1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2019 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"
46 /* The type of functions taking a tree, and some additional data, and
48 typedef int (*tree_fn_t
) (tree
, void*);
50 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
51 instantiations have been deferred, either because their definitions
52 were not yet available, or because we were putting off doing the work. */
53 struct GTY ((chain_next ("%h.next"))) pending_template
55 struct pending_template
*next
;
56 struct tinst_level
*tinst
;
59 static GTY(()) struct pending_template
*pending_templates
;
60 static GTY(()) struct pending_template
*last_pending_template
;
62 int processing_template_parmlist
;
63 static int template_header_count
;
65 static GTY(()) tree saved_trees
;
66 static vec
<int> inline_parm_levels
;
68 static GTY(()) struct tinst_level
*current_tinst_level
;
70 static GTY(()) tree saved_access_scope
;
72 /* Live only within one (recursive) call to tsubst_expr. We use
73 this to pass the statement expression node from the STMT_EXPR
74 to the EXPR_STMT that is its result. */
75 static tree cur_stmt_expr
;
77 // -------------------------------------------------------------------------- //
78 // Local Specialization Stack
80 // Implementation of the RAII helper for creating new local
82 local_specialization_stack::local_specialization_stack (lss_policy policy
)
83 : saved (local_specializations
)
85 if (policy
== lss_blank
|| !saved
)
86 local_specializations
= new hash_map
<tree
, tree
>;
88 local_specializations
= new hash_map
<tree
, tree
>(*saved
);
91 local_specialization_stack::~local_specialization_stack ()
93 delete local_specializations
;
94 local_specializations
= saved
;
97 /* True if we've recursed into fn_type_unification too many times. */
98 static bool excessive_deduction_depth
;
100 struct GTY((for_user
)) spec_entry
107 struct spec_hasher
: ggc_ptr_hash
<spec_entry
>
109 static hashval_t
hash (spec_entry
*);
110 static bool equal (spec_entry
*, spec_entry
*);
113 static GTY (()) hash_table
<spec_hasher
> *decl_specializations
;
115 static GTY (()) hash_table
<spec_hasher
> *type_specializations
;
117 /* Contains canonical template parameter types. The vector is indexed by
118 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
119 TREE_LIST, whose TREE_VALUEs contain the canonical template
120 parameters of various types and levels. */
121 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
123 #define UNIFY_ALLOW_NONE 0
124 #define UNIFY_ALLOW_MORE_CV_QUAL 1
125 #define UNIFY_ALLOW_LESS_CV_QUAL 2
126 #define UNIFY_ALLOW_DERIVED 4
127 #define UNIFY_ALLOW_INTEGER 8
128 #define UNIFY_ALLOW_OUTER_LEVEL 16
129 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
130 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
132 enum template_base_result
{
134 tbr_ambiguous_baseclass
,
138 static void push_access_scope (tree
);
139 static void pop_access_scope (tree
);
140 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
141 unification_kind_t
, int,
143 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
144 unification_kind_t
, int, bool, bool);
145 static int unify (tree
, tree
, tree
, tree
, int, bool);
146 static void add_pending_template (tree
);
147 static tree
reopen_tinst_level (struct tinst_level
*);
148 static tree
tsubst_initializer_list (tree
, tree
);
149 static tree
get_partial_spec_bindings (tree
, tree
, tree
);
150 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
152 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
154 static void tsubst_enum (tree
, tree
, tree
);
155 static tree
add_to_template_args (tree
, tree
);
156 static tree
add_outermost_template_args (tree
, tree
);
157 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
158 static int check_non_deducible_conversion (tree
, tree
, int, int,
159 struct conversion
**, bool);
160 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
162 static int type_unification_real (tree
, tree
, tree
, const tree
*,
163 unsigned int, int, unification_kind_t
,
164 vec
<deferred_access_check
, va_gc
> **,
166 static void note_template_header (int);
167 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
168 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
169 static tree
convert_template_argument (tree
, tree
, tree
,
170 tsubst_flags_t
, int, tree
);
171 static tree
for_each_template_parm (tree
, tree_fn_t
, void*,
172 hash_set
<tree
> *, bool, tree_fn_t
= NULL
);
173 static tree
expand_template_argument_pack (tree
);
174 static tree
build_template_parm_index (int, int, int, tree
, tree
);
175 static bool inline_needs_template_parms (tree
, bool);
176 static void push_inline_template_parms_recursive (tree
, int);
177 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
178 static int mark_template_parm (tree
, void *);
179 static int template_parm_this_level_p (tree
, void *);
180 static tree
tsubst_friend_function (tree
, tree
);
181 static tree
tsubst_friend_class (tree
, tree
);
182 static int can_complete_type_without_circularity (tree
);
183 static tree
get_bindings (tree
, tree
, tree
, bool);
184 static int template_decl_level (tree
);
185 static int check_cv_quals_for_unify (int, tree
, tree
);
186 static void template_parm_level_and_index (tree
, int*, int*);
187 static int unify_pack_expansion (tree
, tree
, tree
,
188 tree
, unification_kind_t
, bool, bool);
189 static tree
copy_template_args (tree
);
190 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
191 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
192 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
193 static tree
most_specialized_partial_spec (tree
, tsubst_flags_t
);
194 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
195 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
196 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
197 static bool check_specialization_scope (void);
198 static tree
process_partial_specialization (tree
);
199 static void set_current_access_from_decl (tree
);
200 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
202 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
203 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
205 static bool template_template_parm_bindings_ok_p (tree
, tree
);
206 static void tsubst_default_arguments (tree
, tsubst_flags_t
);
207 static tree
for_each_template_parm_r (tree
*, int *, void *);
208 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
209 static void copy_default_args_to_explicit_spec (tree
);
210 static bool invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
211 static bool dependent_template_arg_p (tree
);
212 static bool any_template_arguments_need_structural_equality_p (tree
);
213 static bool dependent_type_p_r (tree
);
214 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
215 static tree
tsubst_decl (tree
, tree
, tsubst_flags_t
);
216 static void perform_typedefs_access_check (tree tmpl
, tree targs
);
217 static void append_type_to_template_for_access_check_1 (tree
, tree
, tree
,
219 static tree
listify (tree
);
220 static tree
listify_autos (tree
, tree
);
221 static tree
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
222 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
223 static bool complex_alias_template_p (const_tree tmpl
);
224 static tree
tsubst_attributes (tree
, tree
, tsubst_flags_t
, tree
);
225 static tree
canonicalize_expr_argument (tree
, tsubst_flags_t
);
226 static tree
make_argument_pack (tree
);
227 static void register_parameter_specializations (tree
, tree
);
228 static tree
enclosing_instantiation_of (tree tctx
);
230 /* Make the current scope suitable for access checking when we are
231 processing T. T can be FUNCTION_DECL for instantiated function
232 template, VAR_DECL for static member variable, or TYPE_DECL for
233 alias template (needed by instantiate_decl). */
236 push_access_scope (tree t
)
238 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
239 || TREE_CODE (t
) == TYPE_DECL
);
241 if (DECL_FRIEND_CONTEXT (t
))
242 push_nested_class (DECL_FRIEND_CONTEXT (t
));
243 else if (DECL_CLASS_SCOPE_P (t
))
244 push_nested_class (DECL_CONTEXT (t
));
246 push_to_top_level ();
248 if (TREE_CODE (t
) == FUNCTION_DECL
)
250 saved_access_scope
= tree_cons
251 (NULL_TREE
, current_function_decl
, saved_access_scope
);
252 current_function_decl
= t
;
256 /* Restore the scope set up by push_access_scope. T is the node we
260 pop_access_scope (tree t
)
262 if (TREE_CODE (t
) == FUNCTION_DECL
)
264 current_function_decl
= TREE_VALUE (saved_access_scope
);
265 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
268 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
271 pop_from_top_level ();
274 /* Do any processing required when DECL (a member template
275 declaration) is finished. Returns the TEMPLATE_DECL corresponding
276 to DECL, unless it is a specialization, in which case the DECL
277 itself is returned. */
280 finish_member_template_decl (tree decl
)
282 if (decl
== error_mark_node
)
283 return error_mark_node
;
285 gcc_assert (DECL_P (decl
));
287 if (TREE_CODE (decl
) == TYPE_DECL
)
291 type
= TREE_TYPE (decl
);
292 if (type
== error_mark_node
)
293 return error_mark_node
;
294 if (MAYBE_CLASS_TYPE_P (type
)
295 && CLASSTYPE_TEMPLATE_INFO (type
)
296 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
298 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
299 check_member_template (tmpl
);
304 else if (TREE_CODE (decl
) == FIELD_DECL
)
305 error ("data member %qD cannot be a member template", decl
);
306 else if (DECL_TEMPLATE_INFO (decl
))
308 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
310 check_member_template (DECL_TI_TEMPLATE (decl
));
311 return DECL_TI_TEMPLATE (decl
);
317 error ("invalid member template declaration %qD", decl
);
319 return error_mark_node
;
322 /* Create a template info node. */
325 build_template_info (tree template_decl
, tree template_args
)
327 tree result
= make_node (TEMPLATE_INFO
);
328 TI_TEMPLATE (result
) = template_decl
;
329 TI_ARGS (result
) = template_args
;
333 /* Return the template info node corresponding to T, whatever T is. */
336 get_template_info (const_tree t
)
338 tree tinfo
= NULL_TREE
;
340 if (!t
|| t
== error_mark_node
)
343 if (TREE_CODE (t
) == NAMESPACE_DECL
344 || TREE_CODE (t
) == PARM_DECL
)
347 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
348 tinfo
= DECL_TEMPLATE_INFO (t
);
350 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
353 if (OVERLOAD_TYPE_P (t
))
354 tinfo
= TYPE_TEMPLATE_INFO (t
);
355 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
356 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
361 /* Returns the template nesting level of the indicated class TYPE.
371 A<T>::B<U> has depth two, while A<T> has depth one.
372 Both A<T>::B<int> and A<int>::B<U> have depth one, if
373 they are instantiations, not specializations.
375 This function is guaranteed to return 0 if passed NULL_TREE so
376 that, for example, `template_class_depth (current_class_type)' is
380 template_class_depth (tree type
)
384 for (depth
= 0; type
&& TREE_CODE (type
) != NAMESPACE_DECL
; )
386 tree tinfo
= get_template_info (type
);
388 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
389 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
393 type
= CP_DECL_CONTEXT (type
);
394 else if (LAMBDA_TYPE_P (type
))
395 type
= LAMBDA_TYPE_EXTRA_SCOPE (type
);
397 type
= CP_TYPE_CONTEXT (type
);
403 /* Return TRUE if NODE instantiates a template that has arguments of
404 its own, be it directly a primary template or indirectly through a
405 partial specializations. */
407 instantiates_primary_template_p (tree node
)
409 tree tinfo
= get_template_info (node
);
413 tree tmpl
= TI_TEMPLATE (tinfo
);
414 if (PRIMARY_TEMPLATE_P (tmpl
))
417 if (!DECL_TEMPLATE_SPECIALIZATION (tmpl
))
420 /* So now we know we have a specialization, but it could be a full
421 or a partial specialization. To tell which, compare the depth of
422 its template arguments with those of its context. */
424 tree ctxt
= DECL_CONTEXT (tmpl
);
425 tree ctinfo
= get_template_info (ctxt
);
429 return (TMPL_ARGS_DEPTH (TI_ARGS (tinfo
))
430 > TMPL_ARGS_DEPTH (TI_ARGS (ctinfo
)));
433 /* Subroutine of maybe_begin_member_template_processing.
434 Returns true if processing DECL needs us to push template parms. */
437 inline_needs_template_parms (tree decl
, bool nsdmi
)
439 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
442 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
443 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
446 /* Subroutine of maybe_begin_member_template_processing.
447 Push the template parms in PARMS, starting from LEVELS steps into the
448 chain, and ending at the beginning, since template parms are listed
452 push_inline_template_parms_recursive (tree parmlist
, int levels
)
454 tree parms
= TREE_VALUE (parmlist
);
458 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
460 ++processing_template_decl
;
461 current_template_parms
462 = tree_cons (size_int (processing_template_decl
),
463 parms
, current_template_parms
);
464 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
466 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
468 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
470 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
472 if (error_operand_p (parm
))
475 gcc_assert (DECL_P (parm
));
477 switch (TREE_CODE (parm
))
485 /* Push the CONST_DECL. */
486 pushdecl (TEMPLATE_PARM_DECL (DECL_INITIAL (parm
)));
495 /* Restore the template parameter context for a member template, a
496 friend template defined in a class definition, or a non-template
497 member of template class. */
500 maybe_begin_member_template_processing (tree decl
)
504 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
508 tree ctx
= DECL_CONTEXT (decl
);
509 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
510 /* Disregard full specializations (c++/60999). */
511 && uses_template_parms (ctx
)
512 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
515 if (inline_needs_template_parms (decl
, nsdmi
))
517 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
518 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
520 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
523 parms
= TREE_CHAIN (parms
);
526 push_inline_template_parms_recursive (parms
, levels
);
529 /* Remember how many levels of template parameters we pushed so that
530 we can pop them later. */
531 inline_parm_levels
.safe_push (levels
);
534 /* Undo the effects of maybe_begin_member_template_processing. */
537 maybe_end_member_template_processing (void)
542 if (inline_parm_levels
.length () == 0)
545 last
= inline_parm_levels
.pop ();
546 for (i
= 0; i
< last
; ++i
)
548 --processing_template_decl
;
549 current_template_parms
= TREE_CHAIN (current_template_parms
);
554 /* Return a new template argument vector which contains all of ARGS,
555 but has as its innermost set of arguments the EXTRA_ARGS. */
558 add_to_template_args (tree args
, tree extra_args
)
565 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
568 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
569 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
571 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
572 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
574 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
575 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
580 /* Like add_to_template_args, but only the outermost ARGS are added to
581 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
582 (EXTRA_ARGS) levels are added. This function is used to combine
583 the template arguments from a partial instantiation with the
584 template arguments used to attain the full instantiation from the
585 partial instantiation. */
588 add_outermost_template_args (tree args
, tree extra_args
)
592 /* If there are more levels of EXTRA_ARGS than there are ARGS,
593 something very fishy is going on. */
594 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
596 /* If *all* the new arguments will be the EXTRA_ARGS, just return
598 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
601 /* For the moment, we make ARGS look like it contains fewer levels. */
602 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
604 new_args
= add_to_template_args (args
, extra_args
);
606 /* Now, we restore ARGS to its full dimensions. */
607 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
612 /* Return the N levels of innermost template arguments from the ARGS. */
615 get_innermost_template_args (tree args
, int n
)
623 /* If N is 1, just return the innermost set of template arguments. */
625 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
627 /* If we're not removing anything, just return the arguments we were
629 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
630 gcc_assert (extra_levels
>= 0);
631 if (extra_levels
== 0)
634 /* Make a new set of arguments, not containing the outer arguments. */
635 new_args
= make_tree_vec (n
);
636 for (i
= 1; i
<= n
; ++i
)
637 SET_TMPL_ARGS_LEVEL (new_args
, i
,
638 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
643 /* The inverse of get_innermost_template_args: Return all but the innermost
644 EXTRA_LEVELS levels of template arguments from the ARGS. */
647 strip_innermost_template_args (tree args
, int extra_levels
)
650 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
655 /* If N is 1, just return the outermost set of template arguments. */
657 return TMPL_ARGS_LEVEL (args
, 1);
659 /* If we're not removing anything, just return the arguments we were
661 gcc_assert (extra_levels
>= 0);
662 if (extra_levels
== 0)
665 /* Make a new set of arguments, not containing the inner arguments. */
666 new_args
= make_tree_vec (n
);
667 for (i
= 1; i
<= n
; ++i
)
668 SET_TMPL_ARGS_LEVEL (new_args
, i
,
669 TMPL_ARGS_LEVEL (args
, i
));
674 /* We've got a template header coming up; push to a new level for storing
678 begin_template_parm_list (void)
680 /* We use a non-tag-transparent scope here, which causes pushtag to
681 put tags in this scope, rather than in the enclosing class or
682 namespace scope. This is the right thing, since we want
683 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
684 global template class, push_template_decl handles putting the
685 TEMPLATE_DECL into top-level scope. For a nested template class,
688 template <class T> struct S1 {
689 template <class T> struct S2 {};
692 pushtag contains special code to insert the TEMPLATE_DECL for S2
693 at the right scope. */
694 begin_scope (sk_template_parms
, NULL
);
695 ++processing_template_decl
;
696 ++processing_template_parmlist
;
697 note_template_header (0);
699 /* Add a dummy parameter level while we process the parameter list. */
700 current_template_parms
701 = tree_cons (size_int (processing_template_decl
),
703 current_template_parms
);
706 /* This routine is called when a specialization is declared. If it is
707 invalid to declare a specialization here, an error is reported and
708 false is returned, otherwise this routine will return true. */
711 check_specialization_scope (void)
713 tree scope
= current_scope ();
717 An explicit specialization shall be declared in the namespace of
718 which the template is a member, or, for member templates, in the
719 namespace of which the enclosing class or enclosing class
720 template is a member. An explicit specialization of a member
721 function, member class or static data member of a class template
722 shall be declared in the namespace of which the class template
724 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
726 error ("explicit specialization in non-namespace scope %qD", scope
);
732 In an explicit specialization declaration for a member of a class
733 template or a member template that appears in namespace scope,
734 the member template and some of its enclosing class templates may
735 remain unspecialized, except that the declaration shall not
736 explicitly specialize a class member template if its enclosing
737 class templates are not explicitly specialized as well. */
738 if (current_template_parms
)
740 error ("enclosing class templates are not explicitly specialized");
747 /* We've just seen template <>. */
750 begin_specialization (void)
752 begin_scope (sk_template_spec
, NULL
);
753 note_template_header (1);
754 return check_specialization_scope ();
757 /* Called at then end of processing a declaration preceded by
761 end_specialization (void)
764 reset_specialization ();
767 /* Any template <>'s that we have seen thus far are not referring to a
768 function specialization. */
771 reset_specialization (void)
773 processing_specialization
= 0;
774 template_header_count
= 0;
777 /* We've just seen a template header. If SPECIALIZATION is nonzero,
778 it was of the form template <>. */
781 note_template_header (int specialization
)
783 processing_specialization
= specialization
;
784 template_header_count
++;
787 /* We're beginning an explicit instantiation. */
790 begin_explicit_instantiation (void)
792 gcc_assert (!processing_explicit_instantiation
);
793 processing_explicit_instantiation
= true;
798 end_explicit_instantiation (void)
800 gcc_assert (processing_explicit_instantiation
);
801 processing_explicit_instantiation
= false;
804 /* An explicit specialization or partial specialization of TMPL is being
805 declared. Check that the namespace in which the specialization is
806 occurring is permissible. Returns false iff it is invalid to
807 specialize TMPL in the current namespace. */
810 check_specialization_namespace (tree tmpl
)
812 tree tpl_ns
= decl_namespace_context (tmpl
);
816 An explicit specialization shall be declared in a namespace enclosing the
817 specialized template. An explicit specialization whose declarator-id is
818 not qualified shall be declared in the nearest enclosing namespace of the
819 template, or, if the namespace is inline (7.3.1), any namespace from its
820 enclosing namespace set. */
821 if (current_scope() != DECL_CONTEXT (tmpl
)
822 && !at_namespace_scope_p ())
824 error ("specialization of %qD must appear at namespace scope", tmpl
);
828 if (is_nested_namespace (current_namespace
, tpl_ns
, cxx_dialect
< cxx11
))
829 /* Same or enclosing namespace. */
833 auto_diagnostic_group d
;
834 if (permerror (input_location
,
835 "specialization of %qD in different namespace", tmpl
))
836 inform (DECL_SOURCE_LOCATION (tmpl
),
837 " from definition of %q#D", tmpl
);
842 /* SPEC is an explicit instantiation. Check that it is valid to
843 perform this explicit instantiation in the current namespace. */
846 check_explicit_instantiation_namespace (tree spec
)
850 /* DR 275: An explicit instantiation shall appear in an enclosing
851 namespace of its template. */
852 ns
= decl_namespace_context (spec
);
853 if (!is_nested_namespace (current_namespace
, ns
))
854 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
855 "(which does not enclose namespace %qD)",
856 spec
, current_namespace
, ns
);
859 // Returns the type of a template specialization only if that
860 // specialization needs to be defined. Otherwise (e.g., if the type has
861 // already been defined), the function returns NULL_TREE.
863 maybe_new_partial_specialization (tree type
)
865 // An implicit instantiation of an incomplete type implies
866 // the definition of a new class template.
868 // template<typename T>
871 // template<typename T>
874 // Here, S<T*> is an implicit instantiation of S whose type
876 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
) && !COMPLETE_TYPE_P (type
))
879 // It can also be the case that TYPE is a completed specialization.
880 // Continuing the previous example, suppose we also declare:
882 // template<typename T>
883 // requires Integral<T>
886 // Here, S<T*> refers to the specialization S<T*> defined
887 // above. However, we need to differentiate definitions because
888 // we intend to define a new partial specialization. In this case,
889 // we rely on the fact that the constraints are different for
890 // this declaration than that above.
892 // Note that we also get here for injected class names and
893 // late-parsed template definitions. We must ensure that we
894 // do not create new type declarations for those cases.
895 if (flag_concepts
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
897 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
898 tree args
= CLASSTYPE_TI_ARGS (type
);
900 // If there are no template parameters, this cannot be a new
901 // partial template specializtion?
902 if (!current_template_parms
)
905 // The injected-class-name is not a new partial specialization.
906 if (DECL_SELF_REFERENCE_P (TYPE_NAME (type
)))
909 // If the constraints are not the same as those of the primary
910 // then, we can probably create a new specialization.
911 tree type_constr
= current_template_constraints ();
913 if (type
== TREE_TYPE (tmpl
))
915 tree main_constr
= get_constraints (tmpl
);
916 if (equivalent_constraints (type_constr
, main_constr
))
920 // Also, if there's a pre-existing specialization with matching
921 // constraints, then this also isn't new.
922 tree specs
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
925 tree spec_tmpl
= TREE_VALUE (specs
);
926 tree spec_args
= TREE_PURPOSE (specs
);
927 tree spec_constr
= get_constraints (spec_tmpl
);
928 if (comp_template_args (args
, spec_args
)
929 && equivalent_constraints (type_constr
, spec_constr
))
931 specs
= TREE_CHAIN (specs
);
934 // Create a new type node (and corresponding type decl)
935 // for the newly declared specialization.
936 tree t
= make_class_type (TREE_CODE (type
));
937 CLASSTYPE_DECLARED_CLASS (t
) = CLASSTYPE_DECLARED_CLASS (type
);
938 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (tmpl
, args
));
940 /* We only need a separate type node for storing the definition of this
941 partial specialization; uses of S<T*> are unconstrained, so all are
942 equivalent. So keep TYPE_CANONICAL the same. */
943 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
945 // Build the corresponding type decl.
946 tree d
= create_implicit_typedef (DECL_NAME (tmpl
), t
);
947 DECL_CONTEXT (d
) = TYPE_CONTEXT (t
);
948 DECL_SOURCE_LOCATION (d
) = input_location
;
956 /* The TYPE is being declared. If it is a template type, that means it
957 is a partial specialization. Do appropriate error-checking. */
960 maybe_process_partial_specialization (tree type
)
964 if (type
== error_mark_node
)
965 return error_mark_node
;
967 /* A lambda that appears in specialization context is not itself a
969 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
972 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
974 error ("name of class shadows template template parameter %qD",
976 return error_mark_node
;
979 context
= TYPE_CONTEXT (type
);
981 if (TYPE_ALIAS_P (type
))
983 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (type
);
985 if (tinfo
&& DECL_ALIAS_TEMPLATE_P (TI_TEMPLATE (tinfo
)))
986 error ("specialization of alias template %qD",
987 TI_TEMPLATE (tinfo
));
989 error ("explicit specialization of non-template %qT", type
);
990 return error_mark_node
;
992 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
994 /* This is for ordinary explicit specialization and partial
995 specialization of a template class such as:
997 template <> class C<int>;
1001 template <class T> class C<T*>;
1003 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
1005 if (tree t
= maybe_new_partial_specialization (type
))
1007 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (t
))
1008 && !at_namespace_scope_p ())
1009 return error_mark_node
;
1010 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t
);
1011 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (t
)) = input_location
;
1012 if (processing_template_decl
)
1014 tree decl
= push_template_decl (TYPE_MAIN_DECL (t
));
1015 if (decl
== error_mark_node
)
1016 return error_mark_node
;
1017 return TREE_TYPE (decl
);
1020 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
1021 error ("specialization of %qT after instantiation", type
);
1022 else if (errorcount
&& !processing_specialization
1023 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
1024 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
1025 /* Trying to define a specialization either without a template<> header
1026 or in an inappropriate place. We've already given an error, so just
1027 bail now so we don't actually define the specialization. */
1028 return error_mark_node
;
1030 else if (CLASS_TYPE_P (type
)
1031 && !CLASSTYPE_USE_TEMPLATE (type
)
1032 && CLASSTYPE_TEMPLATE_INFO (type
)
1033 && context
&& CLASS_TYPE_P (context
)
1034 && CLASSTYPE_TEMPLATE_INFO (context
))
1036 /* This is for an explicit specialization of member class
1037 template according to [temp.expl.spec/18]:
1039 template <> template <class U> class C<int>::D;
1041 The context `C<int>' must be an implicit instantiation.
1042 Otherwise this is just a member class template declared
1045 template <> class C<int> { template <class U> class D; };
1046 template <> template <class U> class C<int>::D;
1048 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1049 while in the second case, `C<int>::D' is a primary template
1050 and `C<T>::D' may not exist. */
1052 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
1053 && !COMPLETE_TYPE_P (type
))
1056 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1058 if (current_namespace
1059 != decl_namespace_context (tmpl
))
1061 if (permerror (input_location
,
1062 "specialization of %qD in different namespace",
1064 inform (DECL_SOURCE_LOCATION (tmpl
),
1065 "from definition of %q#D", tmpl
);
1068 /* Check for invalid specialization after instantiation:
1070 template <> template <> class C<int>::D<int>;
1071 template <> template <class U> class C<int>::D; */
1073 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
1074 t
; t
= TREE_CHAIN (t
))
1076 tree inst
= TREE_VALUE (t
);
1077 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
1078 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
1080 /* We already have a full specialization of this partial
1081 instantiation, or a full specialization has been
1082 looked up but not instantiated. Reassign it to the
1083 new member specialization template. */
1087 elt
.tmpl
= most_general_template (tmpl
);
1088 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
1091 type_specializations
->remove_elt (&elt
);
1094 CLASSTYPE_TI_ARGS (inst
)
1095 = elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
1098 = type_specializations
->find_slot (&elt
, INSERT
);
1099 entry
= ggc_alloc
<spec_entry
> ();
1104 /* But if we've had an implicit instantiation, that's a
1105 problem ([temp.expl.spec]/6). */
1106 error ("specialization %qT after instantiation %qT",
1110 /* Mark TYPE as a specialization. And as a result, we only
1111 have one level of template argument for the innermost
1113 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
1114 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
1115 CLASSTYPE_TI_ARGS (type
)
1116 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
1119 else if (processing_specialization
)
1121 /* Someday C++0x may allow for enum template specialization. */
1122 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
1123 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
1124 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
1125 "of %qD not allowed by ISO C++", type
);
1128 error ("explicit specialization of non-template %qT", type
);
1129 return error_mark_node
;
1136 /* Returns nonzero if we can optimize the retrieval of specializations
1137 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1138 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1141 optimize_specialization_lookup_p (tree tmpl
)
1143 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
1144 && DECL_CLASS_SCOPE_P (tmpl
)
1145 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1147 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
1148 /* The optimized lookup depends on the fact that the
1149 template arguments for the member function template apply
1150 purely to the containing class, which is not true if the
1151 containing class is an explicit or partial
1153 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1154 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1155 && !DECL_CONV_FN_P (tmpl
)
1156 /* It is possible to have a template that is not a member
1157 template and is not a member of a template class:
1159 template <typename T>
1160 struct S { friend A::f(); };
1162 Here, the friend function is a template, but the context does
1163 not have template information. The optimized lookup relies
1164 on having ARGS be the template arguments for both the class
1165 and the function template. */
1166 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1169 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1170 gone through coerce_template_parms by now. */
1173 verify_unstripped_args_1 (tree inner
)
1175 for (int i
= 0; i
< TREE_VEC_LENGTH (inner
); ++i
)
1177 tree arg
= TREE_VEC_ELT (inner
, i
);
1178 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1180 else if (TYPE_P (arg
))
1181 gcc_assert (strip_typedefs (arg
, NULL
) == arg
);
1182 else if (ARGUMENT_PACK_P (arg
))
1183 verify_unstripped_args_1 (ARGUMENT_PACK_ARGS (arg
));
1184 else if (strip_typedefs (TREE_TYPE (arg
), NULL
) != TREE_TYPE (arg
))
1185 /* Allow typedefs on the type of a non-type argument, since a
1186 parameter can have them. */;
1188 gcc_assert (strip_typedefs_expr (arg
, NULL
) == arg
);
1193 verify_unstripped_args (tree args
)
1195 ++processing_template_decl
;
1196 if (!any_dependent_template_arguments_p (args
))
1197 verify_unstripped_args_1 (INNERMOST_TEMPLATE_ARGS (args
));
1198 --processing_template_decl
;
1201 /* Retrieve the specialization (in the sense of [temp.spec] - a
1202 specialization is either an instantiation or an explicit
1203 specialization) of TMPL for the given template ARGS. If there is
1204 no such specialization, return NULL_TREE. The ARGS are a vector of
1205 arguments, or a vector of vectors of arguments, in the case of
1206 templates with more than one level of parameters.
1208 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1209 then we search for a partial specialization matching ARGS. This
1210 parameter is ignored if TMPL is not a class template.
1212 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1213 result is a NONTYPE_ARGUMENT_PACK. */
1216 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1218 if (tmpl
== NULL_TREE
)
1221 if (args
== error_mark_node
)
1224 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1225 || TREE_CODE (tmpl
) == FIELD_DECL
);
1227 /* There should be as many levels of arguments as there are
1228 levels of parameters. */
1229 gcc_assert (TMPL_ARGS_DEPTH (args
)
1230 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1231 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1232 : template_class_depth (DECL_CONTEXT (tmpl
))));
1235 verify_unstripped_args (args
);
1237 /* Lambda functions in templates aren't instantiated normally, but through
1238 tsubst_lambda_expr. */
1239 if (lambda_fn_in_template_p (tmpl
))
1242 if (optimize_specialization_lookup_p (tmpl
))
1244 /* The template arguments actually apply to the containing
1245 class. Find the class specialization with those
1247 tree class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1248 tree class_specialization
1249 = retrieve_specialization (class_template
, args
, 0);
1250 if (!class_specialization
)
1253 /* Find the instance of TMPL. */
1254 tree fns
= get_class_binding (class_specialization
, DECL_NAME (tmpl
));
1255 for (ovl_iterator
iter (fns
); iter
; ++iter
)
1258 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1259 /* using-declarations can add base methods to the method vec,
1260 and we don't want those here. */
1261 && DECL_CONTEXT (fn
) == class_specialization
)
1270 hash_table
<spec_hasher
> *specializations
;
1274 elt
.spec
= NULL_TREE
;
1276 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1277 specializations
= type_specializations
;
1279 specializations
= decl_specializations
;
1282 hash
= spec_hasher::hash (&elt
);
1283 found
= specializations
->find_with_hash (&elt
, hash
);
1291 /* Like retrieve_specialization, but for local declarations. */
1294 retrieve_local_specialization (tree tmpl
)
1296 if (local_specializations
== NULL
)
1299 tree
*slot
= local_specializations
->get (tmpl
);
1300 return slot
? *slot
: NULL_TREE
;
1303 /* Returns nonzero iff DECL is a specialization of TMPL. */
1306 is_specialization_of (tree decl
, tree tmpl
)
1310 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1314 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1320 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1322 for (t
= TREE_TYPE (decl
);
1324 t
= CLASSTYPE_USE_TEMPLATE (t
)
1325 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1326 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1333 /* Returns nonzero iff DECL is a specialization of friend declaration
1334 FRIEND_DECL according to [temp.friend]. */
1337 is_specialization_of_friend (tree decl
, tree friend_decl
)
1339 bool need_template
= true;
1342 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1343 || TREE_CODE (decl
) == TYPE_DECL
);
1345 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1346 of a template class, we want to check if DECL is a specialization
1348 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1349 && DECL_TEMPLATE_INFO (friend_decl
)
1350 && !DECL_USE_TEMPLATE (friend_decl
))
1352 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1353 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1354 need_template
= false;
1356 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1357 && !PRIMARY_TEMPLATE_P (friend_decl
))
1358 need_template
= false;
1360 /* There is nothing to do if this is not a template friend. */
1361 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1364 if (is_specialization_of (decl
, friend_decl
))
1368 A member of a class template may be declared to be a friend of a
1369 non-template class. In this case, the corresponding member of
1370 every specialization of the class template is a friend of the
1371 class granting friendship.
1373 For example, given a template friend declaration
1375 template <class T> friend void A<T>::f();
1377 the member function below is considered a friend
1379 template <> struct A<int> {
1383 For this type of template friend, TEMPLATE_DEPTH below will be
1384 nonzero. To determine if DECL is a friend of FRIEND, we first
1385 check if the enclosing class is a specialization of another. */
1387 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1389 && DECL_CLASS_SCOPE_P (decl
)
1390 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1391 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1393 /* Next, we check the members themselves. In order to handle
1394 a few tricky cases, such as when FRIEND_DECL's are
1396 template <class T> friend void A<T>::g(T t);
1397 template <class T> template <T t> friend void A<T>::h();
1401 void A<int>::g(int);
1402 template <int> void A<int>::h();
1404 we need to figure out ARGS, the template arguments from
1405 the context of DECL. This is required for template substitution
1406 of `T' in the function parameter of `g' and template parameter
1407 of `h' in the above examples. Here ARGS corresponds to `int'. */
1409 tree context
= DECL_CONTEXT (decl
);
1410 tree args
= NULL_TREE
;
1411 int current_depth
= 0;
1413 while (current_depth
< template_depth
)
1415 if (CLASSTYPE_TEMPLATE_INFO (context
))
1417 if (current_depth
== 0)
1418 args
= TYPE_TI_ARGS (context
);
1420 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1423 context
= TYPE_CONTEXT (context
);
1426 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1431 tree friend_args_type
;
1432 tree decl_args_type
;
1434 /* Make sure that both DECL and FRIEND_DECL are templates or
1436 is_template
= DECL_TEMPLATE_INFO (decl
)
1437 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1438 if (need_template
^ is_template
)
1440 else if (is_template
)
1442 /* If both are templates, check template parameter list. */
1444 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1446 if (!comp_template_parms
1447 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1451 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1454 decl_type
= TREE_TYPE (decl
);
1456 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1457 tf_none
, NULL_TREE
);
1458 if (friend_type
== error_mark_node
)
1461 /* Check if return types match. */
1462 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1465 /* Check if function parameter types match, ignoring the
1466 `this' parameter. */
1467 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1468 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1469 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1470 friend_args_type
= TREE_CHAIN (friend_args_type
);
1471 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1472 decl_args_type
= TREE_CHAIN (decl_args_type
);
1474 return compparms (decl_args_type
, friend_args_type
);
1478 /* DECL is a TYPE_DECL */
1480 tree decl_type
= TREE_TYPE (decl
);
1482 /* Make sure that both DECL and FRIEND_DECL are templates or
1485 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1486 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1488 if (need_template
^ is_template
)
1490 else if (is_template
)
1493 /* If both are templates, check the name of the two
1494 TEMPLATE_DECL's first because is_friend didn't. */
1495 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1496 != DECL_NAME (friend_decl
))
1499 /* Now check template parameter list. */
1501 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1503 return comp_template_parms
1504 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1508 return (DECL_NAME (decl
)
1509 == DECL_NAME (friend_decl
));
1515 /* Register the specialization SPEC as a specialization of TMPL with
1516 the indicated ARGS. IS_FRIEND indicates whether the specialization
1517 is actually just a friend declaration. ATTRLIST is the list of
1518 attributes that the specialization is declared with or NULL when
1519 it isn't. Returns SPEC, or an equivalent prior declaration, if
1522 We also store instantiations of field packs in the hash table, even
1523 though they are not themselves templates, to make lookup easier. */
1526 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1530 spec_entry
**slot
= NULL
;
1533 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1534 || (TREE_CODE (tmpl
) == FIELD_DECL
1535 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1537 if (TREE_CODE (spec
) == FUNCTION_DECL
1538 && uses_template_parms (DECL_TI_ARGS (spec
)))
1539 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1540 register it; we want the corresponding TEMPLATE_DECL instead.
1541 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1542 the more obvious `uses_template_parms (spec)' to avoid problems
1543 with default function arguments. In particular, given
1544 something like this:
1546 template <class T> void f(T t1, T t = T())
1548 the default argument expression is not substituted for in an
1549 instantiation unless and until it is actually needed. */
1552 if (optimize_specialization_lookup_p (tmpl
))
1553 /* We don't put these specializations in the hash table, but we might
1554 want to give an error about a mismatch. */
1555 fn
= retrieve_specialization (tmpl
, args
, 0);
1563 hash
= spec_hasher::hash (&elt
);
1566 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1568 fn
= ((spec_entry
*) *slot
)->spec
;
1573 /* We can sometimes try to re-register a specialization that we've
1574 already got. In particular, regenerate_decl_from_template calls
1575 duplicate_decls which will update the specialization list. But,
1576 we'll still get called again here anyhow. It's more convenient
1577 to simply allow this than to try to prevent it. */
1580 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1582 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1584 if (DECL_ODR_USED (fn
)
1585 || DECL_EXPLICIT_INSTANTIATION (fn
))
1587 error ("specialization of %qD after instantiation",
1589 return error_mark_node
;
1594 /* This situation should occur only if the first
1595 specialization is an implicit instantiation, the
1596 second is an explicit specialization, and the
1597 implicit instantiation has not yet been used. That
1598 situation can occur if we have implicitly
1599 instantiated a member function and then specialized
1602 We can also wind up here if a friend declaration that
1603 looked like an instantiation turns out to be a
1606 template <class T> void foo(T);
1607 class S { friend void foo<>(int) };
1608 template <> void foo(int);
1610 We transform the existing DECL in place so that any
1611 pointers to it become pointers to the updated
1614 If there was a definition for the template, but not
1615 for the specialization, we want this to look as if
1616 there were no definition, and vice versa. */
1617 DECL_INITIAL (fn
) = NULL_TREE
;
1618 duplicate_decls (spec
, fn
, is_friend
);
1619 /* The call to duplicate_decls will have applied
1622 An explicit specialization of a function template
1623 is inline only if it is explicitly declared to be,
1624 and independently of whether its function template
1627 to the primary function; now copy the inline bits to
1628 the various clones. */
1629 FOR_EACH_CLONE (clone
, fn
)
1631 DECL_DECLARED_INLINE_P (clone
)
1632 = DECL_DECLARED_INLINE_P (fn
);
1633 DECL_SOURCE_LOCATION (clone
)
1634 = DECL_SOURCE_LOCATION (fn
);
1635 DECL_DELETED_FN (clone
)
1636 = DECL_DELETED_FN (fn
);
1638 check_specialization_namespace (tmpl
);
1643 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1645 tree dd
= duplicate_decls (spec
, fn
, is_friend
);
1646 if (dd
== error_mark_node
)
1647 /* We've already complained in duplicate_decls. */
1648 return error_mark_node
;
1650 if (dd
== NULL_TREE
&& DECL_INITIAL (spec
))
1651 /* Dup decl failed, but this is a new definition. Set the
1652 line number so any errors match this new
1654 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1660 return duplicate_decls (spec
, fn
, is_friend
);
1662 /* A specialization must be declared in the same namespace as the
1663 template it is specializing. */
1664 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1665 && !check_specialization_namespace (tmpl
))
1666 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1668 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1670 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1671 gcc_assert (tmpl
&& args
&& spec
);
1674 if ((TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1675 && PRIMARY_TEMPLATE_P (tmpl
)
1676 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1677 || variable_template_p (tmpl
))
1678 /* If TMPL is a forward declaration of a template function, keep a list
1679 of all specializations in case we need to reassign them to a friend
1680 template later in tsubst_friend_function.
1682 Also keep a list of all variable template instantiations so that
1683 process_partial_specialization can check whether a later partial
1684 specialization would have used it. */
1685 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1686 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1692 /* Returns true iff two spec_entry nodes are equivalent. */
1694 int comparing_specializations
;
1697 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1701 ++comparing_specializations
;
1702 equal
= (e1
->tmpl
== e2
->tmpl
1703 && comp_template_args (e1
->args
, e2
->args
));
1704 if (equal
&& flag_concepts
1705 /* tmpl could be a FIELD_DECL for a capture pack. */
1706 && TREE_CODE (e1
->tmpl
) == TEMPLATE_DECL
1707 && VAR_P (DECL_TEMPLATE_RESULT (e1
->tmpl
))
1708 && uses_template_parms (e1
->args
))
1710 /* Partial specializations of a variable template can be distinguished by
1712 tree c1
= e1
->spec
? get_constraints (e1
->spec
) : NULL_TREE
;
1713 tree c2
= e2
->spec
? get_constraints (e2
->spec
) : NULL_TREE
;
1714 equal
= equivalent_constraints (c1
, c2
);
1716 --comparing_specializations
;
1721 /* Returns a hash for a template TMPL and template arguments ARGS. */
1724 hash_tmpl_and_args (tree tmpl
, tree args
)
1726 hashval_t val
= iterative_hash_object (DECL_UID (tmpl
), 0);
1727 return iterative_hash_template_arg (args
, val
);
1730 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1734 spec_hasher::hash (spec_entry
*e
)
1736 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1739 /* Recursively calculate a hash value for a template argument ARG, for use
1740 in the hash tables of template specializations. */
1743 iterative_hash_template_arg (tree arg
, hashval_t val
)
1745 unsigned HOST_WIDE_INT i
;
1746 enum tree_code code
;
1749 if (arg
== NULL_TREE
)
1750 return iterative_hash_object (arg
, val
);
1755 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1758 code
= TREE_CODE (arg
);
1759 tclass
= TREE_CODE_CLASS (code
);
1761 val
= iterative_hash_object (code
, val
);
1768 case IDENTIFIER_NODE
:
1769 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1773 int i
, len
= TREE_VEC_LENGTH (arg
);
1774 for (i
= 0; i
< len
; ++i
)
1775 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1779 case TYPE_PACK_EXPANSION
:
1780 case EXPR_PACK_EXPANSION
:
1781 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1782 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1784 case TYPE_ARGUMENT_PACK
:
1785 case NONTYPE_ARGUMENT_PACK
:
1786 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1789 for (; arg
; arg
= TREE_CHAIN (arg
))
1790 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1794 for (lkp_iterator
iter (arg
); iter
; ++iter
)
1795 val
= iterative_hash_template_arg (*iter
, val
);
1801 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1802 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1804 val
= iterative_hash_template_arg (field
, val
);
1805 val
= iterative_hash_template_arg (value
, val
);
1811 if (!DECL_ARTIFICIAL (arg
))
1813 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1814 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1816 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1819 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1822 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1823 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1825 case TEMPLATE_PARM_INDEX
:
1826 val
= iterative_hash_template_arg
1827 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1828 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1829 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1832 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1833 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1834 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1837 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1839 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1843 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1844 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1845 val
= iterative_hash_object (code
, val
);
1846 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1849 /* [temp.over.link] Two lambda-expressions are never considered
1852 So just hash the closure type. */
1853 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1856 case IMPLICIT_CONV_EXPR
:
1857 case STATIC_CAST_EXPR
:
1858 case REINTERPRET_CAST_EXPR
:
1859 case CONST_CAST_EXPR
:
1860 case DYNAMIC_CAST_EXPR
:
1862 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1863 /* Now hash operands as usual. */
1868 tree fn
= CALL_EXPR_FN (arg
);
1869 if (tree name
= dependent_name (fn
))
1871 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
1872 val
= iterative_hash_template_arg (TREE_OPERAND (fn
, 1), val
);
1875 val
= iterative_hash_template_arg (fn
, val
);
1876 call_expr_arg_iterator ai
;
1877 for (tree x
= first_call_expr_arg (arg
, &ai
); x
;
1878 x
= next_call_expr_arg (&ai
))
1879 val
= iterative_hash_template_arg (x
, val
);
1890 if (alias_template_specialization_p (arg
))
1892 // We want an alias specialization that survived strip_typedefs
1893 // to hash differently from its TYPE_CANONICAL, to avoid hash
1894 // collisions that compare as different in template_args_equal.
1895 // These could be dependent specializations that strip_typedefs
1896 // left alone, or untouched specializations because
1897 // coerce_template_parms returns the unconverted template
1898 // arguments if it sees incomplete argument packs.
1899 tree ti
= TYPE_ALIAS_TEMPLATE_INFO (arg
);
1900 return hash_tmpl_and_args (TI_TEMPLATE (ti
), TI_ARGS (ti
));
1902 if (TYPE_CANONICAL (arg
))
1903 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1905 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1906 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1907 /* Otherwise just compare the types during lookup. */
1910 case tcc_declaration
:
1912 return iterative_hash_expr (arg
, val
);
1915 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1917 unsigned n
= cp_tree_operand_length (arg
);
1918 for (i
= 0; i
< n
; ++i
)
1919 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1927 /* Unregister the specialization SPEC as a specialization of TMPL.
1928 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1929 if the SPEC was listed as a specialization of TMPL.
1931 Note that SPEC has been ggc_freed, so we can't look inside it. */
1934 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1939 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1940 elt
.args
= TI_ARGS (tinfo
);
1941 elt
.spec
= NULL_TREE
;
1943 entry
= decl_specializations
->find (&elt
);
1946 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1947 gcc_assert (new_spec
!= NULL_TREE
);
1948 entry
->spec
= new_spec
;
1955 /* Like register_specialization, but for local declarations. We are
1956 registering SPEC, an instantiation of TMPL. */
1959 register_local_specialization (tree spec
, tree tmpl
)
1961 gcc_assert (tmpl
!= spec
);
1962 local_specializations
->put (tmpl
, spec
);
1965 /* TYPE is a class type. Returns true if TYPE is an explicitly
1966 specialized class. */
1969 explicit_class_specialization_p (tree type
)
1971 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1973 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1976 /* Print the list of functions at FNS, going through all the overloads
1977 for each element of the list. Alternatively, FNS cannot be a
1978 TREE_LIST, in which case it will be printed together with all the
1981 MORE and *STR should respectively be FALSE and NULL when the function
1982 is called from the outside. They are used internally on recursive
1983 calls. print_candidates manages the two parameters and leaves NULL
1984 in *STR when it ends. */
1987 print_candidates_1 (tree fns
, char **str
, bool more
= false)
1989 if (TREE_CODE (fns
) == TREE_LIST
)
1990 for (; fns
; fns
= TREE_CHAIN (fns
))
1991 print_candidates_1 (TREE_VALUE (fns
), str
, more
|| TREE_CHAIN (fns
));
1993 for (lkp_iterator
iter (fns
); iter
;)
1998 const char *pfx
= *str
;
2002 pfx
= _("candidates are:");
2004 pfx
= _("candidate is:");
2005 *str
= get_spaces (pfx
);
2007 inform (DECL_SOURCE_LOCATION (cand
), "%s %#qD", pfx
, cand
);
2011 /* Print the list of candidate FNS in an error message. FNS can also
2012 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
2015 print_candidates (tree fns
)
2018 print_candidates_1 (fns
, &str
);
2022 /* Get a (possibly) constrained template declaration for the
2023 purpose of ordering candidates. */
2025 get_template_for_ordering (tree list
)
2027 gcc_assert (TREE_CODE (list
) == TREE_LIST
);
2028 tree f
= TREE_VALUE (list
);
2029 if (tree ti
= DECL_TEMPLATE_INFO (f
))
2030 return TI_TEMPLATE (ti
);
2034 /* Among candidates having the same signature, return the
2035 most constrained or NULL_TREE if there is no best candidate.
2036 If the signatures of candidates vary (e.g., template
2037 specialization vs. member function), then there can be no
2040 Note that we don't compare constraints on the functions
2041 themselves, but rather those of their templates. */
2043 most_constrained_function (tree candidates
)
2045 // Try to find the best candidate in a first pass.
2046 tree champ
= candidates
;
2047 for (tree c
= TREE_CHAIN (champ
); c
; c
= TREE_CHAIN (c
))
2049 int winner
= more_constrained (get_template_for_ordering (champ
),
2050 get_template_for_ordering (c
));
2052 champ
= c
; // The candidate is more constrained
2053 else if (winner
== 0)
2054 return NULL_TREE
; // Neither is more constrained
2057 // Verify that the champ is better than previous candidates.
2058 for (tree c
= candidates
; c
!= champ
; c
= TREE_CHAIN (c
)) {
2059 if (!more_constrained (get_template_for_ordering (champ
),
2060 get_template_for_ordering (c
)))
2068 /* Returns the template (one of the functions given by TEMPLATE_ID)
2069 which can be specialized to match the indicated DECL with the
2070 explicit template args given in TEMPLATE_ID. The DECL may be
2071 NULL_TREE if none is available. In that case, the functions in
2072 TEMPLATE_ID are non-members.
2074 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2075 specialization of a member template.
2077 The TEMPLATE_COUNT is the number of references to qualifying
2078 template classes that appeared in the name of the function. See
2079 check_explicit_specialization for a more accurate description.
2081 TSK indicates what kind of template declaration (if any) is being
2082 declared. TSK_TEMPLATE indicates that the declaration given by
2083 DECL, though a FUNCTION_DECL, has template parameters, and is
2084 therefore a template function.
2086 The template args (those explicitly specified and those deduced)
2087 are output in a newly created vector *TARGS_OUT.
2089 If it is impossible to determine the result, an error message is
2090 issued. The error_mark_node is returned to indicate failure. */
2093 determine_specialization (tree template_id
,
2096 int need_member_template
,
2102 tree explicit_targs
;
2103 tree candidates
= NULL_TREE
;
2105 /* A TREE_LIST of templates of which DECL may be a specialization.
2106 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2107 corresponding TREE_PURPOSE is the set of template arguments that,
2108 when used to instantiate the template, would produce a function
2109 with the signature of DECL. */
2110 tree templates
= NULL_TREE
;
2112 cp_binding_level
*b
;
2114 *targs_out
= NULL_TREE
;
2116 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
2117 return error_mark_node
;
2119 /* We shouldn't be specializing a member template of an
2120 unspecialized class template; we already gave an error in
2121 check_specialization_scope, now avoid crashing. */
2123 && template_count
&& DECL_CLASS_SCOPE_P (decl
)
2124 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
2126 gcc_assert (errorcount
);
2127 return error_mark_node
;
2130 fns
= TREE_OPERAND (template_id
, 0);
2131 explicit_targs
= TREE_OPERAND (template_id
, 1);
2133 if (fns
== error_mark_node
)
2134 return error_mark_node
;
2136 /* Check for baselinks. */
2137 if (BASELINK_P (fns
))
2138 fns
= BASELINK_FUNCTIONS (fns
);
2140 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
2142 error ("%qD is not a function template", fns
);
2143 return error_mark_node
;
2145 else if (VAR_P (decl
) && !variable_template_p (fns
))
2147 error ("%qD is not a variable template", fns
);
2148 return error_mark_node
;
2151 /* Count the number of template headers specified for this
2154 for (b
= current_binding_level
;
2155 b
->kind
== sk_template_parms
;
2159 tree orig_fns
= fns
;
2161 if (variable_template_p (fns
))
2163 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns
));
2164 targs
= coerce_template_parms (parms
, explicit_targs
, fns
,
2165 tf_warning_or_error
,
2166 /*req_all*/true, /*use_defarg*/true);
2167 if (targs
!= error_mark_node
)
2168 templates
= tree_cons (targs
, fns
, templates
);
2170 else for (lkp_iterator
iter (fns
); iter
; ++iter
)
2174 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2176 tree decl_arg_types
;
2180 /* In case of explicit specialization, we need to check if
2181 the number of template headers appearing in the specialization
2182 is correct. This is usually done in check_explicit_specialization,
2183 but the check done there cannot be exhaustive when specializing
2184 member functions. Consider the following code:
2186 template <> void A<int>::f(int);
2187 template <> template <> void A<int>::f(int);
2189 Assuming that A<int> is not itself an explicit specialization
2190 already, the first line specializes "f" which is a non-template
2191 member function, whilst the second line specializes "f" which
2192 is a template member function. So both lines are syntactically
2193 correct, and check_explicit_specialization does not reject
2196 Here, we can do better, as we are matching the specialization
2197 against the declarations. We count the number of template
2198 headers, and we check if they match TEMPLATE_COUNT + 1
2199 (TEMPLATE_COUNT is the number of qualifying template classes,
2200 plus there must be another header for the member template
2203 Notice that if header_count is zero, this is not a
2204 specialization but rather a template instantiation, so there
2205 is no check we can perform here. */
2206 if (header_count
&& header_count
!= template_count
+ 1)
2209 /* Check that the number of template arguments at the
2210 innermost level for DECL is the same as for FN. */
2211 if (current_binding_level
->kind
== sk_template_parms
2212 && !current_binding_level
->explicit_spec_p
2213 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
2214 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
2215 (current_template_parms
))))
2218 /* DECL might be a specialization of FN. */
2219 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2220 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2222 /* For a non-static member function, we need to make sure
2223 that the const qualification is the same. Since
2224 get_bindings does not try to merge the "this" parameter,
2225 we must do the comparison explicitly. */
2226 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
2228 if (!same_type_p (TREE_VALUE (fn_arg_types
),
2229 TREE_VALUE (decl_arg_types
)))
2232 /* And the ref-qualification. */
2233 if (type_memfn_rqual (TREE_TYPE (decl
))
2234 != type_memfn_rqual (TREE_TYPE (fn
)))
2238 /* Skip the "this" parameter and, for constructors of
2239 classes with virtual bases, the VTT parameter. A
2240 full specialization of a constructor will have a VTT
2241 parameter, but a template never will. */
2243 = skip_artificial_parms_for (decl
, decl_arg_types
);
2245 = skip_artificial_parms_for (fn
, fn_arg_types
);
2247 /* Function templates cannot be specializations; there are
2248 no partial specializations of functions. Therefore, if
2249 the type of DECL does not match FN, there is no
2252 Note that it should never be the case that we have both
2253 candidates added here, and for regular member functions
2255 if (tsk
== tsk_template
)
2257 if (compparms (fn_arg_types
, decl_arg_types
))
2258 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2262 /* See whether this function might be a specialization of this
2263 template. Suppress access control because we might be trying
2264 to make this specialization a friend, and we have already done
2265 access control for the declaration of the specialization. */
2266 push_deferring_access_checks (dk_no_check
);
2267 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
2268 pop_deferring_access_checks ();
2271 /* We cannot deduce template arguments that when used to
2272 specialize TMPL will produce DECL. */
2275 if (uses_template_parms (targs
))
2276 /* We deduced something involving 'auto', which isn't a valid
2277 template argument. */
2280 /* Remove, from the set of candidates, all those functions
2281 whose constraints are not satisfied. */
2282 if (flag_concepts
&& !constraints_satisfied_p (fn
, targs
))
2285 // Then, try to form the new function type.
2286 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_fndecl_type
, NULL_TREE
);
2287 if (insttype
== error_mark_node
)
2290 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
2291 if (!compparms (fn_arg_types
, decl_arg_types
))
2294 /* Save this template, and the arguments deduced. */
2295 templates
= tree_cons (targs
, fn
, templates
);
2297 else if (need_member_template
)
2298 /* FN is an ordinary member function, and we need a
2299 specialization of a member template. */
2301 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2302 /* We can get IDENTIFIER_NODEs here in certain erroneous
2305 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2306 /* This is just an ordinary non-member function. Nothing can
2307 be a specialization of that. */
2309 else if (DECL_ARTIFICIAL (fn
))
2310 /* Cannot specialize functions that are created implicitly. */
2314 tree decl_arg_types
;
2316 /* This is an ordinary member function. However, since
2317 we're here, we can assume its enclosing class is a
2318 template class. For example,
2320 template <typename T> struct S { void f(); };
2321 template <> void S<int>::f() {}
2323 Here, S<int>::f is a non-template, but S<int> is a
2324 template class. If FN has the same type as DECL, we
2325 might be in business. */
2327 if (!DECL_TEMPLATE_INFO (fn
))
2328 /* Its enclosing class is an explicit specialization
2329 of a template class. This is not a candidate. */
2332 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2333 TREE_TYPE (TREE_TYPE (fn
))))
2334 /* The return types differ. */
2337 /* Adjust the type of DECL in case FN is a static member. */
2338 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2339 if (DECL_STATIC_FUNCTION_P (fn
)
2340 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2341 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2343 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2347 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2348 && (type_memfn_rqual (TREE_TYPE (decl
))
2349 != type_memfn_rqual (TREE_TYPE (fn
))))
2352 // If the deduced arguments do not satisfy the constraints,
2353 // this is not a candidate.
2354 if (flag_concepts
&& !constraints_satisfied_p (fn
))
2357 // Add the candidate.
2358 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2362 if (templates
&& TREE_CHAIN (templates
))
2368 It is possible for a specialization with a given function
2369 signature to be instantiated from more than one function
2370 template. In such cases, explicit specification of the
2371 template arguments must be used to uniquely identify the
2372 function template specialization being specialized.
2374 Note that here, there's no suggestion that we're supposed to
2375 determine which of the candidate templates is most
2376 specialized. However, we, also have:
2380 Partial ordering of overloaded function template
2381 declarations is used in the following contexts to select
2382 the function template to which a function template
2383 specialization refers:
2385 -- when an explicit specialization refers to a function
2388 So, we do use the partial ordering rules, at least for now.
2389 This extension can only serve to make invalid programs valid,
2390 so it's safe. And, there is strong anecdotal evidence that
2391 the committee intended the partial ordering rules to apply;
2392 the EDG front end has that behavior, and John Spicer claims
2393 that the committee simply forgot to delete the wording in
2394 [temp.expl.spec]. */
2395 tree tmpl
= most_specialized_instantiation (templates
);
2396 if (tmpl
!= error_mark_node
)
2399 TREE_CHAIN (templates
) = NULL_TREE
;
2403 // Concepts allows multiple declarations of member functions
2404 // with the same signature. Like above, we need to rely on
2405 // on the partial ordering of those candidates to determine which
2407 if (flag_concepts
&& candidates
&& TREE_CHAIN (candidates
))
2409 if (tree cand
= most_constrained_function (candidates
))
2412 TREE_CHAIN (cand
) = NULL_TREE
;
2416 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2418 error ("template-id %qD for %q+D does not match any template "
2419 "declaration", template_id
, decl
);
2420 if (header_count
&& header_count
!= template_count
+ 1)
2421 inform (input_location
, "saw %d %<template<>%>, need %d for "
2422 "specializing a member function template",
2423 header_count
, template_count
+ 1);
2425 print_candidates (orig_fns
);
2426 return error_mark_node
;
2428 else if ((templates
&& TREE_CHAIN (templates
))
2429 || (candidates
&& TREE_CHAIN (candidates
))
2430 || (templates
&& candidates
))
2432 error ("ambiguous template specialization %qD for %q+D",
2434 candidates
= chainon (candidates
, templates
);
2435 print_candidates (candidates
);
2436 return error_mark_node
;
2439 /* We have one, and exactly one, match. */
2442 tree fn
= TREE_VALUE (candidates
);
2443 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2445 // Propagate the candidate's constraints to the declaration.
2446 set_constraints (decl
, get_constraints (fn
));
2448 /* DECL is a re-declaration or partial instantiation of a template
2450 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2452 /* It was a specialization of an ordinary member function in a
2454 return DECL_TI_TEMPLATE (fn
);
2457 /* It was a specialization of a template. */
2458 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2459 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2461 *targs_out
= copy_node (targs
);
2462 SET_TMPL_ARGS_LEVEL (*targs_out
,
2463 TMPL_ARGS_DEPTH (*targs_out
),
2464 TREE_PURPOSE (templates
));
2467 *targs_out
= TREE_PURPOSE (templates
);
2468 return TREE_VALUE (templates
);
2471 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2472 but with the default argument values filled in from those in the
2476 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2479 tree new_spec_types
;
2484 if (spec_types
== void_list_node
)
2485 return void_list_node
;
2487 /* Substitute into the rest of the list. */
2489 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2490 TREE_CHAIN (tmpl_types
));
2492 /* Add the default argument for this parameter. */
2493 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2494 TREE_VALUE (spec_types
),
2498 /* DECL is an explicit specialization. Replicate default arguments
2499 from the template it specializes. (That way, code like:
2501 template <class T> void f(T = 3);
2502 template <> void f(double);
2505 works, as required.) An alternative approach would be to look up
2506 the correct default arguments at the call-site, but this approach
2507 is consistent with how implicit instantiations are handled. */
2510 copy_default_args_to_explicit_spec (tree decl
)
2515 tree new_spec_types
;
2519 tree object_type
= NULL_TREE
;
2520 tree in_charge
= NULL_TREE
;
2521 tree vtt
= NULL_TREE
;
2523 /* See if there's anything we need to do. */
2524 tmpl
= DECL_TI_TEMPLATE (decl
);
2525 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2526 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2527 if (TREE_PURPOSE (t
))
2532 old_type
= TREE_TYPE (decl
);
2533 spec_types
= TYPE_ARG_TYPES (old_type
);
2535 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2537 /* Remove the this pointer, but remember the object's type for
2539 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2540 spec_types
= TREE_CHAIN (spec_types
);
2541 tmpl_types
= TREE_CHAIN (tmpl_types
);
2543 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2545 /* DECL may contain more parameters than TMPL due to the extra
2546 in-charge parameter in constructors and destructors. */
2547 in_charge
= spec_types
;
2548 spec_types
= TREE_CHAIN (spec_types
);
2550 if (DECL_HAS_VTT_PARM_P (decl
))
2553 spec_types
= TREE_CHAIN (spec_types
);
2557 /* Compute the merged default arguments. */
2559 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2561 /* Compute the new FUNCTION_TYPE. */
2565 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2570 /* Put the in-charge parameter back. */
2571 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2572 TREE_VALUE (in_charge
),
2575 new_type
= build_method_type_directly (object_type
,
2576 TREE_TYPE (old_type
),
2580 new_type
= build_function_type (TREE_TYPE (old_type
),
2582 new_type
= cp_build_type_attribute_variant (new_type
,
2583 TYPE_ATTRIBUTES (old_type
));
2584 new_type
= cxx_copy_lang_qualifiers (new_type
, old_type
);
2586 TREE_TYPE (decl
) = new_type
;
2589 /* Return the number of template headers we expect to see for a definition
2590 or specialization of CTYPE or one of its non-template members. */
2593 num_template_headers_for_class (tree ctype
)
2595 int num_templates
= 0;
2597 while (ctype
&& CLASS_TYPE_P (ctype
))
2599 /* You're supposed to have one `template <...>' for every
2600 template class, but you don't need one for a full
2601 specialization. For example:
2603 template <class T> struct S{};
2604 template <> struct S<int> { void f(); };
2605 void S<int>::f () {}
2607 is correct; there shouldn't be a `template <>' for the
2608 definition of `S<int>::f'. */
2609 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2610 /* If CTYPE does not have template information of any
2611 kind, then it is not a template, nor is it nested
2612 within a template. */
2614 if (explicit_class_specialization_p (ctype
))
2616 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2619 ctype
= TYPE_CONTEXT (ctype
);
2622 return num_templates
;
2625 /* Do a simple sanity check on the template headers that precede the
2626 variable declaration DECL. */
2629 check_template_variable (tree decl
)
2631 tree ctx
= CP_DECL_CONTEXT (decl
);
2632 int wanted
= num_template_headers_for_class (ctx
);
2633 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2634 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2636 if (cxx_dialect
< cxx14
)
2637 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2638 "variable templates only available with "
2639 "%<-std=c++14%> or %<-std=gnu++14%>");
2641 // Namespace-scope variable templates should have a template header.
2644 if (template_header_count
> wanted
)
2646 auto_diagnostic_group d
;
2647 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2648 "too many template headers for %qD "
2651 if (warned
&& CLASS_TYPE_P (ctx
)
2652 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2653 inform (DECL_SOURCE_LOCATION (decl
),
2654 "members of an explicitly specialized class are defined "
2655 "without a template header");
2659 /* An explicit specialization whose declarator-id or class-head-name is not
2660 qualified shall be declared in the nearest enclosing namespace of the
2661 template, or, if the namespace is inline (7.3.1), any namespace from its
2662 enclosing namespace set.
2664 If the name declared in the explicit instantiation is an unqualified name,
2665 the explicit instantiation shall appear in the namespace where its template
2666 is declared or, if that namespace is inline (7.3.1), any namespace from its
2667 enclosing namespace set. */
2670 check_unqualified_spec_or_inst (tree t
, location_t loc
)
2672 tree tmpl
= most_general_template (t
);
2673 if (DECL_NAMESPACE_SCOPE_P (tmpl
)
2674 && !is_nested_namespace (current_namespace
,
2675 CP_DECL_CONTEXT (tmpl
), true))
2677 if (processing_specialization
)
2678 permerror (loc
, "explicit specialization of %qD outside its "
2679 "namespace must use a nested-name-specifier", tmpl
);
2680 else if (processing_explicit_instantiation
2681 && cxx_dialect
>= cxx11
)
2682 /* This was allowed in C++98, so only pedwarn. */
2683 pedwarn (loc
, OPT_Wpedantic
, "explicit instantiation of %qD "
2684 "outside its namespace must use a nested-name-"
2689 /* Warn for a template specialization SPEC that is missing some of a set
2690 of function or type attributes that the template TEMPL is declared with.
2691 ATTRLIST is a list of additional attributes that SPEC should be taken
2692 to ultimately be declared with. */
2695 warn_spec_missing_attributes (tree tmpl
, tree spec
, tree attrlist
)
2697 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
2698 tmpl
= DECL_TEMPLATE_RESULT (tmpl
);
2700 /* Avoid warning if the difference between the primary and
2701 the specialization is not in one of the attributes below. */
2702 const char* const blacklist
[] = {
2703 "alloc_align", "alloc_size", "assume_aligned", "format",
2704 "format_arg", "malloc", "nonnull", NULL
2707 /* Put together a list of the black listed attributes that the primary
2708 template is declared with that the specialization is not, in case
2709 it's not apparent from the most recent declaration of the primary. */
2711 unsigned nattrs
= decls_mismatched_attributes (tmpl
, spec
, attrlist
,
2717 auto_diagnostic_group d
;
2718 if (warning_at (DECL_SOURCE_LOCATION (spec
), OPT_Wmissing_attributes
,
2719 "explicit specialization %q#D may be missing attributes",
2721 inform (DECL_SOURCE_LOCATION (tmpl
),
2723 ? G_("missing primary template attributes %s")
2724 : G_("missing primary template attribute %s"),
2725 pp_formatted_text (&str
));
2728 /* Check to see if the function just declared, as indicated in
2729 DECLARATOR, and in DECL, is a specialization of a function
2730 template. We may also discover that the declaration is an explicit
2731 instantiation at this point.
2733 Returns DECL, or an equivalent declaration that should be used
2734 instead if all goes well. Issues an error message if something is
2735 amiss. Returns error_mark_node if the error is not easily
2738 FLAGS is a bitmask consisting of the following flags:
2740 2: The function has a definition.
2741 4: The function is a friend.
2743 The TEMPLATE_COUNT is the number of references to qualifying
2744 template classes that appeared in the name of the function. For
2747 template <class T> struct S { void f(); };
2750 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2751 classes are not counted in the TEMPLATE_COUNT, so that in
2753 template <class T> struct S {};
2754 template <> struct S<int> { void f(); }
2755 template <> void S<int>::f();
2757 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2758 invalid; there should be no template <>.)
2760 If the function is a specialization, it is marked as such via
2761 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2762 is set up correctly, and it is added to the list of specializations
2763 for that template. */
2766 check_explicit_specialization (tree declarator
,
2772 int have_def
= flags
& 2;
2773 int is_friend
= flags
& 4;
2774 bool is_concept
= flags
& 8;
2775 int specialization
= 0;
2776 int explicit_instantiation
= 0;
2777 int member_specialization
= 0;
2778 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2779 tree dname
= DECL_NAME (decl
);
2784 if (!processing_specialization
)
2787 tsk
= tsk_excessive_parms
;
2790 tsk
= current_tmpl_spec_kind (template_count
);
2795 if (processing_specialization
&& !VAR_P (decl
))
2798 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2800 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2803 /* This could be something like:
2805 template <class T> void f(T);
2806 class S { friend void f<>(int); } */
2810 /* This case handles bogus declarations like template <>
2811 template <class T> void f<int>(); */
2813 error ("template-id %qD in declaration of primary template",
2820 case tsk_invalid_member_spec
:
2821 /* The error has already been reported in
2822 check_specialization_scope. */
2823 return error_mark_node
;
2825 case tsk_invalid_expl_inst
:
2826 error ("template parameter list used in explicit instantiation");
2832 error ("definition provided for explicit instantiation");
2834 explicit_instantiation
= 1;
2837 case tsk_excessive_parms
:
2838 case tsk_insufficient_parms
:
2839 if (tsk
== tsk_excessive_parms
)
2840 error ("too many template parameter lists in declaration of %qD",
2842 else if (template_header_count
)
2843 error("too few template parameter lists in declaration of %qD", decl
);
2845 error("explicit specialization of %qD must be introduced by "
2846 "%<template <>%>", decl
);
2851 error ("explicit specialization declared %<concept%>");
2853 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2854 /* In cases like template<> constexpr bool v = true;
2855 We'll give an error in check_template_variable. */
2858 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2860 member_specialization
= 1;
2866 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2868 /* This case handles bogus declarations like template <>
2869 template <class T> void f<int>(); */
2871 if (!uses_template_parms (TREE_OPERAND (declarator
, 1)))
2872 error ("template-id %qD in declaration of primary template",
2874 else if (variable_template_p (TREE_OPERAND (declarator
, 0)))
2876 /* Partial specialization of variable template. */
2877 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2881 else if (cxx_dialect
< cxx14
)
2882 error ("non-type partial specialization %qD "
2883 "is not allowed", declarator
);
2885 error ("non-class, non-variable partial specialization %qD "
2886 "is not allowed", declarator
);
2891 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2892 /* This is a specialization of a member template, without
2893 specialization the containing class. Something like:
2895 template <class T> struct S {
2896 template <class U> void f (U);
2898 template <> template <class U> void S<int>::f(U) {}
2900 That's a specialization -- but of the entire template. */
2908 if ((specialization
|| member_specialization
)
2909 /* This doesn't apply to variable templates. */
2910 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (decl
)))
2912 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2913 for (; t
; t
= TREE_CHAIN (t
))
2914 if (TREE_PURPOSE (t
))
2916 permerror (input_location
,
2917 "default argument specified in explicit specialization");
2922 if (specialization
|| member_specialization
|| explicit_instantiation
)
2924 tree tmpl
= NULL_TREE
;
2925 tree targs
= NULL_TREE
;
2926 bool was_template_id
= (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
);
2928 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2929 if (!was_template_id
)
2933 gcc_assert (identifier_p (declarator
));
2938 /* If there is no class context, the explicit instantiation
2939 must be at namespace scope. */
2940 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2942 /* Find the namespace binding, using the declaration
2944 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2946 if (fns
== error_mark_node
)
2947 /* If lookup fails, look for a friend declaration so we can
2948 give a better diagnostic. */
2949 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2950 /*type*/false, /*complain*/true,
2953 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2955 error ("%qD is not a template function", dname
);
2956 fns
= error_mark_node
;
2960 declarator
= lookup_template_function (fns
, NULL_TREE
);
2963 if (declarator
== error_mark_node
)
2964 return error_mark_node
;
2966 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2968 if (!explicit_instantiation
)
2969 /* A specialization in class scope. This is invalid,
2970 but the error will already have been flagged by
2971 check_specialization_scope. */
2972 return error_mark_node
;
2975 /* It's not valid to write an explicit instantiation in
2978 class C { template void f(); }
2980 This case is caught by the parser. However, on
2983 template class C { void f(); };
2985 (which is invalid) we can get here. The error will be
2992 else if (ctype
!= NULL_TREE
2993 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2995 // We'll match variable templates in start_decl.
2999 /* Find the list of functions in ctype that have the same
3000 name as the declared function. */
3001 tree name
= TREE_OPERAND (declarator
, 0);
3003 if (constructor_name_p (name
, ctype
))
3005 if (DECL_CONSTRUCTOR_P (decl
)
3006 ? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
3007 : !CLASSTYPE_DESTRUCTOR (ctype
))
3009 /* From [temp.expl.spec]:
3011 If such an explicit specialization for the member
3012 of a class template names an implicitly-declared
3013 special member function (clause _special_), the
3014 program is ill-formed.
3016 Similar language is found in [temp.explicit]. */
3017 error ("specialization of implicitly-declared special member function");
3018 return error_mark_node
;
3021 name
= DECL_NAME (decl
);
3024 /* For a type-conversion operator, We might be looking for
3025 `operator int' which will be a specialization of
3026 `operator T'. Grab all the conversion operators, and
3027 then select from them. */
3028 tree fns
= get_class_binding (ctype
, IDENTIFIER_CONV_OP_P (name
)
3029 ? conv_op_identifier
: name
);
3031 if (fns
== NULL_TREE
)
3033 error ("no member function %qD declared in %qT", name
, ctype
);
3034 return error_mark_node
;
3037 TREE_OPERAND (declarator
, 0) = fns
;
3040 /* Figure out what exactly is being specialized at this point.
3041 Note that for an explicit instantiation, even one for a
3042 member function, we cannot tell a priori whether the
3043 instantiation is for a member template, or just a member
3044 function of a template class. Even if a member template is
3045 being instantiated, the member template arguments may be
3046 elided if they can be deduced from the rest of the
3048 tmpl
= determine_specialization (declarator
, decl
,
3050 member_specialization
,
3054 if (!tmpl
|| tmpl
== error_mark_node
)
3055 /* We couldn't figure out what this declaration was
3057 return error_mark_node
;
3060 if (TREE_CODE (decl
) == FUNCTION_DECL
3061 && DECL_HIDDEN_FRIEND_P (tmpl
))
3063 auto_diagnostic_group d
;
3064 if (pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
3065 "friend declaration %qD is not visible to "
3066 "explicit specialization", tmpl
))
3067 inform (DECL_SOURCE_LOCATION (tmpl
),
3068 "friend declaration here");
3070 else if (!ctype
&& !is_friend
3071 && CP_DECL_CONTEXT (decl
) == current_namespace
)
3072 check_unqualified_spec_or_inst (tmpl
, DECL_SOURCE_LOCATION (decl
));
3074 tree gen_tmpl
= most_general_template (tmpl
);
3076 if (explicit_instantiation
)
3078 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
3079 is done by do_decl_instantiation later. */
3081 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
3082 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
3084 if (arg_depth
> parm_depth
)
3086 /* If TMPL is not the most general template (for
3087 example, if TMPL is a friend template that is
3088 injected into namespace scope), then there will
3089 be too many levels of TARGS. Remove some of them
3094 new_targs
= make_tree_vec (parm_depth
);
3095 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
3096 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
3097 = TREE_VEC_ELT (targs
, i
);
3101 return instantiate_template (tmpl
, targs
, tf_error
);
3104 /* If we thought that the DECL was a member function, but it
3105 turns out to be specializing a static member function,
3106 make DECL a static member function as well. */
3107 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
3108 && DECL_STATIC_FUNCTION_P (tmpl
)
3109 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
3110 revert_static_member_fn (decl
);
3112 /* If this is a specialization of a member template of a
3113 template class, we want to return the TEMPLATE_DECL, not
3114 the specialization of it. */
3115 if (tsk
== tsk_template
&& !was_template_id
)
3117 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
3118 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
3119 DECL_INITIAL (result
) = NULL_TREE
;
3123 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
3124 DECL_SOURCE_LOCATION (result
)
3125 = DECL_SOURCE_LOCATION (decl
);
3126 /* We want to use the argument list specified in the
3127 definition, not in the original declaration. */
3128 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
3129 for (parm
= DECL_ARGUMENTS (result
); parm
;
3130 parm
= DECL_CHAIN (parm
))
3131 DECL_CONTEXT (parm
) = result
;
3133 return register_specialization (tmpl
, gen_tmpl
, targs
,
3137 /* Set up the DECL_TEMPLATE_INFO for DECL. */
3138 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
3140 if (was_template_id
)
3141 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
)) = true;
3143 /* Inherit default function arguments from the template
3144 DECL is specializing. */
3145 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
3146 copy_default_args_to_explicit_spec (decl
);
3148 /* This specialization has the same protection as the
3149 template it specializes. */
3150 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
3151 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
3153 /* 7.1.1-1 [dcl.stc]
3155 A storage-class-specifier shall not be specified in an
3156 explicit specialization...
3158 The parser rejects these, so unless action is taken here,
3159 explicit function specializations will always appear with
3162 The action recommended by the C++ CWG in response to C++
3163 defect report 605 is to make the storage class and linkage
3164 of the explicit specialization match the templated function:
3166 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3168 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
3170 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
3171 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
3173 /* A concept cannot be specialized. */
3174 if (DECL_DECLARED_CONCEPT_P (tmpl_func
))
3176 error ("explicit specialization of function concept %qD",
3178 return error_mark_node
;
3181 /* This specialization has the same linkage and visibility as
3182 the function template it specializes. */
3183 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
3184 if (! TREE_PUBLIC (decl
))
3186 DECL_INTERFACE_KNOWN (decl
) = 1;
3187 DECL_NOT_REALLY_EXTERN (decl
) = 1;
3189 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
3190 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
3192 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3193 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
3197 /* If DECL is a friend declaration, declared using an
3198 unqualified name, the namespace associated with DECL may
3199 have been set incorrectly. For example, in:
3201 template <typename T> void f(T);
3203 struct S { friend void f<int>(int); }
3206 we will have set the DECL_CONTEXT for the friend
3207 declaration to N, rather than to the global namespace. */
3208 if (DECL_NAMESPACE_SCOPE_P (decl
))
3209 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
3211 if (is_friend
&& !have_def
)
3212 /* This is not really a declaration of a specialization.
3213 It's just the name of an instantiation. But, it's not
3214 a request for an instantiation, either. */
3215 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
3216 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3217 /* A specialization is not necessarily COMDAT. */
3218 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
3219 && DECL_DECLARED_INLINE_P (decl
));
3220 else if (VAR_P (decl
))
3221 DECL_COMDAT (decl
) = false;
3223 /* If this is a full specialization, register it so that we can find
3224 it again. Partial specializations will be registered in
3225 process_partial_specialization. */
3226 if (!processing_template_decl
)
3228 warn_spec_missing_attributes (gen_tmpl
, decl
, attrlist
);
3230 decl
= register_specialization (decl
, gen_tmpl
, targs
,
3235 /* A 'structor should already have clones. */
3236 gcc_assert (decl
== error_mark_node
3237 || variable_template_p (tmpl
)
3238 || !(DECL_CONSTRUCTOR_P (decl
)
3239 || DECL_DESTRUCTOR_P (decl
))
3240 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
3247 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3248 parameters. These are represented in the same format used for
3249 DECL_TEMPLATE_PARMS. */
3252 comp_template_parms (const_tree parms1
, const_tree parms2
)
3257 if (parms1
== parms2
)
3260 for (p1
= parms1
, p2
= parms2
;
3261 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
3262 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
3264 tree t1
= TREE_VALUE (p1
);
3265 tree t2
= TREE_VALUE (p2
);
3268 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
3269 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
3271 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3274 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
3276 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
3277 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
3279 /* If either of the template parameters are invalid, assume
3280 they match for the sake of error recovery. */
3281 if (error_operand_p (parm1
) || error_operand_p (parm2
))
3284 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
3287 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
3288 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
3289 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
3291 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
3296 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
3297 /* One set of parameters has more parameters lists than the
3304 /* Determine whether PARM is a parameter pack. */
3307 template_parameter_pack_p (const_tree parm
)
3309 /* Determine if we have a non-type template parameter pack. */
3310 if (TREE_CODE (parm
) == PARM_DECL
)
3311 return (DECL_TEMPLATE_PARM_P (parm
)
3312 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
3313 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
3314 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
3316 /* If this is a list of template parameters, we could get a
3317 TYPE_DECL or a TEMPLATE_DECL. */
3318 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
3319 parm
= TREE_TYPE (parm
);
3321 /* Otherwise it must be a type template parameter. */
3322 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
3323 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
3324 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
3327 /* Determine if T is a function parameter pack. */
3330 function_parameter_pack_p (const_tree t
)
3332 if (t
&& TREE_CODE (t
) == PARM_DECL
)
3333 return DECL_PACK_P (t
);
3337 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3338 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3341 get_function_template_decl (const_tree primary_func_tmpl_inst
)
3343 if (! primary_func_tmpl_inst
3344 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
3345 || ! primary_template_specialization_p (primary_func_tmpl_inst
))
3348 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
3351 /* Return true iff the function parameter PARAM_DECL was expanded
3352 from the function parameter pack PACK. */
3355 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
3357 if (DECL_ARTIFICIAL (param_decl
)
3358 || !function_parameter_pack_p (pack
))
3361 /* The parameter pack and its pack arguments have the same
3363 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
3366 /* Determine whether ARGS describes a variadic template args list,
3367 i.e., one that is terminated by a template argument pack. */
3370 template_args_variadic_p (tree args
)
3375 if (args
== NULL_TREE
)
3378 args
= INNERMOST_TEMPLATE_ARGS (args
);
3379 nargs
= TREE_VEC_LENGTH (args
);
3384 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
3386 return ARGUMENT_PACK_P (last_parm
);
3389 /* Generate a new name for the parameter pack name NAME (an
3390 IDENTIFIER_NODE) that incorporates its */
3393 make_ith_pack_parameter_name (tree name
, int i
)
3395 /* Munge the name to include the parameter index. */
3396 #define NUMBUF_LEN 128
3397 char numbuf
[NUMBUF_LEN
];
3401 if (name
== NULL_TREE
)
3403 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
3404 newname_len
= IDENTIFIER_LENGTH (name
)
3405 + strlen (numbuf
) + 2;
3406 newname
= (char*)alloca (newname_len
);
3407 snprintf (newname
, newname_len
,
3408 "%s#%i", IDENTIFIER_POINTER (name
), i
);
3409 return get_identifier (newname
);
3412 /* Return true if T is a primary function, class or alias template
3413 specialization, not including the template pattern. */
3416 primary_template_specialization_p (const_tree t
)
3421 if (TREE_CODE (t
) == FUNCTION_DECL
|| VAR_P (t
))
3422 return (DECL_LANG_SPECIFIC (t
)
3423 && DECL_USE_TEMPLATE (t
)
3424 && DECL_TEMPLATE_INFO (t
)
3425 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)));
3426 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3427 return (CLASSTYPE_TEMPLATE_INFO (t
)
3428 && CLASSTYPE_USE_TEMPLATE (t
)
3429 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
3430 else if (alias_template_specialization_p (t
))
3435 /* Return true if PARM is a template template parameter. */
3438 template_template_parameter_p (const_tree parm
)
3440 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3443 /* Return true iff PARM is a DECL representing a type template
3447 template_type_parameter_p (const_tree parm
)
3450 && (TREE_CODE (parm
) == TYPE_DECL
3451 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3452 && DECL_TEMPLATE_PARM_P (parm
));
3455 /* Return the template parameters of T if T is a
3456 primary template instantiation, NULL otherwise. */
3459 get_primary_template_innermost_parameters (const_tree t
)
3461 tree parms
= NULL
, template_info
= NULL
;
3463 if ((template_info
= get_template_info (t
))
3464 && primary_template_specialization_p (t
))
3465 parms
= INNERMOST_TEMPLATE_PARMS
3466 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3471 /* Return the template parameters of the LEVELth level from the full list
3472 of template parameters PARMS. */
3475 get_template_parms_at_level (tree parms
, int level
)
3479 || TREE_CODE (parms
) != TREE_LIST
3480 || level
> TMPL_PARMS_DEPTH (parms
))
3483 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3484 if (TMPL_PARMS_DEPTH (p
) == level
)
3490 /* Returns the template arguments of T if T is a template instantiation,
3494 get_template_innermost_arguments (const_tree t
)
3496 tree args
= NULL
, template_info
= NULL
;
3498 if ((template_info
= get_template_info (t
))
3499 && TI_ARGS (template_info
))
3500 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3505 /* Return the argument pack elements of T if T is a template argument pack,
3509 get_template_argument_pack_elems (const_tree t
)
3511 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3512 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3515 return ARGUMENT_PACK_ARGS (t
);
3518 /* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the
3519 ARGUMENT_PACK_SELECT represents. */
3522 argument_pack_select_arg (tree t
)
3524 tree args
= ARGUMENT_PACK_ARGS (ARGUMENT_PACK_SELECT_FROM_PACK (t
));
3525 tree arg
= TREE_VEC_ELT (args
, ARGUMENT_PACK_SELECT_INDEX (t
));
3527 /* If the selected argument is an expansion E, that most likely means we were
3528 called from gen_elem_of_pack_expansion_instantiation during the
3529 substituting of an argument pack (of which the Ith element is a pack
3530 expansion, where I is ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
3531 In this case, the Ith element resulting from this substituting is going to
3532 be a pack expansion, which pattern is the pattern of E. Let's return the
3533 pattern of E, and gen_elem_of_pack_expansion_instantiation will build the
3534 resulting pack expansion from it. */
3535 if (PACK_EXPANSION_P (arg
))
3537 /* Make sure we aren't throwing away arg info. */
3538 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
3539 arg
= PACK_EXPANSION_PATTERN (arg
);
3546 /* True iff FN is a function representing a built-in variadic parameter
3550 builtin_pack_fn_p (tree fn
)
3553 || TREE_CODE (fn
) != FUNCTION_DECL
3554 || !DECL_IS_BUILTIN (fn
))
3557 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3563 /* True iff CALL is a call to a function representing a built-in variadic
3567 builtin_pack_call_p (tree call
)
3569 if (TREE_CODE (call
) != CALL_EXPR
)
3571 return builtin_pack_fn_p (CALL_EXPR_FN (call
));
3574 /* Return a TREE_VEC for the expansion of __integer_pack(HI). */
3577 expand_integer_pack (tree call
, tree args
, tsubst_flags_t complain
,
3580 tree ohi
= CALL_EXPR_ARG (call
, 0);
3581 tree hi
= tsubst_copy_and_build (ohi
, args
, complain
, in_decl
,
3582 false/*fn*/, true/*int_cst*/);
3584 if (value_dependent_expression_p (hi
))
3588 call
= copy_node (call
);
3589 CALL_EXPR_ARG (call
, 0) = hi
;
3591 tree ex
= make_pack_expansion (call
, complain
);
3592 tree vec
= make_tree_vec (1);
3593 TREE_VEC_ELT (vec
, 0) = ex
;
3598 hi
= cxx_constant_value (hi
);
3599 int len
= valid_constant_size_p (hi
) ? tree_to_shwi (hi
) : -1;
3601 /* Calculate the largest value of len that won't make the size of the vec
3602 overflow an int. The compiler will exceed resource limits long before
3603 this, but it seems a decent place to diagnose. */
3604 int max
= ((INT_MAX
- sizeof (tree_vec
)) / sizeof (tree
)) + 1;
3606 if (len
< 0 || len
> max
)
3608 if ((complain
& tf_error
)
3609 && hi
!= error_mark_node
)
3610 error ("argument to %<__integer_pack%> must be between 0 and %d",
3612 return error_mark_node
;
3615 tree vec
= make_tree_vec (len
);
3617 for (int i
= 0; i
< len
; ++i
)
3618 TREE_VEC_ELT (vec
, i
) = size_int (i
);
3624 /* Return a TREE_VEC for the expansion of built-in template parameter pack
3628 expand_builtin_pack_call (tree call
, tree args
, tsubst_flags_t complain
,
3631 if (!builtin_pack_call_p (call
))
3634 tree fn
= CALL_EXPR_FN (call
);
3636 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3637 return expand_integer_pack (call
, args
, complain
, in_decl
);
3642 /* Structure used to track the progress of find_parameter_packs_r. */
3643 struct find_parameter_pack_data
3645 /* TREE_LIST that will contain all of the parameter packs found by
3647 tree
* parameter_packs
;
3649 /* Set of AST nodes that have been visited by the traversal. */
3650 hash_set
<tree
> *visited
;
3652 /* True iff we're making a type pack expansion. */
3653 bool type_pack_expansion_p
;
3656 /* Identifies all of the argument packs that occur in a template
3657 argument and appends them to the TREE_LIST inside DATA, which is a
3658 find_parameter_pack_data structure. This is a subroutine of
3659 make_pack_expansion and uses_parameter_packs. */
3661 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3664 struct find_parameter_pack_data
* ppd
=
3665 (struct find_parameter_pack_data
*)data
;
3666 bool parameter_pack_p
= false;
3668 /* Handle type aliases/typedefs. */
3669 if (TYPE_ALIAS_P (t
))
3671 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
3672 cp_walk_tree (&TI_ARGS (tinfo
),
3673 &find_parameter_packs_r
,
3679 /* Identify whether this is a parameter pack or not. */
3680 switch (TREE_CODE (t
))
3682 case TEMPLATE_PARM_INDEX
:
3683 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3684 parameter_pack_p
= true;
3687 case TEMPLATE_TYPE_PARM
:
3688 t
= TYPE_MAIN_VARIANT (t
);
3690 case TEMPLATE_TEMPLATE_PARM
:
3691 /* If the placeholder appears in the decl-specifier-seq of a function
3692 parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3693 is a pack expansion, the invented template parameter is a template
3695 if (ppd
->type_pack_expansion_p
&& is_auto (t
))
3696 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
3697 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3698 parameter_pack_p
= true;
3703 if (DECL_PACK_P (t
))
3705 /* We don't want to walk into the type of a PARM_DECL,
3706 because we don't want to see the type parameter pack. */
3708 parameter_pack_p
= true;
3713 if (DECL_PACK_P (t
))
3715 /* We don't want to walk into the type of a variadic capture proxy,
3716 because we don't want to see the type parameter pack. */
3718 parameter_pack_p
= true;
3720 else if (variable_template_specialization_p (t
))
3722 cp_walk_tree (&DECL_TI_ARGS (t
),
3723 find_parameter_packs_r
,
3730 if (builtin_pack_call_p (t
))
3731 parameter_pack_p
= true;
3735 parameter_pack_p
= true;
3738 /* Not a parameter pack. */
3742 if (parameter_pack_p
)
3744 /* Add this parameter pack to the list. */
3745 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3749 cp_walk_tree (&TYPE_CONTEXT (t
),
3750 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3752 /* This switch statement will return immediately if we don't find a
3754 switch (TREE_CODE (t
))
3756 case TEMPLATE_PARM_INDEX
:
3759 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3760 /* Check the template itself. */
3761 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3762 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3763 /* Check the template arguments. */
3764 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3769 case TEMPLATE_TYPE_PARM
:
3770 case TEMPLATE_TEMPLATE_PARM
:
3777 /* Ignore the declaration of a capture proxy for a parameter pack. */
3778 if (is_capture_proxy (DECL_EXPR_DECL (t
)))
3783 if (TYPE_PTRMEMFUNC_P (t
))
3789 if (TYPE_TEMPLATE_INFO (t
))
3790 cp_walk_tree (&TYPE_TI_ARGS (t
),
3791 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3797 if (!DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
3802 cp_walk_tree (&TREE_TYPE (t
),
3803 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3807 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3812 case TYPE_PACK_EXPANSION
:
3813 case EXPR_PACK_EXPANSION
:
3818 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3823 case IDENTIFIER_NODE
:
3824 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3831 /* Look at explicit captures. */
3832 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
);
3833 cap
; cap
= TREE_CHAIN (cap
))
3834 cp_walk_tree (&TREE_VALUE (cap
), &find_parameter_packs_r
, ppd
,
3836 /* Since we defer implicit capture, look in the parms and body. */
3837 tree fn
= lambda_function (t
);
3838 cp_walk_tree (&TREE_TYPE (fn
), &find_parameter_packs_r
, ppd
,
3840 cp_walk_tree (&DECL_SAVED_TREE (fn
), &find_parameter_packs_r
, ppd
,
3848 /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
3849 type_pack_expansion_p to false so that any placeholders
3850 within the expression don't get marked as parameter packs. */
3851 bool type_pack_expansion_p
= ppd
->type_pack_expansion_p
;
3852 ppd
->type_pack_expansion_p
= false;
3853 cp_walk_tree (&DECLTYPE_TYPE_EXPR (t
), &find_parameter_packs_r
,
3855 ppd
->type_pack_expansion_p
= type_pack_expansion_p
;
3861 cp_walk_tree (&IF_COND (t
), &find_parameter_packs_r
,
3863 cp_walk_tree (&THEN_CLAUSE (t
), &find_parameter_packs_r
,
3865 cp_walk_tree (&ELSE_CLAUSE (t
), &find_parameter_packs_r
,
3867 /* Don't walk into IF_STMT_EXTRA_ARGS. */
3878 /* Determines if the expression or type T uses any parameter packs. */
3880 uses_parameter_packs (tree t
)
3882 tree parameter_packs
= NULL_TREE
;
3883 struct find_parameter_pack_data ppd
;
3884 ppd
.parameter_packs
= ¶meter_packs
;
3885 ppd
.visited
= new hash_set
<tree
>;
3886 ppd
.type_pack_expansion_p
= false;
3887 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3889 return parameter_packs
!= NULL_TREE
;
3892 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3893 representation a base-class initializer into a parameter pack
3894 expansion. If all goes well, the resulting node will be an
3895 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3898 make_pack_expansion (tree arg
, tsubst_flags_t complain
)
3901 tree parameter_packs
= NULL_TREE
;
3902 bool for_types
= false;
3903 struct find_parameter_pack_data ppd
;
3905 if (!arg
|| arg
== error_mark_node
)
3908 if (TREE_CODE (arg
) == TREE_LIST
&& TREE_PURPOSE (arg
))
3910 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3911 class initializer. In this case, the TREE_PURPOSE will be a
3912 _TYPE node (representing the base class expansion we're
3913 initializing) and the TREE_VALUE will be a TREE_LIST
3914 containing the initialization arguments.
3916 The resulting expansion looks somewhat different from most
3917 expansions. Rather than returning just one _EXPANSION, we
3918 return a TREE_LIST whose TREE_PURPOSE is a
3919 TYPE_PACK_EXPANSION containing the bases that will be
3920 initialized. The TREE_VALUE will be identical to the
3921 original TREE_VALUE, which is a list of arguments that will
3922 be passed to each base. We do not introduce any new pack
3923 expansion nodes into the TREE_VALUE (although it is possible
3924 that some already exist), because the TREE_PURPOSE and
3925 TREE_VALUE all need to be expanded together with the same
3926 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3927 resulting TREE_PURPOSE will mention the parameter packs in
3928 both the bases and the arguments to the bases. */
3931 tree parameter_packs
= NULL_TREE
;
3933 /* Determine which parameter packs will be used by the base
3935 ppd
.visited
= new hash_set
<tree
>;
3936 ppd
.parameter_packs
= ¶meter_packs
;
3937 ppd
.type_pack_expansion_p
= false;
3938 gcc_assert (TYPE_P (TREE_PURPOSE (arg
)));
3939 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3942 if (parameter_packs
== NULL_TREE
)
3944 if (complain
& tf_error
)
3945 error ("base initializer expansion %qT contains no parameter packs",
3948 return error_mark_node
;
3951 if (TREE_VALUE (arg
) != void_type_node
)
3953 /* Collect the sets of parameter packs used in each of the
3954 initialization arguments. */
3955 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3957 /* Determine which parameter packs will be expanded in this
3959 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3966 /* Create the pack expansion type for the base type. */
3967 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3968 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3969 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3970 PACK_EXPANSION_LOCAL_P (purpose
) = at_function_scope_p ();
3972 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3973 they will rarely be compared to anything. */
3974 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3976 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3979 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3982 /* Build the PACK_EXPANSION_* node. */
3984 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3985 : make_node (EXPR_PACK_EXPANSION
);
3986 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3987 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3989 /* Propagate type and const-expression information. */
3990 TREE_TYPE (result
) = TREE_TYPE (arg
);
3991 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3992 /* Mark this read now, since the expansion might be length 0. */
3993 mark_exp_read (arg
);
3996 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3997 they will rarely be compared to anything. */
3998 SET_TYPE_STRUCTURAL_EQUALITY (result
);
4000 /* Determine which parameter packs will be expanded. */
4001 ppd
.parameter_packs
= ¶meter_packs
;
4002 ppd
.visited
= new hash_set
<tree
>;
4003 ppd
.type_pack_expansion_p
= TYPE_P (arg
);
4004 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
4007 /* Make sure we found some parameter packs. */
4008 if (parameter_packs
== NULL_TREE
)
4010 if (complain
& tf_error
)
4013 error ("expansion pattern %qT contains no parameter packs", arg
);
4015 error ("expansion pattern %qE contains no parameter packs", arg
);
4017 return error_mark_node
;
4019 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
4021 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
4026 /* Checks T for any "bare" parameter packs, which have not yet been
4027 expanded, and issues an error if any are found. This operation can
4028 only be done on full expressions or types (e.g., an expression
4029 statement, "if" condition, etc.), because we could have expressions like:
4031 foo(f(g(h(args)))...)
4033 where "args" is a parameter pack. check_for_bare_parameter_packs
4034 should not be called for the subexpressions args, h(args),
4035 g(h(args)), or f(g(h(args))), because we would produce erroneous
4038 Returns TRUE and emits an error if there were bare parameter packs,
4039 returns FALSE otherwise. */
4041 check_for_bare_parameter_packs (tree t
, location_t loc
/* = UNKNOWN_LOCATION */)
4043 tree parameter_packs
= NULL_TREE
;
4044 struct find_parameter_pack_data ppd
;
4046 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
4049 /* A lambda might use a parameter pack from the containing context. */
4050 if (current_class_type
&& LAMBDA_TYPE_P (current_class_type
)
4051 && CLASSTYPE_TEMPLATE_INFO (current_class_type
))
4054 if (TREE_CODE (t
) == TYPE_DECL
)
4057 ppd
.parameter_packs
= ¶meter_packs
;
4058 ppd
.visited
= new hash_set
<tree
>;
4059 ppd
.type_pack_expansion_p
= false;
4060 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
4063 if (parameter_packs
)
4065 if (loc
== UNKNOWN_LOCATION
)
4066 loc
= cp_expr_loc_or_loc (t
, input_location
);
4067 error_at (loc
, "parameter packs not expanded with %<...%>:");
4068 while (parameter_packs
)
4070 tree pack
= TREE_VALUE (parameter_packs
);
4071 tree name
= NULL_TREE
;
4073 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
4074 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
4075 name
= TYPE_NAME (pack
);
4076 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
4077 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
4078 else if (TREE_CODE (pack
) == CALL_EXPR
)
4079 name
= DECL_NAME (CALL_EXPR_FN (pack
));
4081 name
= DECL_NAME (pack
);
4084 inform (loc
, " %qD", name
);
4086 inform (loc
, " %s", "<anonymous>");
4088 parameter_packs
= TREE_CHAIN (parameter_packs
);
4097 /* Expand any parameter packs that occur in the template arguments in
4100 expand_template_argument_pack (tree args
)
4102 if (args
== error_mark_node
)
4103 return error_mark_node
;
4105 tree result_args
= NULL_TREE
;
4106 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
4107 int num_result_args
= -1;
4108 int non_default_args_count
= -1;
4110 /* First, determine if we need to expand anything, and the number of
4111 slots we'll need. */
4112 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
4114 tree arg
= TREE_VEC_ELT (args
, in_arg
);
4115 if (arg
== NULL_TREE
)
4117 if (ARGUMENT_PACK_P (arg
))
4119 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
4120 if (num_result_args
< 0)
4121 num_result_args
= in_arg
+ num_packed
;
4123 num_result_args
+= num_packed
;
4127 if (num_result_args
>= 0)
4132 /* If no expansion is necessary, we're done. */
4133 if (num_result_args
< 0)
4136 /* Expand arguments. */
4137 result_args
= make_tree_vec (num_result_args
);
4138 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
4139 non_default_args_count
=
4140 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
4141 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
4143 tree arg
= TREE_VEC_ELT (args
, in_arg
);
4144 if (ARGUMENT_PACK_P (arg
))
4146 tree packed
= ARGUMENT_PACK_ARGS (arg
);
4147 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
4148 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
4149 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
4150 if (non_default_args_count
> 0)
4151 non_default_args_count
+= num_packed
- 1;
4155 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
4159 if (non_default_args_count
>= 0)
4160 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
4164 /* Checks if DECL shadows a template parameter.
4166 [temp.local]: A template-parameter shall not be redeclared within its
4167 scope (including nested scopes).
4169 Emits an error and returns TRUE if the DECL shadows a parameter,
4170 returns FALSE otherwise. */
4173 check_template_shadow (tree decl
)
4177 /* If we're not in a template, we can't possibly shadow a template
4179 if (!current_template_parms
)
4182 /* Figure out what we're shadowing. */
4183 decl
= OVL_FIRST (decl
);
4184 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
4186 /* If there's no previous binding for this name, we're not shadowing
4187 anything, let alone a template parameter. */
4191 /* If we're not shadowing a template parameter, we're done. Note
4192 that OLDDECL might be an OVERLOAD (or perhaps even an
4193 ERROR_MARK), so we can't just blithely assume it to be a _DECL
4195 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
4198 /* We check for decl != olddecl to avoid bogus errors for using a
4199 name inside a class. We check TPFI to avoid duplicate errors for
4200 inline member templates. */
4202 || (DECL_TEMPLATE_PARM_P (decl
)
4203 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
4206 /* Don't complain about the injected class name, as we've already
4207 complained about the class itself. */
4208 if (DECL_SELF_REFERENCE_P (decl
))
4211 if (DECL_TEMPLATE_PARM_P (decl
))
4212 error ("declaration of template parameter %q+D shadows "
4213 "template parameter", decl
);
4215 error ("declaration of %q+#D shadows template parameter", decl
);
4216 inform (DECL_SOURCE_LOCATION (olddecl
),
4217 "template parameter %qD declared here", olddecl
);
4221 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
4222 ORIG_LEVEL, DECL, and TYPE. */
4225 build_template_parm_index (int index
,
4231 tree t
= make_node (TEMPLATE_PARM_INDEX
);
4232 TEMPLATE_PARM_IDX (t
) = index
;
4233 TEMPLATE_PARM_LEVEL (t
) = level
;
4234 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
4235 TEMPLATE_PARM_DECL (t
) = decl
;
4236 TREE_TYPE (t
) = type
;
4237 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
4238 TREE_READONLY (t
) = TREE_READONLY (decl
);
4243 /* Find the canonical type parameter for the given template type
4244 parameter. Returns the canonical type parameter, which may be TYPE
4245 if no such parameter existed. */
4248 canonical_type_parameter (tree type
)
4251 int idx
= TEMPLATE_TYPE_IDX (type
);
4252 if (!canonical_template_parms
)
4253 vec_alloc (canonical_template_parms
, idx
+ 1);
4255 if (canonical_template_parms
->length () <= (unsigned) idx
)
4256 vec_safe_grow_cleared (canonical_template_parms
, idx
+ 1);
4258 list
= (*canonical_template_parms
)[idx
];
4259 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
4260 list
= TREE_CHAIN (list
);
4263 return TREE_VALUE (list
);
4266 (*canonical_template_parms
)[idx
]
4267 = tree_cons (NULL_TREE
, type
, (*canonical_template_parms
)[idx
]);
4272 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
4273 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
4274 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
4275 new one is created. */
4278 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
4279 tsubst_flags_t complain
)
4281 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
4282 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
4283 != TEMPLATE_PARM_LEVEL (index
) - levels
)
4284 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
4286 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
4289 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
4290 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
4291 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
4292 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
4293 DECL_ARTIFICIAL (decl
) = 1;
4294 SET_DECL_TEMPLATE_PARM_P (decl
);
4296 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
4297 TEMPLATE_PARM_LEVEL (index
) - levels
,
4298 TEMPLATE_PARM_ORIG_LEVEL (index
),
4300 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
4301 TEMPLATE_PARM_PARAMETER_PACK (t
)
4302 = TEMPLATE_PARM_PARAMETER_PACK (index
);
4304 /* Template template parameters need this. */
4305 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4307 DECL_TEMPLATE_RESULT (decl
)
4308 = build_decl (DECL_SOURCE_LOCATION (decl
),
4309 TYPE_DECL
, DECL_NAME (decl
), type
);
4310 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (decl
)) = true;
4311 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
4312 (DECL_TEMPLATE_PARMS (orig_decl
), args
, complain
);
4316 return TEMPLATE_PARM_DESCENDANTS (index
);
4319 /* Process information from new template parameter PARM and append it
4320 to the LIST being built. This new parameter is a non-type
4321 parameter iff IS_NON_TYPE is true. This new parameter is a
4322 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4326 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
4327 bool is_non_type
, bool is_parameter_pack
)
4332 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
4333 tree defval
= TREE_PURPOSE (parm
);
4334 tree constr
= TREE_TYPE (parm
);
4338 tree p
= tree_last (list
);
4340 if (p
&& TREE_VALUE (p
) != error_mark_node
)
4343 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
4344 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
4346 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
4354 parm
= TREE_VALUE (parm
);
4356 SET_DECL_TEMPLATE_PARM_P (parm
);
4358 if (TREE_TYPE (parm
) != error_mark_node
)
4362 The top-level cv-qualifiers on the template-parameter are
4363 ignored when determining its type. */
4364 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
4365 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
4366 TREE_TYPE (parm
) = error_mark_node
;
4367 else if (uses_parameter_packs (TREE_TYPE (parm
))
4368 && !is_parameter_pack
4369 /* If we're in a nested template parameter list, the template
4370 template parameter could be a parameter pack. */
4371 && processing_template_parmlist
== 1)
4373 /* This template parameter is not a parameter pack, but it
4374 should be. Complain about "bare" parameter packs. */
4375 check_for_bare_parameter_packs (TREE_TYPE (parm
));
4377 /* Recover by calling this a parameter pack. */
4378 is_parameter_pack
= true;
4382 /* A template parameter is not modifiable. */
4383 TREE_CONSTANT (parm
) = 1;
4384 TREE_READONLY (parm
) = 1;
4385 decl
= build_decl (parm_loc
,
4386 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
4387 TREE_CONSTANT (decl
) = 1;
4388 TREE_READONLY (decl
) = 1;
4389 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
4390 = build_template_parm_index (idx
, processing_template_decl
,
4391 processing_template_decl
,
4392 decl
, TREE_TYPE (parm
));
4394 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
4395 = is_parameter_pack
;
4400 parm
= TREE_VALUE (TREE_VALUE (parm
));
4402 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
4404 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
4405 /* This is for distinguishing between real templates and template
4406 template parameters */
4407 TREE_TYPE (parm
) = t
;
4408 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
4413 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
4414 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4415 decl
= build_decl (parm_loc
,
4416 TYPE_DECL
, parm
, t
);
4419 TYPE_NAME (t
) = decl
;
4420 TYPE_STUB_DECL (t
) = decl
;
4422 TEMPLATE_TYPE_PARM_INDEX (t
)
4423 = build_template_parm_index (idx
, processing_template_decl
,
4424 processing_template_decl
,
4425 decl
, TREE_TYPE (parm
));
4426 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
4427 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
4429 DECL_ARTIFICIAL (decl
) = 1;
4430 SET_DECL_TEMPLATE_PARM_P (decl
);
4432 /* Build requirements for the type/template parameter.
4433 This must be done after SET_DECL_TEMPLATE_PARM_P or
4434 process_template_parm could fail. */
4435 tree reqs
= finish_shorthand_constraint (parm
, constr
);
4437 decl
= pushdecl (decl
);
4441 /* Build the parameter node linking the parameter declaration,
4442 its default argument (if any), and its constraints (if any). */
4443 parm
= build_tree_list (defval
, parm
);
4444 TEMPLATE_PARM_CONSTRAINTS (parm
) = reqs
;
4446 return chainon (list
, parm
);
4449 /* The end of a template parameter list has been reached. Process the
4450 tree list into a parameter vector, converting each parameter into a more
4451 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4455 end_template_parm_list (tree parms
)
4459 tree saved_parmlist
= make_tree_vec (list_length (parms
));
4461 /* Pop the dummy parameter level and add the real one. */
4462 current_template_parms
= TREE_CHAIN (current_template_parms
);
4464 current_template_parms
4465 = tree_cons (size_int (processing_template_decl
),
4466 saved_parmlist
, current_template_parms
);
4468 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
4470 next
= TREE_CHAIN (parm
);
4471 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
4472 TREE_CHAIN (parm
) = NULL_TREE
;
4475 --processing_template_parmlist
;
4477 return saved_parmlist
;
4480 // Explicitly indicate the end of the template parameter list. We assume
4481 // that the current template parameters have been constructed and/or
4482 // managed explicitly, as when creating new template template parameters
4483 // from a shorthand constraint.
4485 end_template_parm_list ()
4487 --processing_template_parmlist
;
4490 /* end_template_decl is called after a template declaration is seen. */
4493 end_template_decl (void)
4495 reset_specialization ();
4497 if (! processing_template_decl
)
4500 /* This matches the pushlevel in begin_template_parm_list. */
4503 --processing_template_decl
;
4504 current_template_parms
= TREE_CHAIN (current_template_parms
);
4507 /* Takes a TREE_LIST representing a template parameter and convert it
4508 into an argument suitable to be passed to the type substitution
4509 functions. Note that If the TREE_LIST contains an error_mark
4510 node, the returned argument is error_mark_node. */
4513 template_parm_to_arg (tree t
)
4517 || TREE_CODE (t
) != TREE_LIST
)
4520 if (error_operand_p (TREE_VALUE (t
)))
4521 return error_mark_node
;
4525 if (TREE_CODE (t
) == TYPE_DECL
4526 || TREE_CODE (t
) == TEMPLATE_DECL
)
4530 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
4532 /* Turn this argument into a TYPE_ARGUMENT_PACK
4533 with a single element, which expands T. */
4534 tree vec
= make_tree_vec (1);
4536 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4538 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4540 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
4541 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4546 t
= DECL_INITIAL (t
);
4548 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
4550 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4551 with a single element, which expands T. */
4552 tree vec
= make_tree_vec (1);
4554 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4556 t
= convert_from_reference (t
);
4557 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4559 t
= make_node (NONTYPE_ARGUMENT_PACK
);
4560 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4563 t
= convert_from_reference (t
);
4568 /* Given a single level of template parameters (a TREE_VEC), return it
4569 as a set of template arguments. */
4572 template_parms_level_to_args (tree parms
)
4574 tree a
= copy_node (parms
);
4575 TREE_TYPE (a
) = NULL_TREE
;
4576 for (int i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
4577 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
4580 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
4585 /* Given a set of template parameters, return them as a set of template
4586 arguments. The template parameters are represented as a TREE_VEC, in
4587 the form documented in cp-tree.h for template arguments. */
4590 template_parms_to_args (tree parms
)
4593 tree args
= NULL_TREE
;
4594 int length
= TMPL_PARMS_DEPTH (parms
);
4597 /* If there is only one level of template parameters, we do not
4598 create a TREE_VEC of TREE_VECs. Instead, we return a single
4599 TREE_VEC containing the arguments. */
4601 args
= make_tree_vec (length
);
4603 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
4605 tree a
= template_parms_level_to_args (TREE_VALUE (header
));
4608 TREE_VEC_ELT (args
, --l
) = a
;
4616 /* Within the declaration of a template, return the currently active
4617 template parameters as an argument TREE_VEC. */
4620 current_template_args (void)
4622 return template_parms_to_args (current_template_parms
);
4625 /* Update the declared TYPE by doing any lookups which were thought to be
4626 dependent, but are not now that we know the SCOPE of the declarator. */
4629 maybe_update_decl_type (tree orig_type
, tree scope
)
4631 tree type
= orig_type
;
4633 if (type
== NULL_TREE
)
4636 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4637 type
= TREE_TYPE (type
);
4639 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
4640 && dependent_type_p (type
)
4641 /* Don't bother building up the args in this case. */
4642 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
4644 /* tsubst in the args corresponding to the template parameters,
4645 including auto if present. Most things will be unchanged, but
4646 make_typename_type and tsubst_qualified_id will resolve
4647 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4648 tree args
= current_template_args ();
4649 tree auto_node
= type_uses_auto (type
);
4653 tree auto_vec
= make_tree_vec (1);
4654 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4655 args
= add_to_template_args (args
, auto_vec
);
4657 pushed
= push_scope (scope
);
4658 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4663 if (type
== error_mark_node
)
4666 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4668 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4671 type
= TYPE_NAME (type
);
4676 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4677 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4678 the new template is a member template. */
4681 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4683 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4684 SET_DECL_LANGUAGE (tmpl
, DECL_LANGUAGE (decl
));
4685 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4686 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4687 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4688 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4693 struct template_parm_data
4695 /* The level of the template parameters we are currently
4699 /* The index of the specialization argument we are currently
4703 /* An array whose size is the number of template parameters. The
4704 elements are nonzero if the parameter has been used in any one
4705 of the arguments processed so far. */
4708 /* An array whose size is the number of template arguments. The
4709 elements are nonzero if the argument makes use of template
4710 parameters of this level. */
4711 int* arg_uses_template_parms
;
4714 /* Subroutine of push_template_decl used to see if each template
4715 parameter in a partial specialization is used in the explicit
4716 argument list. If T is of the LEVEL given in DATA (which is
4717 treated as a template_parm_data*), then DATA->PARMS is marked
4721 mark_template_parm (tree t
, void* data
)
4725 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4727 template_parm_level_and_index (t
, &level
, &idx
);
4729 if (level
== tpd
->level
)
4731 tpd
->parms
[idx
] = 1;
4732 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4735 /* In C++17 the type of a non-type argument is a deduced context. */
4736 if (cxx_dialect
>= cxx17
4737 && TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4738 for_each_template_parm (TREE_TYPE (t
),
4739 &mark_template_parm
,
4742 /*include_nondeduced_p=*/false);
4744 /* Return zero so that for_each_template_parm will continue the
4745 traversal of the tree; we want to mark *every* template parm. */
4749 /* Process the partial specialization DECL. */
4752 process_partial_specialization (tree decl
)
4754 tree type
= TREE_TYPE (decl
);
4755 tree tinfo
= get_template_info (decl
);
4756 tree maintmpl
= TI_TEMPLATE (tinfo
);
4757 tree specargs
= TI_ARGS (tinfo
);
4758 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4759 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4762 int nargs
= TREE_VEC_LENGTH (inner_args
);
4765 bool did_error_intro
= false;
4766 struct template_parm_data tpd
;
4767 struct template_parm_data tpd2
;
4769 gcc_assert (current_template_parms
);
4771 /* A concept cannot be specialized. */
4772 if (flag_concepts
&& variable_concept_p (maintmpl
))
4774 error ("specialization of variable concept %q#D", maintmpl
);
4775 return error_mark_node
;
4778 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4779 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4781 /* We check that each of the template parameters given in the
4782 partial specialization is used in the argument list to the
4783 specialization. For example:
4785 template <class T> struct S;
4786 template <class T> struct S<T*>;
4788 The second declaration is OK because `T*' uses the template
4789 parameter T, whereas
4791 template <class T> struct S<int>;
4793 is no good. Even trickier is:
4804 The S2<T> declaration is actually invalid; it is a
4805 full-specialization. Of course,
4808 struct S2<T (*)(U)>;
4810 or some such would have been OK. */
4811 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4812 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4813 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4815 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4816 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4817 for (i
= 0; i
< nargs
; ++i
)
4819 tpd
.current_arg
= i
;
4820 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4821 &mark_template_parm
,
4824 /*include_nondeduced_p=*/false);
4826 for (i
= 0; i
< ntparms
; ++i
)
4827 if (tpd
.parms
[i
] == 0)
4829 /* One of the template parms was not used in a deduced context in the
4831 if (!did_error_intro
)
4833 error ("template parameters not deducible in "
4834 "partial specialization:");
4835 did_error_intro
= true;
4838 inform (input_location
, " %qD",
4839 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4842 if (did_error_intro
)
4843 return error_mark_node
;
4845 /* [temp.class.spec]
4847 The argument list of the specialization shall not be identical to
4848 the implicit argument list of the primary template. */
4850 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl
)));
4851 if (comp_template_args (inner_args
, INNERMOST_TEMPLATE_ARGS (main_args
))
4853 || !strictly_subsumes (current_template_constraints (),
4854 get_constraints (maintmpl
))))
4857 error ("partial specialization %q+D does not specialize "
4858 "any template arguments; to define the primary template, "
4859 "remove the template argument list", decl
);
4861 error ("partial specialization %q+D does not specialize any "
4862 "template arguments and is not more constrained than "
4863 "the primary template; to define the primary template, "
4864 "remove the template argument list", decl
);
4865 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4868 /* A partial specialization that replaces multiple parameters of the
4869 primary template with a pack expansion is less specialized for those
4871 if (nargs
< DECL_NTPARMS (maintmpl
))
4873 error ("partial specialization is not more specialized than the "
4874 "primary template because it replaces multiple parameters "
4875 "with a pack expansion");
4876 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4877 /* Avoid crash in process_partial_specialization. */
4881 /* If we aren't in a dependent class, we can actually try deduction. */
4882 else if (tpd
.level
== 1
4883 /* FIXME we should be able to handle a partial specialization of a
4884 partial instantiation, but currently we can't (c++/41727). */
4885 && TMPL_ARGS_DEPTH (specargs
) == 1
4886 && !get_partial_spec_bindings (maintmpl
, maintmpl
, specargs
))
4888 auto_diagnostic_group d
;
4889 if (permerror (input_location
, "partial specialization %qD is not "
4890 "more specialized than", decl
))
4891 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template %qD",
4895 /* [temp.class.spec]
4897 A partially specialized non-type argument expression shall not
4898 involve template parameters of the partial specialization except
4899 when the argument expression is a simple identifier.
4901 The type of a template parameter corresponding to a specialized
4902 non-type argument shall not be dependent on a parameter of the
4905 Also, we verify that pack expansions only occur at the
4906 end of the argument list. */
4907 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4909 for (i
= 0; i
< nargs
; ++i
)
4911 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4912 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4913 tree packed_args
= NULL_TREE
;
4916 if (ARGUMENT_PACK_P (arg
))
4918 /* Extract the arguments from the argument pack. We'll be
4919 iterating over these in the following loop. */
4920 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4921 len
= TREE_VEC_LENGTH (packed_args
);
4924 for (j
= 0; j
< len
; j
++)
4927 /* Get the Jth argument in the parameter pack. */
4928 arg
= TREE_VEC_ELT (packed_args
, j
);
4930 if (PACK_EXPANSION_P (arg
))
4932 /* Pack expansions must come at the end of the
4934 if ((packed_args
&& j
< len
- 1)
4935 || (!packed_args
&& i
< nargs
- 1))
4937 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4938 error ("parameter pack argument %qE must be at the "
4939 "end of the template argument list", arg
);
4941 error ("parameter pack argument %qT must be at the "
4942 "end of the template argument list", arg
);
4946 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4947 /* We only care about the pattern. */
4948 arg
= PACK_EXPANSION_PATTERN (arg
);
4950 if (/* These first two lines are the `non-type' bit. */
4952 && TREE_CODE (arg
) != TEMPLATE_DECL
4953 /* This next two lines are the `argument expression is not just a
4954 simple identifier' condition and also the `specialized
4955 non-type argument' bit. */
4956 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4957 && !(REFERENCE_REF_P (arg
)
4958 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4960 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4961 || (packed_args
&& uses_template_parms (arg
)))
4962 error ("template argument %qE involves template parameter(s)",
4966 /* Look at the corresponding template parameter,
4967 marking which template parameters its type depends
4969 tree type
= TREE_TYPE (parm
);
4973 /* We haven't yet initialized TPD2. Do so now. */
4974 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4975 /* The number of parameters here is the number in the
4976 main template, which, as checked in the assertion
4978 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4980 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4983 /* Mark the template parameters. But this time, we're
4984 looking for the template parameters of the main
4985 template, not in the specialization. */
4986 tpd2
.current_arg
= i
;
4987 tpd2
.arg_uses_template_parms
[i
] = 0;
4988 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4989 for_each_template_parm (type
,
4990 &mark_template_parm
,
4993 /*include_nondeduced_p=*/false);
4995 if (tpd2
.arg_uses_template_parms
[i
])
4997 /* The type depended on some template parameters.
4998 If they are fully specialized in the
4999 specialization, that's OK. */
5002 for (j
= 0; j
< nargs
; ++j
)
5003 if (tpd2
.parms
[j
] != 0
5004 && tpd
.arg_uses_template_parms
[j
])
5007 error_n (input_location
, count
,
5008 "type %qT of template argument %qE depends "
5009 "on a template parameter",
5010 "type %qT of template argument %qE depends "
5011 "on template parameters",
5020 /* We should only get here once. */
5021 if (TREE_CODE (decl
) == TYPE_DECL
)
5022 gcc_assert (!COMPLETE_TYPE_P (type
));
5024 // Build the template decl.
5025 tree tmpl
= build_template_decl (decl
, current_template_parms
,
5026 DECL_MEMBER_TEMPLATE_P (maintmpl
));
5027 TREE_TYPE (tmpl
) = type
;
5028 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5029 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5030 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
5031 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
5033 /* Give template template parms a DECL_CONTEXT of the template
5034 for which they are a parameter. */
5035 for (i
= 0; i
< ntparms
; ++i
)
5037 tree parm
= TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
));
5038 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5039 DECL_CONTEXT (parm
) = tmpl
;
5043 /* We didn't register this in check_explicit_specialization so we could
5044 wait until the constraints were set. */
5045 decl
= register_specialization (decl
, maintmpl
, specargs
, false, 0);
5047 associate_classtype_constraints (type
);
5049 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
5050 = tree_cons (specargs
, tmpl
,
5051 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
5052 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
5054 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
5055 inst
= TREE_CHAIN (inst
))
5057 tree instance
= TREE_VALUE (inst
);
5058 if (TYPE_P (instance
)
5059 ? (COMPLETE_TYPE_P (instance
)
5060 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance
))
5061 : DECL_TEMPLATE_INSTANTIATION (instance
))
5063 tree spec
= most_specialized_partial_spec (instance
, tf_none
);
5064 tree inst_decl
= (DECL_P (instance
)
5065 ? instance
: TYPE_NAME (instance
));
5068 else if (spec
== error_mark_node
)
5069 permerror (input_location
,
5070 "declaration of %qD ambiguates earlier template "
5071 "instantiation for %qD", decl
, inst_decl
);
5072 else if (TREE_VALUE (spec
) == tmpl
)
5073 permerror (input_location
,
5074 "partial specialization of %qD after instantiation "
5075 "of %qD", decl
, inst_decl
);
5082 /* PARM is a template parameter of some form; return the corresponding
5083 TEMPLATE_PARM_INDEX. */
5086 get_template_parm_index (tree parm
)
5088 if (TREE_CODE (parm
) == PARM_DECL
5089 || TREE_CODE (parm
) == CONST_DECL
)
5090 parm
= DECL_INITIAL (parm
);
5091 else if (TREE_CODE (parm
) == TYPE_DECL
5092 || TREE_CODE (parm
) == TEMPLATE_DECL
)
5093 parm
= TREE_TYPE (parm
);
5094 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
5095 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
5096 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
5097 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
5098 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
5102 /* Subroutine of fixed_parameter_pack_p below. Look for any template
5103 parameter packs used by the template parameter PARM. */
5106 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
5108 /* A type parm can't refer to another parm. */
5109 if (TREE_CODE (parm
) == TYPE_DECL
|| parm
== error_mark_node
)
5111 else if (TREE_CODE (parm
) == PARM_DECL
)
5113 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
5118 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
5120 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
5121 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
5123 tree p
= TREE_VALUE (TREE_VEC_ELT (vec
, i
));
5124 if (template_parameter_pack_p (p
))
5125 /* Any packs in the type are expanded by this parameter. */;
5127 fixed_parameter_pack_p_1 (p
, ppd
);
5131 /* PARM is a template parameter pack. Return any parameter packs used in
5132 its type or the type of any of its template parameters. If there are
5133 any such packs, it will be instantiated into a fixed template parameter
5134 list by partial instantiation rather than be fully deduced. */
5137 fixed_parameter_pack_p (tree parm
)
5139 /* This can only be true in a member template. */
5140 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
5142 /* This can only be true for a parameter pack. */
5143 if (!template_parameter_pack_p (parm
))
5145 /* A type parm can't refer to another parm. */
5146 if (TREE_CODE (parm
) == TYPE_DECL
)
5149 tree parameter_packs
= NULL_TREE
;
5150 struct find_parameter_pack_data ppd
;
5151 ppd
.parameter_packs
= ¶meter_packs
;
5152 ppd
.visited
= new hash_set
<tree
>;
5153 ppd
.type_pack_expansion_p
= false;
5155 fixed_parameter_pack_p_1 (parm
, &ppd
);
5158 return parameter_packs
;
5161 /* Check that a template declaration's use of default arguments and
5162 parameter packs is not invalid. Here, PARMS are the template
5163 parameters. IS_PRIMARY is true if DECL is the thing declared by
5164 a primary template. IS_PARTIAL is true if DECL is a partial
5167 IS_FRIEND_DECL is nonzero if DECL is either a non-defining friend
5168 function template declaration or a friend class template
5169 declaration. In the function case, 1 indicates a declaration, 2
5170 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
5171 emitted for extraneous default arguments.
5173 Returns TRUE if there were no errors found, FALSE otherwise. */
5176 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
5177 bool is_partial
, int is_friend_decl
)
5180 int last_level_to_check
;
5182 bool no_errors
= true;
5186 A default template-argument shall not be specified in a
5187 function template declaration or a function template definition, nor
5188 in the template-parameter-list of the definition of a member of a
5191 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
5192 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
5193 /* You can't have a function template declaration in a local
5194 scope, nor you can you define a member of a class template in a
5198 if ((TREE_CODE (decl
) == TYPE_DECL
5200 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5201 || (TREE_CODE (decl
) == FUNCTION_DECL
5202 && LAMBDA_FUNCTION_P (decl
)))
5203 /* A lambda doesn't have an explicit declaration; don't complain
5204 about the parms of the enclosing class. */
5207 if (current_class_type
5208 && !TYPE_BEING_DEFINED (current_class_type
)
5209 && DECL_LANG_SPECIFIC (decl
)
5210 && DECL_DECLARES_FUNCTION_P (decl
)
5211 /* If this is either a friend defined in the scope of the class
5212 or a member function. */
5213 && (DECL_FUNCTION_MEMBER_P (decl
)
5214 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
5215 : DECL_FRIEND_CONTEXT (decl
)
5216 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
5218 /* And, if it was a member function, it really was defined in
5219 the scope of the class. */
5220 && (!DECL_FUNCTION_MEMBER_P (decl
)
5221 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
5222 /* We already checked these parameters when the template was
5223 declared, so there's no need to do it again now. This function
5224 was defined in class scope, but we're processing its body now
5225 that the class is complete. */
5228 /* Core issue 226 (C++0x only): the following only applies to class
5231 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
5235 If a template-parameter has a default template-argument, all
5236 subsequent template-parameters shall have a default
5237 template-argument supplied. */
5238 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
5240 tree inner_parms
= TREE_VALUE (parm_level
);
5241 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
5242 int seen_def_arg_p
= 0;
5245 for (i
= 0; i
< ntparms
; ++i
)
5247 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
5249 if (parm
== error_mark_node
)
5252 if (TREE_PURPOSE (parm
))
5254 else if (seen_def_arg_p
5255 && !template_parameter_pack_p (TREE_VALUE (parm
)))
5257 error ("no default argument for %qD", TREE_VALUE (parm
));
5258 /* For better subsequent error-recovery, we indicate that
5259 there should have been a default argument. */
5260 TREE_PURPOSE (parm
) = error_mark_node
;
5263 else if (!is_partial
5265 /* Don't complain about an enclosing partial
5267 && parm_level
== parms
5268 && TREE_CODE (decl
) == TYPE_DECL
5270 && template_parameter_pack_p (TREE_VALUE (parm
))
5271 /* A fixed parameter pack will be partially
5272 instantiated into a fixed length list. */
5273 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
5275 /* A primary class template can only have one
5276 parameter pack, at the end of the template
5279 error ("parameter pack %q+D must be at the end of the"
5280 " template parameter list", TREE_VALUE (parm
));
5282 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
5290 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
5294 /* For an ordinary class template, default template arguments are
5295 allowed at the innermost level, e.g.:
5296 template <class T = int>
5298 but, in a partial specialization, they're not allowed even
5299 there, as we have in [temp.class.spec]:
5301 The template parameter list of a specialization shall not
5302 contain default template argument values.
5304 So, for a partial specialization, or for a function template
5305 (in C++98/C++03), we look at all of them. */
5308 /* But, for a primary class template that is not a partial
5309 specialization we look at all template parameters except the
5311 parms
= TREE_CHAIN (parms
);
5313 /* Figure out what error message to issue. */
5314 if (is_friend_decl
== 2)
5315 msg
= G_("default template arguments may not be used in function template "
5316 "friend re-declaration");
5317 else if (is_friend_decl
)
5318 msg
= G_("default template arguments may not be used in template "
5319 "friend declarations");
5320 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
5321 msg
= G_("default template arguments may not be used in function templates "
5322 "without %<-std=c++11%> or %<-std=gnu++11%>");
5323 else if (is_partial
)
5324 msg
= G_("default template arguments may not be used in "
5325 "partial specializations");
5326 else if (current_class_type
&& CLASSTYPE_IS_TEMPLATE (current_class_type
))
5327 msg
= G_("default argument for template parameter for class enclosing %qD");
5329 /* Per [temp.param]/9, "A default template-argument shall not be
5330 specified in the template-parameter-lists of the definition of
5331 a member of a class template that appears outside of the member's
5332 class.", thus if we aren't handling a member of a class template
5333 there is no need to examine the parameters. */
5336 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
5337 /* If we're inside a class definition, there's no need to
5338 examine the parameters to the class itself. On the one
5339 hand, they will be checked when the class is defined, and,
5340 on the other, default arguments are valid in things like:
5341 template <class T = double>
5342 struct S { template <class U> void f(U); };
5343 Here the default argument for `S' has no bearing on the
5344 declaration of `f'. */
5345 last_level_to_check
= template_class_depth (current_class_type
) + 1;
5347 /* Check everything. */
5348 last_level_to_check
= 0;
5350 for (parm_level
= parms
;
5351 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
5352 parm_level
= TREE_CHAIN (parm_level
))
5354 tree inner_parms
= TREE_VALUE (parm_level
);
5358 ntparms
= TREE_VEC_LENGTH (inner_parms
);
5359 for (i
= 0; i
< ntparms
; ++i
)
5361 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
5364 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
5369 if (is_friend_decl
== 2)
5376 /* Clear out the default argument so that we are not
5378 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
5382 /* At this point, if we're still interested in issuing messages,
5383 they must apply to classes surrounding the object declared. */
5385 msg
= G_("default argument for template parameter for class "
5392 /* Worker for push_template_decl_real, called via
5393 for_each_template_parm. DATA is really an int, indicating the
5394 level of the parameters we are interested in. If T is a template
5395 parameter of that level, return nonzero. */
5398 template_parm_this_level_p (tree t
, void* data
)
5400 int this_level
= *(int *)data
;
5403 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5404 level
= TEMPLATE_PARM_LEVEL (t
);
5406 level
= TEMPLATE_TYPE_LEVEL (t
);
5407 return level
== this_level
;
5410 /* Worker for uses_outer_template_parms, called via for_each_template_parm.
5411 DATA is really an int, indicating the innermost outer level of parameters.
5412 If T is a template parameter of that level or further out, return
5416 template_parm_outer_level (tree t
, void *data
)
5418 int this_level
= *(int *)data
;
5421 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5422 level
= TEMPLATE_PARM_LEVEL (t
);
5424 level
= TEMPLATE_TYPE_LEVEL (t
);
5425 return level
<= this_level
;
5428 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5429 parameters given by current_template_args, or reuses a
5430 previously existing one, if appropriate. Returns the DECL, or an
5431 equivalent one, if it is replaced via a call to duplicate_decls.
5433 If IS_FRIEND is true, DECL is a friend declaration. */
5436 push_template_decl_real (tree decl
, bool is_friend
)
5444 int new_template_p
= 0;
5445 /* True if the template is a member template, in the sense of
5447 bool member_template_p
= false;
5449 if (decl
== error_mark_node
|| !current_template_parms
)
5450 return error_mark_node
;
5452 /* See if this is a partial specialization. */
5453 is_partial
= ((DECL_IMPLICIT_TYPEDEF_P (decl
)
5454 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
5455 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
5457 && DECL_LANG_SPECIFIC (decl
)
5458 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5459 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
))));
5461 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
5465 /* For a friend, we want the context of the friend, not
5466 the type of which it is a friend. */
5467 ctx
= CP_DECL_CONTEXT (decl
);
5468 else if (CP_DECL_CONTEXT (decl
)
5469 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
5470 /* In the case of a virtual function, we want the class in which
5472 ctx
= CP_DECL_CONTEXT (decl
);
5474 /* Otherwise, if we're currently defining some class, the DECL
5475 is assumed to be a member of the class. */
5476 ctx
= current_scope ();
5478 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5481 if (!DECL_CONTEXT (decl
))
5482 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
5484 /* See if this is a primary template. */
5485 if (is_friend
&& ctx
5486 && uses_template_parms_level (ctx
, processing_template_decl
))
5487 /* A friend template that specifies a class context, i.e.
5488 template <typename T> friend void A<T>::f();
5491 else if (TREE_CODE (decl
) == TYPE_DECL
5492 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5495 is_primary
= template_parm_scope_p ();
5499 warning (OPT_Wtemplates
, "template %qD declared", decl
);
5501 if (DECL_CLASS_SCOPE_P (decl
))
5502 member_template_p
= true;
5503 if (TREE_CODE (decl
) == TYPE_DECL
5504 && IDENTIFIER_ANON_P (DECL_NAME (decl
)))
5506 error ("template class without a name");
5507 return error_mark_node
;
5509 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
5511 if (member_template_p
)
5513 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
5514 error ("member template %qD may not have virt-specifiers", decl
);
5516 if (DECL_DESTRUCTOR_P (decl
))
5520 A destructor shall not be a member template. */
5521 error ("destructor %qD declared as member template", decl
);
5522 return error_mark_node
;
5524 if (IDENTIFIER_NEWDEL_OP_P (DECL_NAME (decl
))
5525 && (!prototype_p (TREE_TYPE (decl
))
5526 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
5527 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5528 || (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5529 == void_list_node
)))
5531 /* [basic.stc.dynamic.allocation]
5533 An allocation function can be a function
5534 template. ... Template allocation functions shall
5535 have two or more parameters. */
5536 error ("invalid template declaration of %qD", decl
);
5537 return error_mark_node
;
5540 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5541 && CLASS_TYPE_P (TREE_TYPE (decl
)))
5543 /* Class template, set TEMPLATE_TYPE_PARM_FOR_CLASS. */
5544 tree parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
5545 for (int i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
5547 tree t
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5548 if (TREE_CODE (t
) == TYPE_DECL
)
5550 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
5551 TEMPLATE_TYPE_PARM_FOR_CLASS (t
) = true;
5554 else if (TREE_CODE (decl
) == TYPE_DECL
5555 && TYPE_DECL_ALIAS_P (decl
))
5556 /* alias-declaration */
5557 gcc_assert (!DECL_ARTIFICIAL (decl
));
5558 else if (VAR_P (decl
))
5559 /* C++14 variable template. */;
5562 error ("template declaration of %q#D", decl
);
5563 return error_mark_node
;
5567 /* Check to see that the rules regarding the use of default
5568 arguments are not being violated. We check args for a friend
5569 functions when we know whether it's a definition, introducing
5570 declaration or re-declaration. */
5571 if (!is_friend
|| TREE_CODE (decl
) != FUNCTION_DECL
)
5572 check_default_tmpl_args (decl
, current_template_parms
,
5573 is_primary
, is_partial
, is_friend
);
5575 /* Ensure that there are no parameter packs in the type of this
5576 declaration that have not been expanded. */
5577 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5579 /* Check each of the arguments individually to see if there are
5580 any bare parameter packs. */
5581 tree type
= TREE_TYPE (decl
);
5582 tree arg
= DECL_ARGUMENTS (decl
);
5583 tree argtype
= TYPE_ARG_TYPES (type
);
5585 while (arg
&& argtype
)
5587 if (!DECL_PACK_P (arg
)
5588 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
5590 /* This is a PARM_DECL that contains unexpanded parameter
5591 packs. We have already complained about this in the
5592 check_for_bare_parameter_packs call, so just replace
5593 these types with ERROR_MARK_NODE. */
5594 TREE_TYPE (arg
) = error_mark_node
;
5595 TREE_VALUE (argtype
) = error_mark_node
;
5598 arg
= DECL_CHAIN (arg
);
5599 argtype
= TREE_CHAIN (argtype
);
5602 /* Check for bare parameter packs in the return type and the
5603 exception specifiers. */
5604 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
5605 /* Errors were already issued, set return type to int
5606 as the frontend doesn't expect error_mark_node as
5608 TREE_TYPE (type
) = integer_type_node
;
5609 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
5610 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
5612 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
5613 && TYPE_DECL_ALIAS_P (decl
))
5614 ? DECL_ORIGINAL_TYPE (decl
)
5615 : TREE_TYPE (decl
)))
5617 TREE_TYPE (decl
) = error_mark_node
;
5618 return error_mark_node
;
5622 return process_partial_specialization (decl
);
5624 args
= current_template_args ();
5627 || TREE_CODE (ctx
) == FUNCTION_DECL
5628 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
5629 || (TREE_CODE (decl
) == TYPE_DECL
5630 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5631 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
5633 if (DECL_LANG_SPECIFIC (decl
)
5634 && DECL_TEMPLATE_INFO (decl
)
5635 && DECL_TI_TEMPLATE (decl
))
5636 tmpl
= DECL_TI_TEMPLATE (decl
);
5637 /* If DECL is a TYPE_DECL for a class-template, then there won't
5638 be DECL_LANG_SPECIFIC. The information equivalent to
5639 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5640 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5641 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
5642 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
5644 /* Since a template declaration already existed for this
5645 class-type, we must be redeclaring it here. Make sure
5646 that the redeclaration is valid. */
5647 redeclare_class_template (TREE_TYPE (decl
),
5648 current_template_parms
,
5649 current_template_constraints ());
5650 /* We don't need to create a new TEMPLATE_DECL; just use the
5651 one we already had. */
5652 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
5656 tmpl
= build_template_decl (decl
, current_template_parms
,
5660 if (DECL_LANG_SPECIFIC (decl
)
5661 && DECL_TEMPLATE_SPECIALIZATION (decl
))
5663 /* A specialization of a member template of a template
5665 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5666 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
5667 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
5673 tree a
, t
, current
, parms
;
5675 tree tinfo
= get_template_info (decl
);
5679 error ("template definition of non-template %q#D", decl
);
5680 return error_mark_node
;
5683 tmpl
= TI_TEMPLATE (tinfo
);
5685 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
5686 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
5687 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5688 && DECL_MEMBER_TEMPLATE_P (tmpl
))
5692 /* The declaration is a specialization of a member
5693 template, declared outside the class. Therefore, the
5694 innermost template arguments will be NULL, so we
5695 replace them with the arguments determined by the
5696 earlier call to check_explicit_specialization. */
5697 args
= DECL_TI_ARGS (decl
);
5700 = build_template_decl (decl
, current_template_parms
,
5702 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
5703 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
5704 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
5705 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
5706 DECL_TEMPLATE_INFO (new_tmpl
)
5707 = build_template_info (tmpl
, args
);
5709 register_specialization (new_tmpl
,
5710 most_general_template (tmpl
),
5716 /* Make sure the template headers we got make sense. */
5718 parms
= DECL_TEMPLATE_PARMS (tmpl
);
5719 i
= TMPL_PARMS_DEPTH (parms
);
5720 if (TMPL_ARGS_DEPTH (args
) != i
)
5722 error ("expected %d levels of template parms for %q#D, got %d",
5723 i
, decl
, TMPL_ARGS_DEPTH (args
));
5724 DECL_INTERFACE_KNOWN (decl
) = 1;
5725 return error_mark_node
;
5728 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
5730 a
= TMPL_ARGS_LEVEL (args
, i
);
5731 t
= INNERMOST_TEMPLATE_PARMS (parms
);
5733 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
5735 if (current
== decl
)
5736 error ("got %d template parameters for %q#D",
5737 TREE_VEC_LENGTH (a
), decl
);
5739 error ("got %d template parameters for %q#T",
5740 TREE_VEC_LENGTH (a
), current
);
5741 error (" but %d required", TREE_VEC_LENGTH (t
));
5742 /* Avoid crash in import_export_decl. */
5743 DECL_INTERFACE_KNOWN (decl
) = 1;
5744 return error_mark_node
;
5747 if (current
== decl
)
5749 else if (current
== NULL_TREE
)
5750 /* Can happen in erroneous input. */
5753 current
= get_containing_scope (current
);
5756 /* Check that the parms are used in the appropriate qualifying scopes
5757 in the declarator. */
5758 if (!comp_template_args
5760 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
5762 error ("template arguments to %qD do not match original "
5763 "template %qD", decl
, DECL_TEMPLATE_RESULT (tmpl
));
5764 if (!uses_template_parms (TI_ARGS (tinfo
)))
5765 inform (input_location
, "use %<template<>%> for"
5766 " an explicit specialization");
5767 /* Avoid crash in import_export_decl. */
5768 DECL_INTERFACE_KNOWN (decl
) = 1;
5769 return error_mark_node
;
5773 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5774 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5776 /* Push template declarations for global functions and types. Note
5777 that we do not try to push a global template friend declared in a
5778 template class; such a thing may well depend on the template
5779 parameters of the class. */
5780 if (new_template_p
&& !ctx
5781 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5783 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5784 if (tmpl
== error_mark_node
)
5785 return error_mark_node
;
5787 /* Hide template friend classes that haven't been declared yet. */
5788 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5790 DECL_ANTICIPATED (tmpl
) = 1;
5791 DECL_FRIEND_P (tmpl
) = 1;
5797 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5799 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5801 /* Give template template parms a DECL_CONTEXT of the template
5802 for which they are a parameter. */
5803 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5804 for (int i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5806 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5807 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5808 DECL_CONTEXT (parm
) = tmpl
;
5811 if (TREE_CODE (decl
) == TYPE_DECL
5812 && TYPE_DECL_ALIAS_P (decl
)
5813 && complex_alias_template_p (tmpl
))
5814 TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl
) = true;
5817 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5818 back to its most general template. If TMPL is a specialization,
5819 ARGS may only have the innermost set of arguments. Add the missing
5820 argument levels if necessary. */
5821 if (DECL_TEMPLATE_INFO (tmpl
))
5822 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5824 info
= build_template_info (tmpl
, args
);
5826 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5827 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5831 retrofit_lang_decl (decl
);
5832 if (DECL_LANG_SPECIFIC (decl
))
5833 DECL_TEMPLATE_INFO (decl
) = info
;
5836 if (flag_implicit_templates
5838 && TREE_PUBLIC (decl
)
5839 && VAR_OR_FUNCTION_DECL_P (decl
))
5840 /* Set DECL_COMDAT on template instantiations; if we force
5841 them to be emitted by explicit instantiation or -frepo,
5842 mark_needed will tell cgraph to do the right thing. */
5843 DECL_COMDAT (decl
) = true;
5845 return DECL_TEMPLATE_RESULT (tmpl
);
5849 push_template_decl (tree decl
)
5851 return push_template_decl_real (decl
, false);
5854 /* FN is an inheriting constructor that inherits from the constructor
5855 template INHERITED; turn FN into a constructor template with a matching
5859 add_inherited_template_parms (tree fn
, tree inherited
)
5862 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5863 inner_parms
= copy_node (inner_parms
);
5865 = tree_cons (size_int (processing_template_decl
+ 1),
5866 inner_parms
, current_template_parms
);
5867 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5868 tree args
= template_parms_to_args (parms
);
5869 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5870 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5871 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5872 DECL_ARTIFICIAL (tmpl
) = true;
5873 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5877 /* Called when a class template TYPE is redeclared with the indicated
5878 template PARMS, e.g.:
5880 template <class T> struct S;
5881 template <class T> struct S {}; */
5884 redeclare_class_template (tree type
, tree parms
, tree cons
)
5890 if (!TYPE_TEMPLATE_INFO (type
))
5892 error ("%qT is not a template type", type
);
5896 tmpl
= TYPE_TI_TEMPLATE (type
);
5897 if (!PRIMARY_TEMPLATE_P (tmpl
))
5898 /* The type is nested in some template class. Nothing to worry
5899 about here; there are no new template parameters for the nested
5905 error ("template specifiers not specified in declaration of %qD",
5910 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5911 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5913 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5915 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5916 "redeclared with %d template parameter",
5917 "redeclared with %d template parameters",
5918 TREE_VEC_LENGTH (parms
));
5919 inform_n (DECL_SOURCE_LOCATION (tmpl
), TREE_VEC_LENGTH (tmpl_parms
),
5920 "previous declaration %qD used %d template parameter",
5921 "previous declaration %qD used %d template parameters",
5922 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5926 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5933 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5934 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5937 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5938 if (error_operand_p (tmpl_parm
))
5941 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5942 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5943 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5945 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5947 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5948 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5949 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5950 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5951 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5952 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5953 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5954 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5955 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5957 error ("template parameter %q+#D", tmpl_parm
);
5958 error ("redeclared here as %q#D", parm
);
5962 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5964 /* We have in [temp.param]:
5966 A template-parameter may not be given default arguments
5967 by two different declarations in the same scope. */
5968 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5969 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5970 "original definition appeared here");
5974 if (parm_default
!= NULL_TREE
)
5975 /* Update the previous template parameters (which are the ones
5976 that will really count) with the new default value. */
5977 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5978 else if (tmpl_default
!= NULL_TREE
)
5979 /* Update the new parameters, too; they'll be used as the
5980 parameters for any members. */
5981 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5983 /* Give each template template parm in this redeclaration a
5984 DECL_CONTEXT of the template for which they are a parameter. */
5985 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5987 gcc_assert (DECL_CONTEXT (parm
) == NULL_TREE
);
5988 DECL_CONTEXT (parm
) = tmpl
;
5991 if (TREE_CODE (parm
) == TYPE_DECL
)
5992 TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (parm
)) = true;
5995 // Cannot redeclare a class template with a different set of constraints.
5996 if (!equivalent_constraints (get_constraints (tmpl
), cons
))
5998 error_at (input_location
, "redeclaration %q#D with different "
5999 "constraints", tmpl
);
6000 inform (DECL_SOURCE_LOCATION (tmpl
),
6001 "original declaration appeared here");
6007 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
6008 to be used when the caller has already checked
6009 (processing_template_decl
6010 && !instantiation_dependent_expression_p (expr)
6011 && potential_constant_expression (expr))
6012 and cleared processing_template_decl. */
6015 instantiate_non_dependent_expr_internal (tree expr
, tsubst_flags_t complain
)
6017 return tsubst_copy_and_build (expr
,
6020 /*in_decl=*/NULL_TREE
,
6021 /*function_p=*/false,
6022 /*integral_constant_expression_p=*/true);
6025 /* Simplify EXPR if it is a non-dependent expression. Returns the
6026 (possibly simplified) expression. */
6029 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
6031 if (expr
== NULL_TREE
)
6034 /* If we're in a template, but EXPR isn't value dependent, simplify
6035 it. We're supposed to treat:
6037 template <typename T> void f(T[1 + 1]);
6038 template <typename T> void f(T[2]);
6040 as two declarations of the same function, for example. */
6041 if (processing_template_decl
6042 && is_nondependent_constant_expression (expr
))
6044 processing_template_decl_sentinel s
;
6045 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6051 instantiate_non_dependent_expr (tree expr
)
6053 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
6056 /* Like instantiate_non_dependent_expr, but return NULL_TREE rather than
6057 an uninstantiated expression. */
6060 instantiate_non_dependent_or_null (tree expr
)
6062 if (expr
== NULL_TREE
)
6064 if (processing_template_decl
)
6066 if (!is_nondependent_constant_expression (expr
))
6070 processing_template_decl_sentinel s
;
6071 expr
= instantiate_non_dependent_expr_internal (expr
, tf_error
);
6077 /* True iff T is a specialization of a variable template. */
6080 variable_template_specialization_p (tree t
)
6082 if (!VAR_P (t
) || !DECL_LANG_SPECIFIC (t
) || !DECL_TEMPLATE_INFO (t
))
6084 tree tmpl
= DECL_TI_TEMPLATE (t
);
6085 return variable_template_p (tmpl
);
6088 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
6089 template declaration, or a TYPE_DECL for an alias declaration. */
6092 alias_type_or_template_p (tree t
)
6096 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
6099 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
6100 || DECL_ALIAS_TEMPLATE_P (t
));
6103 /* Return TRUE iff T is a specialization of an alias template. */
6106 alias_template_specialization_p (const_tree t
)
6108 /* It's an alias template specialization if it's an alias and its
6109 TYPE_NAME is a specialization of a primary template. */
6110 if (TYPE_ALIAS_P (t
))
6111 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
6112 return PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
));
6117 /* An alias template is complex from a SFINAE perspective if a template-id
6118 using that alias can be ill-formed when the expansion is not, as with
6119 the void_t template. We determine this by checking whether the
6120 expansion for the alias template uses all its template parameters. */
6122 struct uses_all_template_parms_data
6129 uses_all_template_parms_r (tree t
, void *data_
)
6131 struct uses_all_template_parms_data
&data
6132 = *(struct uses_all_template_parms_data
*)data_
;
6133 tree idx
= get_template_parm_index (t
);
6135 if (TEMPLATE_PARM_LEVEL (idx
) == data
.level
)
6136 data
.seen
[TEMPLATE_PARM_IDX (idx
)] = true;
6141 complex_alias_template_p (const_tree tmpl
)
6143 struct uses_all_template_parms_data data
;
6144 tree pat
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
6145 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
6146 data
.level
= TMPL_PARMS_DEPTH (parms
);
6147 int len
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms
));
6148 data
.seen
= XALLOCAVEC (bool, len
);
6149 for (int i
= 0; i
< len
; ++i
)
6150 data
.seen
[i
] = false;
6152 for_each_template_parm (pat
, uses_all_template_parms_r
, &data
, NULL
, true);
6153 for (int i
= 0; i
< len
; ++i
)
6159 /* Return TRUE iff T is a specialization of a complex alias template with
6160 dependent template-arguments. */
6163 dependent_alias_template_spec_p (const_tree t
)
6165 if (!alias_template_specialization_p (t
))
6168 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
);
6169 if (!TEMPLATE_DECL_COMPLEX_ALIAS_P (TI_TEMPLATE (tinfo
)))
6172 tree args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
));
6173 if (!any_dependent_template_arguments_p (args
))
6179 /* Return the number of innermost template parameters in TMPL. */
6182 num_innermost_template_parms (tree tmpl
)
6184 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
6185 return TREE_VEC_LENGTH (parms
);
6188 /* Return either TMPL or another template that it is equivalent to under DR
6189 1286: An alias that just changes the name of a template is equivalent to
6190 the other template. */
6193 get_underlying_template (tree tmpl
)
6195 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
6196 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
6198 /* Determine if the alias is equivalent to an underlying template. */
6199 tree orig_type
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
6200 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (orig_type
);
6204 tree underlying
= TI_TEMPLATE (tinfo
);
6205 if (!PRIMARY_TEMPLATE_P (underlying
)
6206 || (num_innermost_template_parms (tmpl
)
6207 != num_innermost_template_parms (underlying
)))
6210 tree alias_args
= INNERMOST_TEMPLATE_ARGS
6211 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
6212 if (!comp_template_args (TI_ARGS (tinfo
), alias_args
))
6215 /* Alias is equivalent. Strip it and repeat. */
6222 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
6223 must be a reference-to-function or a pointer-to-function type, as specified
6224 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
6225 and check that the resulting function has external linkage. */
6228 convert_nontype_argument_function (tree type
, tree expr
,
6229 tsubst_flags_t complain
)
6233 linkage_kind linkage
;
6235 fn
= instantiate_type (type
, fns
, tf_none
);
6236 if (fn
== error_mark_node
)
6237 return error_mark_node
;
6239 if (value_dependent_expression_p (fn
))
6242 fn_no_ptr
= strip_fnptr_conv (fn
);
6243 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
6244 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
6245 if (BASELINK_P (fn_no_ptr
))
6246 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
6248 /* [temp.arg.nontype]/1
6250 A template-argument for a non-type, non-template template-parameter
6253 -- the address of an object or function with external [C++11: or
6254 internal] linkage. */
6256 STRIP_ANY_LOCATION_WRAPPER (fn_no_ptr
);
6257 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
6259 if (complain
& tf_error
)
6261 error ("%qE is not a valid template argument for type %qT",
6263 if (TYPE_PTR_P (type
))
6264 inform (input_location
, "it must be the address of a function "
6265 "with external linkage");
6267 inform (input_location
, "it must be the name of a function with "
6268 "external linkage");
6273 linkage
= decl_linkage (fn_no_ptr
);
6274 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
6276 if (complain
& tf_error
)
6278 if (cxx_dialect
>= cxx11
)
6279 error ("%qE is not a valid template argument for type %qT "
6280 "because %qD has no linkage",
6281 expr
, type
, fn_no_ptr
);
6283 error ("%qE is not a valid template argument for type %qT "
6284 "because %qD does not have external linkage",
6285 expr
, type
, fn_no_ptr
);
6291 if (TYPE_REF_P (type
))
6293 if (REFERENCE_REF_P (fn
))
6294 fn
= TREE_OPERAND (fn
, 0);
6296 fn
= build_address (fn
);
6298 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (fn
)))
6299 fn
= build_nop (type
, fn
);
6304 /* Subroutine of convert_nontype_argument.
6305 Check if EXPR of type TYPE is a valid pointer-to-member constant.
6306 Emit an error otherwise. */
6309 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
6310 tsubst_flags_t complain
)
6312 location_t loc
= cp_expr_loc_or_loc (expr
, input_location
);
6313 tree orig_expr
= expr
;
6315 if (null_ptr_cst_p (expr
))
6317 if (TREE_CODE (expr
) == PTRMEM_CST
6318 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
6319 PTRMEM_CST_CLASS (expr
)))
6321 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
6323 if (processing_template_decl
6324 && TREE_CODE (expr
) == ADDR_EXPR
6325 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
6327 if (complain
& tf_error
)
6329 error_at (loc
, "%qE is not a valid template argument for type %qT",
6331 if (TREE_CODE (expr
) != PTRMEM_CST
)
6332 inform (loc
, "it must be a pointer-to-member of the form %<&X::Y%>");
6334 inform (loc
, "because it is a member of %qT", PTRMEM_CST_CLASS (expr
));
6339 /* Returns TRUE iff the address of OP is value-dependent.
6341 14.6.2.4 [temp.dep.temp]:
6342 A non-integral non-type template-argument is dependent if its type is
6343 dependent or it has either of the following forms
6346 and contains a nested-name-specifier which specifies a class-name that
6347 names a dependent type.
6349 We generalize this to just say that the address of a member of a
6350 dependent class is value-dependent; the above doesn't cover the
6351 address of a static data member named with an unqualified-id. */
6354 has_value_dependent_address (tree op
)
6356 /* We could use get_inner_reference here, but there's no need;
6357 this is only relevant for template non-type arguments, which
6358 can only be expressed as &id-expression. */
6361 tree ctx
= CP_DECL_CONTEXT (op
);
6362 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
6369 /* The next set of functions are used for providing helpful explanatory
6370 diagnostics for failed overload resolution. Their messages should be
6371 indented by two spaces for consistency with the messages in
6375 unify_success (bool /*explain_p*/)
6380 /* Other failure functions should call this one, to provide a single function
6381 for setting a breakpoint on. */
6384 unify_invalid (bool /*explain_p*/)
6390 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
6393 inform (input_location
,
6394 " couldn%'t deduce template parameter %qD", parm
);
6395 return unify_invalid (explain_p
);
6399 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
6402 inform (input_location
,
6403 " types %qT and %qT have incompatible cv-qualifiers",
6405 return unify_invalid (explain_p
);
6409 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
6412 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
6413 return unify_invalid (explain_p
);
6417 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
6420 inform (input_location
,
6421 " template parameter %qD is not a parameter pack, but "
6424 return unify_invalid (explain_p
);
6428 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
6431 inform (input_location
,
6432 " template argument %qE does not match "
6433 "pointer-to-member constant %qE",
6435 return unify_invalid (explain_p
);
6439 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
6442 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
6443 return unify_invalid (explain_p
);
6447 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
6450 inform (input_location
,
6451 " inconsistent parameter pack deduction with %qT and %qT",
6453 return unify_invalid (explain_p
);
6457 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
6462 inform (input_location
,
6463 " deduced conflicting types for parameter %qT (%qT and %qT)",
6464 parm
, first
, second
);
6466 inform (input_location
,
6467 " deduced conflicting values for non-type parameter "
6468 "%qE (%qE and %qE)", parm
, first
, second
);
6470 return unify_invalid (explain_p
);
6474 unify_vla_arg (bool explain_p
, tree arg
)
6477 inform (input_location
,
6478 " variable-sized array type %qT is not "
6479 "a valid template argument",
6481 return unify_invalid (explain_p
);
6485 unify_method_type_error (bool explain_p
, tree arg
)
6488 inform (input_location
,
6489 " member function type %qT is not a valid template argument",
6491 return unify_invalid (explain_p
);
6495 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
6500 inform_n (input_location
, wanted
,
6501 " candidate expects at least %d argument, %d provided",
6502 " candidate expects at least %d arguments, %d provided",
6505 inform_n (input_location
, wanted
,
6506 " candidate expects %d argument, %d provided",
6507 " candidate expects %d arguments, %d provided",
6510 return unify_invalid (explain_p
);
6514 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
6516 return unify_arity (explain_p
, have
, wanted
);
6520 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
6521 bool least_p
= false)
6523 return unify_arity (explain_p
, have
, wanted
, least_p
);
6527 unify_arg_conversion (bool explain_p
, tree to_type
,
6528 tree from_type
, tree arg
)
6531 inform (cp_expr_loc_or_loc (arg
, input_location
),
6532 " cannot convert %qE (type %qT) to type %qT",
6533 arg
, from_type
, to_type
);
6534 return unify_invalid (explain_p
);
6538 unify_no_common_base (bool explain_p
, enum template_base_result r
,
6539 tree parm
, tree arg
)
6544 case tbr_ambiguous_baseclass
:
6545 inform (input_location
, " %qT is an ambiguous base class of %qT",
6549 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
6552 return unify_invalid (explain_p
);
6556 unify_inconsistent_template_template_parameters (bool explain_p
)
6559 inform (input_location
,
6560 " template parameters of a template template argument are "
6561 "inconsistent with other deduced template arguments");
6562 return unify_invalid (explain_p
);
6566 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
6569 inform (input_location
,
6570 " cannot deduce a template for %qT from non-template type %qT",
6572 return unify_invalid (explain_p
);
6576 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
6579 inform (input_location
,
6580 " template argument %qE does not match %qE", arg
, parm
);
6581 return unify_invalid (explain_p
);
6584 /* True if T is a C++20 template parameter object to store the argument for a
6585 template parameter of class type. */
6588 template_parm_object_p (const_tree t
)
6590 return (TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
) && DECL_NAME (t
)
6591 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (t
)), "_ZTA", 4));
6594 /* Subroutine of convert_nontype_argument, to check whether EXPR, as an
6595 argument for TYPE, points to an unsuitable object. */
6598 invalid_tparm_referent_p (tree type
, tree expr
, tsubst_flags_t complain
)
6600 switch (TREE_CODE (expr
))
6603 return invalid_tparm_referent_p (type
, TREE_OPERAND (expr
, 0),
6607 return invalid_tparm_referent_p (type
, TARGET_EXPR_INITIAL (expr
),
6612 unsigned i
; tree elt
;
6613 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), i
, elt
)
6614 if (invalid_tparm_referent_p (TREE_TYPE (elt
), elt
, complain
))
6621 tree decl
= TREE_OPERAND (expr
, 0);
6625 if (complain
& tf_error
)
6626 error ("%qE is not a valid template argument of type %qT "
6627 "because %qE is not a variable", expr
, type
, decl
);
6630 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
6632 if (complain
& tf_error
)
6633 error ("%qE is not a valid template argument of type %qT "
6634 "in C++98 because %qD does not have external linkage",
6638 else if ((cxx_dialect
>= cxx11
&& cxx_dialect
< cxx17
)
6639 && decl_linkage (decl
) == lk_none
)
6641 if (complain
& tf_error
)
6642 error ("%qE is not a valid template argument of type %qT "
6643 "because %qD has no linkage", expr
, type
, decl
);
6646 /* C++17: For a non-type template-parameter of reference or pointer
6647 type, the value of the constant expression shall not refer to (or
6648 for a pointer type, shall not be the address of):
6649 * a subobject (4.5),
6650 * a temporary object (15.2),
6651 * a string literal (5.13.5),
6652 * the result of a typeid expression (8.2.8), or
6653 * a predefined __func__ variable (11.4.1). */
6654 else if (DECL_ARTIFICIAL (decl
))
6656 if (complain
& tf_error
)
6657 error ("the address of %qD is not a valid template argument",
6661 else if (!same_type_ignoring_top_level_qualifiers_p
6662 (strip_array_types (TREE_TYPE (type
)),
6663 strip_array_types (TREE_TYPE (decl
))))
6665 if (complain
& tf_error
)
6666 error ("the address of the %qT subobject of %qD is not a "
6667 "valid template argument", TREE_TYPE (type
), decl
);
6670 else if (!TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
6672 if (complain
& tf_error
)
6673 error ("the address of %qD is not a valid template argument "
6674 "because it does not have static storage duration",
6682 if (!INDIRECT_TYPE_P (type
))
6683 /* We're only concerned about pointers and references here. */;
6684 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6685 /* Null pointer values are OK in C++11. */;
6690 if (complain
& tf_error
)
6691 error ("%qD is not a valid template argument "
6692 "because %qD is a variable, not the address of "
6693 "a variable", expr
, expr
);
6698 if (complain
& tf_error
)
6699 error ("%qE is not a valid template argument for %qT "
6700 "because it is not the address of a variable",
6710 /* Return a VAR_DECL for the C++20 template parameter object corresponding to
6711 template argument EXPR. */
6714 get_template_parm_object (tree expr
, tsubst_flags_t complain
)
6716 if (TREE_CODE (expr
) == TARGET_EXPR
)
6717 expr
= TARGET_EXPR_INITIAL (expr
);
6719 if (!TREE_CONSTANT (expr
))
6721 if ((complain
& tf_error
)
6722 && require_rvalue_constant_expression (expr
))
6723 cxx_constant_value (expr
);
6724 return error_mark_node
;
6726 if (invalid_tparm_referent_p (TREE_TYPE (expr
), expr
, complain
))
6727 return error_mark_node
;
6729 tree name
= mangle_template_parm_object (expr
);
6730 tree decl
= get_global_binding (name
);
6734 tree type
= cp_build_qualified_type (TREE_TYPE (expr
), TYPE_QUAL_CONST
);
6735 decl
= create_temporary_var (type
);
6736 TREE_STATIC (decl
) = true;
6737 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
6738 TREE_READONLY (decl
) = true;
6739 DECL_NAME (decl
) = name
;
6740 SET_DECL_ASSEMBLER_NAME (decl
, name
);
6741 DECL_CONTEXT (decl
) = global_namespace
;
6742 comdat_linkage (decl
);
6743 pushdecl_top_level_and_finish (decl
, expr
);
6747 /* Attempt to convert the non-type template parameter EXPR to the
6748 indicated TYPE. If the conversion is successful, return the
6749 converted value. If the conversion is unsuccessful, return
6750 NULL_TREE if we issued an error message, or error_mark_node if we
6751 did not. We issue error messages for out-and-out bad template
6752 parameters, but not simply because the conversion failed, since we
6753 might be just trying to do argument deduction. Both TYPE and EXPR
6754 must be non-dependent.
6756 The conversion follows the special rules described in
6757 [temp.arg.nontype], and it is much more strict than an implicit
6760 This function is called twice for each template argument (see
6761 lookup_template_class for a more accurate description of this
6762 problem). This means that we need to handle expressions which
6763 are not valid in a C++ source, but can be created from the
6764 first call (for instance, casts to perform conversions). These
6765 hacks can go away after we fix the double coercion problem. */
6768 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
6771 location_t loc
= cp_expr_loc_or_loc (expr
, input_location
);
6773 /* Detect immediately string literals as invalid non-type argument.
6774 This special-case is not needed for correctness (we would easily
6775 catch this later), but only to provide better diagnostic for this
6776 common user mistake. As suggested by DR 100, we do not mention
6777 linkage issues in the diagnostic as this is not the point. */
6778 if (TREE_CODE (expr
) == STRING_CST
&& !CLASS_TYPE_P (type
))
6780 if (complain
& tf_error
)
6781 error ("%qE is not a valid template argument for type %qT "
6782 "because string literals can never be used in this context",
6787 /* Add the ADDR_EXPR now for the benefit of
6788 value_dependent_expression_p. */
6789 if (TYPE_PTROBV_P (type
)
6790 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
6792 expr
= decay_conversion (expr
, complain
);
6793 if (expr
== error_mark_node
)
6794 return error_mark_node
;
6797 /* If we are in a template, EXPR may be non-dependent, but still
6798 have a syntactic, rather than semantic, form. For example, EXPR
6799 might be a SCOPE_REF, rather than the VAR_DECL to which the
6800 SCOPE_REF refers. Preserving the qualifying scope is necessary
6801 so that access checking can be performed when the template is
6802 instantiated -- but here we need the resolved form so that we can
6803 convert the argument. */
6804 bool non_dep
= false;
6805 if (TYPE_REF_OBJ_P (type
)
6806 && has_value_dependent_address (expr
))
6807 /* If we want the address and it's value-dependent, don't fold. */;
6808 else if (processing_template_decl
6809 && is_nondependent_constant_expression (expr
))
6811 if (error_operand_p (expr
))
6812 return error_mark_node
;
6813 expr_type
= TREE_TYPE (expr
);
6815 /* If the argument is non-dependent, perform any conversions in
6816 non-dependent context as well. */
6817 processing_template_decl_sentinel
s (non_dep
);
6819 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6821 if (value_dependent_expression_p (expr
))
6822 expr
= canonicalize_expr_argument (expr
, complain
);
6824 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
6825 to a non-type argument of "nullptr". */
6826 if (NULLPTR_TYPE_P (expr_type
) && TYPE_PTR_OR_PTRMEM_P (type
))
6827 expr
= fold_simple (convert (type
, expr
));
6829 /* In C++11, integral or enumeration non-type template arguments can be
6830 arbitrary constant expressions. Pointer and pointer to
6831 member arguments can be general constant expressions that evaluate
6832 to a null value, but otherwise still need to be of a specific form. */
6833 if (cxx_dialect
>= cxx11
)
6835 if (TREE_CODE (expr
) == PTRMEM_CST
&& TYPE_PTRMEM_P (type
))
6836 /* A PTRMEM_CST is already constant, and a valid template
6837 argument for a parameter of pointer to member type, we just want
6838 to leave it in that form rather than lower it to a
6840 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
6841 || cxx_dialect
>= cxx17
)
6843 /* Calling build_converted_constant_expr might create a call to
6844 a conversion function with a value-dependent argument, which
6845 could invoke taking the address of a temporary representing
6846 the result of the conversion. */
6847 if (COMPOUND_LITERAL_P (expr
)
6848 && CONSTRUCTOR_IS_DEPENDENT (expr
)
6849 && MAYBE_CLASS_TYPE_P (expr_type
)
6850 && TYPE_HAS_CONVERSION (expr_type
))
6852 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
6853 IMPLICIT_CONV_EXPR_NONTYPE_ARG (expr
) = true;
6856 /* C++17: A template-argument for a non-type template-parameter shall
6857 be a converted constant expression (8.20) of the type of the
6858 template-parameter. */
6859 expr
= build_converted_constant_expr (type
, expr
, complain
);
6860 if (expr
== error_mark_node
)
6861 /* Make sure we return NULL_TREE only if we have really issued
6862 an error, as described above. */
6863 return (complain
& tf_error
) ? NULL_TREE
: error_mark_node
;
6864 expr
= maybe_constant_value (expr
, NULL_TREE
,
6865 /*manifestly_const_eval=*/true);
6866 expr
= convert_from_reference (expr
);
6868 else if (TYPE_PTR_OR_PTRMEM_P (type
))
6870 tree folded
= maybe_constant_value (expr
, NULL_TREE
,
6871 /*manifestly_const_eval=*/true);
6872 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
6873 : null_member_pointer_value_p (folded
))
6878 if (TYPE_REF_P (type
))
6879 expr
= mark_lvalue_use (expr
);
6881 expr
= mark_rvalue_use (expr
);
6883 /* HACK: Due to double coercion, we can get a
6884 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
6885 which is the tree that we built on the first call (see
6886 below when coercing to reference to object or to reference to
6887 function). We just strip everything and get to the arg.
6888 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
6890 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
6892 tree probe_type
, probe
= expr
;
6893 if (REFERENCE_REF_P (probe
))
6894 probe
= TREE_OPERAND (probe
, 0);
6895 probe_type
= TREE_TYPE (probe
);
6896 if (TREE_CODE (probe
) == NOP_EXPR
)
6898 /* ??? Maybe we could use convert_from_reference here, but we
6899 would need to relax its constraints because the NOP_EXPR
6900 could actually change the type to something more cv-qualified,
6901 and this is not folded by convert_from_reference. */
6902 tree addr
= TREE_OPERAND (probe
, 0);
6903 if (TYPE_REF_P (probe_type
)
6904 && TREE_CODE (addr
) == ADDR_EXPR
6905 && TYPE_PTR_P (TREE_TYPE (addr
))
6906 && (same_type_ignoring_top_level_qualifiers_p
6907 (TREE_TYPE (probe_type
),
6908 TREE_TYPE (TREE_TYPE (addr
)))))
6910 expr
= TREE_OPERAND (addr
, 0);
6911 expr_type
= TREE_TYPE (probe_type
);
6916 /* [temp.arg.nontype]/5, bullet 1
6918 For a non-type template-parameter of integral or enumeration type,
6919 integral promotions (_conv.prom_) and integral conversions
6920 (_conv.integral_) are applied. */
6921 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6923 if (cxx_dialect
< cxx11
)
6925 tree t
= build_converted_constant_expr (type
, expr
, complain
);
6926 t
= maybe_constant_value (t
);
6927 if (t
!= error_mark_node
)
6931 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
6932 return error_mark_node
;
6934 /* Notice that there are constant expressions like '4 % 0' which
6935 do not fold into integer constants. */
6936 if (TREE_CODE (expr
) != INTEGER_CST
6937 && !value_dependent_expression_p (expr
))
6939 if (complain
& tf_error
)
6941 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
6942 if (!require_potential_constant_expression (expr
))
6943 expr
= error_mark_node
;
6945 expr
= cxx_constant_value (expr
);
6946 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
6947 inform (loc
, "in template argument for type %qT", type
);
6948 if (expr
== error_mark_node
)
6950 /* else cxx_constant_value complained but gave us
6951 a real constant, so go ahead. */
6952 if (TREE_CODE (expr
) != INTEGER_CST
)
6954 /* Some assemble time constant expressions like
6955 (intptr_t)&&lab1 - (intptr_t)&&lab2 or
6956 4 + (intptr_t)&&var satisfy reduced_constant_expression_p
6957 as we can emit them into .rodata initializers of
6958 variables, yet they can't fold into an INTEGER_CST at
6959 compile time. Refuse them here. */
6960 gcc_checking_assert (reduced_constant_expression_p (expr
));
6961 error_at (loc
, "template argument %qE for type %qT not "
6962 "a constant integer", expr
, type
);
6970 /* Avoid typedef problems. */
6971 if (TREE_TYPE (expr
) != type
)
6972 expr
= fold_convert (type
, expr
);
6974 /* [temp.arg.nontype]/5, bullet 2
6976 For a non-type template-parameter of type pointer to object,
6977 qualification conversions (_conv.qual_) and the array-to-pointer
6978 conversion (_conv.array_) are applied. */
6979 else if (TYPE_PTROBV_P (type
))
6981 tree decayed
= expr
;
6983 /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
6984 decay_conversion or an explicit cast. If it's a problematic cast,
6985 we'll complain about it below. */
6986 if (TREE_CODE (expr
) == NOP_EXPR
)
6990 if (TREE_CODE (probe
) == ADDR_EXPR
6991 && TYPE_PTR_P (TREE_TYPE (probe
)))
6994 expr_type
= TREE_TYPE (expr
);
6998 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
7000 A template-argument for a non-type, non-template template-parameter
7001 shall be one of: [...]
7003 -- the name of a non-type template-parameter;
7004 -- the address of an object or function with external linkage, [...]
7005 expressed as "& id-expression" where the & is optional if the name
7006 refers to a function or array, or if the corresponding
7007 template-parameter is a reference.
7009 Here, we do not care about functions, as they are invalid anyway
7010 for a parameter of type pointer-to-object. */
7012 if (value_dependent_expression_p (expr
))
7013 /* Non-type template parameters are OK. */
7015 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
7016 /* Null pointer values are OK in C++11. */;
7017 else if (TREE_CODE (expr
) != ADDR_EXPR
7018 && !INDIRECT_TYPE_P (expr_type
))
7019 /* Other values, like integer constants, might be valid
7020 non-type arguments of some other type. */
7021 return error_mark_node
;
7022 else if (invalid_tparm_referent_p (type
, expr
, complain
))
7027 expr
= perform_qualification_conversions (type
, expr
);
7028 if (expr
== error_mark_node
)
7029 return error_mark_node
;
7031 /* [temp.arg.nontype]/5, bullet 3
7033 For a non-type template-parameter of type reference to object, no
7034 conversions apply. The type referred to by the reference may be more
7035 cv-qualified than the (otherwise identical) type of the
7036 template-argument. The template-parameter is bound directly to the
7037 template-argument, which must be an lvalue. */
7038 else if (TYPE_REF_OBJ_P (type
))
7040 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
7042 return error_mark_node
;
7044 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
7046 if (complain
& tf_error
)
7047 error ("%qE is not a valid template argument for type %qT "
7048 "because of conflicts in cv-qualification", expr
, type
);
7052 if (!lvalue_p (expr
))
7054 if (complain
& tf_error
)
7055 error ("%qE is not a valid template argument for type %qT "
7056 "because it is not an lvalue", expr
, type
);
7060 /* [temp.arg.nontype]/1
7062 A template-argument for a non-type, non-template template-parameter
7063 shall be one of: [...]
7065 -- the address of an object or function with external linkage. */
7066 if (INDIRECT_REF_P (expr
)
7067 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
7069 expr
= TREE_OPERAND (expr
, 0);
7072 if (complain
& tf_error
)
7073 error ("%q#D is not a valid template argument for type %qT "
7074 "because a reference variable does not have a constant "
7075 "address", expr
, type
);
7080 if (TYPE_REF_OBJ_P (TREE_TYPE (expr
))
7081 && value_dependent_expression_p (expr
))
7082 /* OK, dependent reference. We don't want to ask whether a DECL is
7083 itself value-dependent, since what we want here is its address. */;
7086 expr
= build_address (expr
);
7088 if (invalid_tparm_referent_p (type
, expr
, complain
))
7092 if (!same_type_p (type
, TREE_TYPE (expr
)))
7093 expr
= build_nop (type
, expr
);
7095 /* [temp.arg.nontype]/5, bullet 4
7097 For a non-type template-parameter of type pointer to function, only
7098 the function-to-pointer conversion (_conv.func_) is applied. If the
7099 template-argument represents a set of overloaded functions (or a
7100 pointer to such), the matching function is selected from the set
7102 else if (TYPE_PTRFN_P (type
))
7104 /* If the argument is a template-id, we might not have enough
7105 context information to decay the pointer. */
7106 if (!type_unknown_p (expr_type
))
7108 expr
= decay_conversion (expr
, complain
);
7109 if (expr
== error_mark_node
)
7110 return error_mark_node
;
7113 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
7114 /* Null pointer values are OK in C++11. */
7115 return perform_qualification_conversions (type
, expr
);
7117 expr
= convert_nontype_argument_function (type
, expr
, complain
);
7118 if (!expr
|| expr
== error_mark_node
)
7121 /* [temp.arg.nontype]/5, bullet 5
7123 For a non-type template-parameter of type reference to function, no
7124 conversions apply. If the template-argument represents a set of
7125 overloaded functions, the matching function is selected from the set
7127 else if (TYPE_REFFN_P (type
))
7129 if (TREE_CODE (expr
) == ADDR_EXPR
)
7131 if (complain
& tf_error
)
7133 error ("%qE is not a valid template argument for type %qT "
7134 "because it is a pointer", expr
, type
);
7135 inform (input_location
, "try using %qE instead",
7136 TREE_OPERAND (expr
, 0));
7141 expr
= convert_nontype_argument_function (type
, expr
, complain
);
7142 if (!expr
|| expr
== error_mark_node
)
7145 /* [temp.arg.nontype]/5, bullet 6
7147 For a non-type template-parameter of type pointer to member function,
7148 no conversions apply. If the template-argument represents a set of
7149 overloaded member functions, the matching member function is selected
7150 from the set (_over.over_). */
7151 else if (TYPE_PTRMEMFUNC_P (type
))
7153 expr
= instantiate_type (type
, expr
, tf_none
);
7154 if (expr
== error_mark_node
)
7155 return error_mark_node
;
7157 /* [temp.arg.nontype] bullet 1 says the pointer to member
7158 expression must be a pointer-to-member constant. */
7159 if (!value_dependent_expression_p (expr
)
7160 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
7163 /* Repeated conversion can't deal with a conversion that turns PTRMEM_CST
7164 into a CONSTRUCTOR, so build up a new PTRMEM_CST instead. */
7165 if (fnptr_conv_p (type
, TREE_TYPE (expr
)))
7166 expr
= make_ptrmem_cst (type
, PTRMEM_CST_MEMBER (expr
));
7168 /* [temp.arg.nontype]/5, bullet 7
7170 For a non-type template-parameter of type pointer to data member,
7171 qualification conversions (_conv.qual_) are applied. */
7172 else if (TYPE_PTRDATAMEM_P (type
))
7174 /* [temp.arg.nontype] bullet 1 says the pointer to member
7175 expression must be a pointer-to-member constant. */
7176 if (!value_dependent_expression_p (expr
)
7177 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
7180 expr
= perform_qualification_conversions (type
, expr
);
7181 if (expr
== error_mark_node
)
7184 else if (NULLPTR_TYPE_P (type
))
7186 if (!NULLPTR_TYPE_P (TREE_TYPE (expr
)))
7188 if (complain
& tf_error
)
7189 error ("%qE is not a valid template argument for type %qT "
7190 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
7195 else if (CLASS_TYPE_P (type
))
7197 /* Replace the argument with a reference to the corresponding template
7198 parameter object. */
7199 if (!value_dependent_expression_p (expr
))
7200 expr
= get_template_parm_object (expr
, complain
);
7201 if (expr
== error_mark_node
)
7204 /* A template non-type parameter must be one of the above. */
7208 /* Sanity check: did we actually convert the argument to the
7210 gcc_assert (same_type_ignoring_top_level_qualifiers_p
7211 (type
, TREE_TYPE (expr
)));
7212 return convert_from_reference (expr
);
7215 /* Subroutine of coerce_template_template_parms, which returns 1 if
7216 PARM_PARM and ARG_PARM match using the rule for the template
7217 parameters of template template parameters. Both PARM and ARG are
7218 template parameters; the rest of the arguments are the same as for
7219 coerce_template_template_parms.
7222 coerce_template_template_parm (tree parm
,
7224 tsubst_flags_t complain
,
7228 if (arg
== NULL_TREE
|| error_operand_p (arg
)
7229 || parm
== NULL_TREE
|| error_operand_p (parm
))
7232 if (TREE_CODE (arg
) != TREE_CODE (parm
))
7235 switch (TREE_CODE (parm
))
7238 /* We encounter instantiations of templates like
7239 template <template <template <class> class> class TT>
7242 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
7243 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
7245 if (!coerce_template_template_parms
7246 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
7252 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
7253 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
7254 /* Argument is a parameter pack but parameter is not. */
7259 /* The tsubst call is used to handle cases such as
7261 template <int> class C {};
7262 template <class T, template <T> class TT> class D {};
7265 i.e. the parameter list of TT depends on earlier parameters. */
7266 if (!uses_template_parms (TREE_TYPE (arg
)))
7268 tree t
= tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
);
7269 if (!uses_template_parms (t
)
7270 && !same_type_p (t
, TREE_TYPE (arg
)))
7274 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
7275 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
7276 /* Argument is a parameter pack but parameter is not. */
7288 /* Coerce template argument list ARGLIST for use with template
7289 template-parameter TEMPL. */
7292 coerce_template_args_for_ttp (tree templ
, tree arglist
,
7293 tsubst_flags_t complain
)
7295 /* Consider an example where a template template parameter declared as
7297 template <class T, class U = std::allocator<T> > class TT
7299 The template parameter level of T and U are one level larger than
7300 of TT. To proper process the default argument of U, say when an
7301 instantiation `TT<int>' is seen, we need to build the full
7302 arguments containing {int} as the innermost level. Outer levels,
7303 available when not appearing as default template argument, can be
7304 obtained from the arguments of the enclosing template.
7306 Suppose that TT is later substituted with std::vector. The above
7307 instantiation is `TT<int, std::allocator<T> >' with TT at
7308 level 1, and T at level 2, while the template arguments at level 1
7309 becomes {std::vector} and the inner level 2 is {int}. */
7311 tree outer
= DECL_CONTEXT (templ
);
7314 if (DECL_TEMPLATE_SPECIALIZATION (outer
))
7315 /* We want arguments for the partial specialization, not arguments for
7316 the primary template. */
7317 outer
= template_parms_to_args (DECL_TEMPLATE_PARMS (outer
));
7319 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7321 else if (current_template_parms
)
7323 /* This is an argument of the current template, so we haven't set
7324 DECL_CONTEXT yet. */
7325 tree relevant_template_parms
;
7327 /* Parameter levels that are greater than the level of the given
7328 template template parm are irrelevant. */
7329 relevant_template_parms
= current_template_parms
;
7330 while (TMPL_PARMS_DEPTH (relevant_template_parms
)
7331 != TEMPLATE_TYPE_LEVEL (TREE_TYPE (templ
)))
7332 relevant_template_parms
= TREE_CHAIN (relevant_template_parms
);
7334 outer
= template_parms_to_args (relevant_template_parms
);
7338 arglist
= add_to_template_args (outer
, arglist
);
7340 tree parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7341 return coerce_template_parms (parmlist
, arglist
, templ
,
7343 /*require_all_args=*/true,
7344 /*use_default_args=*/true);
7347 /* A cache of template template parameters with match-all default
7349 static GTY((deletable
)) hash_map
<tree
,tree
> *defaulted_ttp_cache
;
7351 store_defaulted_ttp (tree v
, tree t
)
7353 if (!defaulted_ttp_cache
)
7354 defaulted_ttp_cache
= hash_map
<tree
,tree
>::create_ggc (13);
7355 defaulted_ttp_cache
->put (v
, t
);
7358 lookup_defaulted_ttp (tree v
)
7360 if (defaulted_ttp_cache
)
7361 if (tree
*p
= defaulted_ttp_cache
->get (v
))
7366 /* T is a bound template template-parameter. Copy its arguments into default
7367 arguments of the template template-parameter's template parameters. */
7370 add_defaults_to_ttp (tree otmpl
)
7372 if (tree c
= lookup_defaulted_ttp (otmpl
))
7375 tree ntmpl
= copy_node (otmpl
);
7377 tree ntype
= copy_node (TREE_TYPE (otmpl
));
7378 TYPE_STUB_DECL (ntype
) = TYPE_NAME (ntype
) = ntmpl
;
7379 TYPE_MAIN_VARIANT (ntype
) = ntype
;
7380 TYPE_POINTER_TO (ntype
) = TYPE_REFERENCE_TO (ntype
) = NULL_TREE
;
7381 TYPE_NAME (ntype
) = ntmpl
;
7382 SET_TYPE_STRUCTURAL_EQUALITY (ntype
);
7384 tree idx
= TEMPLATE_TYPE_PARM_INDEX (ntype
)
7385 = copy_node (TEMPLATE_TYPE_PARM_INDEX (ntype
));
7386 TEMPLATE_PARM_DECL (idx
) = ntmpl
;
7387 TREE_TYPE (ntmpl
) = TREE_TYPE (idx
) = ntype
;
7389 tree oparms
= DECL_TEMPLATE_PARMS (otmpl
);
7390 tree parms
= DECL_TEMPLATE_PARMS (ntmpl
) = copy_node (oparms
);
7391 TREE_CHAIN (parms
) = TREE_CHAIN (oparms
);
7392 tree vec
= TREE_VALUE (parms
) = copy_node (TREE_VALUE (parms
));
7393 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
7395 tree o
= TREE_VEC_ELT (vec
, i
);
7396 if (!template_parameter_pack_p (TREE_VALUE (o
)))
7398 tree n
= TREE_VEC_ELT (vec
, i
) = copy_node (o
);
7399 TREE_PURPOSE (n
) = any_targ_node
;
7403 store_defaulted_ttp (otmpl
, ntmpl
);
7407 /* ARG is a bound potential template template-argument, and PARGS is a list
7408 of arguments for the corresponding template template-parameter. Adjust
7409 PARGS as appropriate for application to ARG's template, and if ARG is a
7410 BOUND_TEMPLATE_TEMPLATE_PARM, possibly adjust it to add default template
7411 arguments to the template template parameter. */
7414 coerce_ttp_args_for_tta (tree
& arg
, tree pargs
, tsubst_flags_t complain
)
7416 ++processing_template_decl
;
7417 tree arg_tmpl
= TYPE_TI_TEMPLATE (arg
);
7418 if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg_tmpl
))
7420 /* When comparing two template template-parameters in partial ordering,
7421 rewrite the one currently being used as an argument to have default
7422 arguments for all parameters. */
7423 arg_tmpl
= add_defaults_to_ttp (arg_tmpl
);
7424 pargs
= coerce_template_args_for_ttp (arg_tmpl
, pargs
, complain
);
7425 if (pargs
!= error_mark_node
)
7426 arg
= bind_template_template_parm (TREE_TYPE (arg_tmpl
),
7427 TYPE_TI_ARGS (arg
));
7432 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (arg_tmpl
));
7433 pargs
= coerce_template_parms (aparms
, pargs
, arg_tmpl
, complain
,
7434 /*require_all*/true,
7435 /*use_default*/true);
7437 --processing_template_decl
;
7441 /* Subroutine of unify for the case when PARM is a
7442 BOUND_TEMPLATE_TEMPLATE_PARM. */
7445 unify_bound_ttp_args (tree tparms
, tree targs
, tree parm
, tree
& arg
,
7448 tree parmvec
= TYPE_TI_ARGS (parm
);
7449 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
7451 /* The template template parm might be variadic and the argument
7452 not, so flatten both argument lists. */
7453 parmvec
= expand_template_argument_pack (parmvec
);
7454 argvec
= expand_template_argument_pack (argvec
);
7458 /* In keeping with P0522R0, adjust P's template arguments
7459 to apply to A's template; then flatten it again. */
7460 tree nparmvec
= coerce_ttp_args_for_tta (arg
, parmvec
, tf_none
);
7461 nparmvec
= expand_template_argument_pack (nparmvec
);
7463 if (unify (tparms
, targs
, nparmvec
, argvec
,
7464 UNIFY_ALLOW_NONE
, explain_p
))
7467 /* If the P0522 adjustment eliminated a pack expansion, deduce
7470 && TREE_VEC_LENGTH (nparmvec
) < TREE_VEC_LENGTH (parmvec
)
7471 && unify_pack_expansion (tparms
, targs
, parmvec
, argvec
,
7472 DEDUCE_EXACT
, /*sub*/true, explain_p
))
7477 /* Deduce arguments T, i from TT<T> or TT<i>.
7478 We check each element of PARMVEC and ARGVEC individually
7479 rather than the whole TREE_VEC since they can have
7480 different number of elements, which is allowed under N2555. */
7482 int len
= TREE_VEC_LENGTH (parmvec
);
7484 /* Check if the parameters end in a pack, making them
7486 int parm_variadic_p
= 0;
7488 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
7489 parm_variadic_p
= 1;
7491 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7492 /* If the template argument list of P contains a pack
7493 expansion that is not the last template argument, the
7494 entire template argument list is a non-deduced
7496 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
7497 return unify_success (explain_p
);
7499 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
7500 return unify_too_few_arguments (explain_p
,
7501 TREE_VEC_LENGTH (argvec
), len
);
7503 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7504 if (unify (tparms
, targs
,
7505 TREE_VEC_ELT (parmvec
, i
),
7506 TREE_VEC_ELT (argvec
, i
),
7507 UNIFY_ALLOW_NONE
, explain_p
))
7511 && unify_pack_expansion (tparms
, targs
,
7514 /*subr=*/true, explain_p
))
7521 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
7522 template template parameters. Both PARM_PARMS and ARG_PARMS are
7523 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
7526 Consider the example:
7527 template <class T> class A;
7528 template<template <class U> class TT> class B;
7530 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
7531 the parameters to A, and OUTER_ARGS contains A. */
7534 coerce_template_template_parms (tree parm_parms
,
7536 tsubst_flags_t complain
,
7540 int nparms
, nargs
, i
;
7544 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
7545 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
7547 nparms
= TREE_VEC_LENGTH (parm_parms
);
7548 nargs
= TREE_VEC_LENGTH (arg_parms
);
7552 /* P0522R0: A template template-parameter P is at least as specialized as
7553 a template template-argument A if, given the following rewrite to two
7554 function templates, the function template corresponding to P is at
7555 least as specialized as the function template corresponding to A
7556 according to the partial ordering rules for function templates
7557 ([temp.func.order]). Given an invented class template X with the
7558 template parameter list of A (including default arguments):
7560 * Each of the two function templates has the same template parameters,
7561 respectively, as P or A.
7563 * Each function template has a single function parameter whose type is
7564 a specialization of X with template arguments corresponding to the
7565 template parameters from the respective function template where, for
7566 each template parameter PP in the template parameter list of the
7567 function template, a corresponding template argument AA is formed. If
7568 PP declares a parameter pack, then AA is the pack expansion
7569 PP... ([temp.variadic]); otherwise, AA is the id-expression PP.
7571 If the rewrite produces an invalid type, then P is not at least as
7572 specialized as A. */
7574 /* So coerce P's args to apply to A's parms, and then deduce between A's
7575 args and the converted args. If that succeeds, A is at least as
7576 specialized as P, so they match.*/
7577 tree pargs
= template_parms_level_to_args (parm_parms
);
7578 pargs
= add_outermost_template_args (outer_args
, pargs
);
7579 ++processing_template_decl
;
7580 pargs
= coerce_template_parms (arg_parms
, pargs
, NULL_TREE
, tf_none
,
7581 /*require_all*/true, /*use_default*/true);
7582 --processing_template_decl
;
7583 if (pargs
!= error_mark_node
)
7585 tree targs
= make_tree_vec (nargs
);
7586 tree aargs
= template_parms_level_to_args (arg_parms
);
7587 if (!unify (arg_parms
, targs
, aargs
, pargs
, UNIFY_ALLOW_NONE
,
7593 /* Determine whether we have a parameter pack at the end of the
7594 template template parameter's template parameter list. */
7595 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
7597 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
7599 if (error_operand_p (parm
))
7602 switch (TREE_CODE (parm
))
7606 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
7611 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
7621 && !(variadic_p
&& nargs
>= nparms
- 1))
7624 /* Check all of the template parameters except the parameter pack at
7625 the end (if any). */
7626 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
7628 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
7629 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7632 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7633 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7635 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7643 /* Check each of the template parameters in the template
7644 argument against the template parameter pack at the end of
7645 the template template parameter. */
7646 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
7649 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7651 for (; i
< nargs
; ++i
)
7653 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7656 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7658 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7667 /* Verifies that the deduced template arguments (in TARGS) for the
7668 template template parameters (in TPARMS) represent valid bindings,
7669 by comparing the template parameter list of each template argument
7670 to the template parameter list of its corresponding template
7671 template parameter, in accordance with DR150. This
7672 routine can only be called after all template arguments have been
7673 deduced. It will return TRUE if all of the template template
7674 parameter bindings are okay, FALSE otherwise. */
7676 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
7678 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
7681 /* We're dealing with template parms in this process. */
7682 ++processing_template_decl
;
7684 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
7686 for (i
= 0; i
< ntparms
; ++i
)
7688 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
7689 tree targ
= TREE_VEC_ELT (targs
, i
);
7691 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
7693 tree packed_args
= NULL_TREE
;
7696 if (ARGUMENT_PACK_P (targ
))
7698 /* Look inside the argument pack. */
7699 packed_args
= ARGUMENT_PACK_ARGS (targ
);
7700 len
= TREE_VEC_LENGTH (packed_args
);
7703 for (idx
= 0; idx
< len
; ++idx
)
7705 tree targ_parms
= NULL_TREE
;
7708 /* Extract the next argument from the argument
7710 targ
= TREE_VEC_ELT (packed_args
, idx
);
7712 if (PACK_EXPANSION_P (targ
))
7713 /* Look at the pattern of the pack expansion. */
7714 targ
= PACK_EXPANSION_PATTERN (targ
);
7716 /* Extract the template parameters from the template
7718 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
7719 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
7720 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
7721 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
7723 /* Verify that we can coerce the template template
7724 parameters from the template argument to the template
7725 parameter. This requires an exact match. */
7727 && !coerce_template_template_parms
7728 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
7743 --processing_template_decl
;
7747 /* Since type attributes aren't mangled, we need to strip them from
7748 template type arguments. */
7751 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
7753 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
7755 bool removed_attributes
= false;
7756 tree canon
= strip_typedefs (arg
, &removed_attributes
);
7757 if (removed_attributes
7758 && (complain
& tf_warning
))
7759 warning (OPT_Wignored_attributes
,
7760 "ignoring attributes on template argument %qT", arg
);
7764 /* And from inside dependent non-type arguments like sizeof(Type). */
7767 canonicalize_expr_argument (tree arg
, tsubst_flags_t complain
)
7769 if (!arg
|| arg
== error_mark_node
)
7771 bool removed_attributes
= false;
7772 tree canon
= strip_typedefs_expr (arg
, &removed_attributes
);
7773 if (removed_attributes
7774 && (complain
& tf_warning
))
7775 warning (OPT_Wignored_attributes
,
7776 "ignoring attributes in template argument %qE", arg
);
7780 // A template declaration can be substituted for a constrained
7781 // template template parameter only when the argument is more
7782 // constrained than the parameter.
7784 is_compatible_template_arg (tree parm
, tree arg
)
7786 tree parm_cons
= get_constraints (parm
);
7788 /* For now, allow constrained template template arguments
7789 and unconstrained template template parameters. */
7790 if (parm_cons
== NULL_TREE
)
7793 tree arg_cons
= get_constraints (arg
);
7795 // If the template parameter is constrained, we need to rewrite its
7796 // constraints in terms of the ARG's template parameters. This ensures
7797 // that all of the template parameter types will have the same depth.
7799 // Note that this is only valid when coerce_template_template_parm is
7800 // true for the innermost template parameters of PARM and ARG. In other
7801 // words, because coercion is successful, this conversion will be valid.
7804 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (arg
));
7805 parm_cons
= tsubst_constraint_info (parm_cons
,
7806 INNERMOST_TEMPLATE_ARGS (args
),
7807 tf_none
, NULL_TREE
);
7808 if (parm_cons
== error_mark_node
)
7812 return subsumes (parm_cons
, arg_cons
);
7815 // Convert a placeholder argument into a binding to the original
7816 // parameter. The original parameter is saved as the TREE_TYPE of
7819 convert_wildcard_argument (tree parm
, tree arg
)
7821 TREE_TYPE (arg
) = parm
;
7825 /* We can't fully resolve ARG given as a non-type template argument to TYPE,
7826 because one of them is dependent. But we need to represent the
7827 conversion for the benefit of cp_tree_equal. */
7830 maybe_convert_nontype_argument (tree type
, tree arg
)
7832 /* Auto parms get no conversion. */
7833 if (type_uses_auto (type
))
7835 /* We don't need or want to add this conversion now if we're going to use the
7836 argument for deduction. */
7837 if (value_dependent_expression_p (arg
))
7840 type
= cv_unqualified (type
);
7841 tree argtype
= TREE_TYPE (arg
);
7842 if (same_type_p (type
, argtype
))
7845 arg
= build1 (IMPLICIT_CONV_EXPR
, type
, arg
);
7846 IMPLICIT_CONV_EXPR_NONTYPE_ARG (arg
) = true;
7850 /* Convert the indicated template ARG as necessary to match the
7851 indicated template PARM. Returns the converted ARG, or
7852 error_mark_node if the conversion was unsuccessful. Error and
7853 warning messages are issued under control of COMPLAIN. This
7854 conversion is for the Ith parameter in the parameter list. ARGS is
7855 the full set of template arguments deduced so far. */
7858 convert_template_argument (tree parm
,
7861 tsubst_flags_t complain
,
7867 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
7869 if (parm
== error_mark_node
|| error_operand_p (arg
))
7870 return error_mark_node
;
7872 /* Trivially convert placeholders. */
7873 if (TREE_CODE (arg
) == WILDCARD_DECL
)
7874 return convert_wildcard_argument (parm
, arg
);
7876 if (arg
== any_targ_node
)
7879 if (TREE_CODE (arg
) == TREE_LIST
7880 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
7882 /* The template argument was the name of some
7883 member function. That's usually
7884 invalid, but static members are OK. In any
7885 case, grab the underlying fields/functions
7886 and issue an error later if required. */
7887 TREE_TYPE (arg
) = unknown_type_node
;
7892 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
7893 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
7894 || requires_tmpl_type
);
7896 /* When determining whether an argument pack expansion is a template,
7897 look at the pattern. */
7898 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
7899 arg
= PACK_EXPANSION_PATTERN (arg
);
7901 /* Deal with an injected-class-name used as a template template arg. */
7902 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
7904 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
7905 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7907 if (cxx_dialect
>= cxx11
)
7908 /* OK under DR 1004. */;
7909 else if (complain
& tf_warning_or_error
)
7910 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
7911 " used as template template argument", TYPE_NAME (arg
));
7912 else if (flag_pedantic_errors
)
7920 ((TREE_CODE (arg
) == TEMPLATE_DECL
7921 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
7922 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
7923 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7924 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
7927 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7928 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
7929 arg
= TYPE_STUB_DECL (arg
);
7931 is_type
= TYPE_P (arg
) || is_tmpl_type
;
7933 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
7934 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
7936 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
7938 if (complain
& tf_error
)
7939 error ("invalid use of destructor %qE as a type", orig_arg
);
7940 return error_mark_node
;
7943 permerror (input_location
,
7944 "to refer to a type member of a template parameter, "
7945 "use %<typename %E%>", orig_arg
);
7947 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
7948 TREE_OPERAND (arg
, 1),
7954 if (is_type
!= requires_type
)
7958 if (complain
& tf_error
)
7960 error ("type/value mismatch at argument %d in template "
7961 "parameter list for %qD",
7965 /* The template argument is a type, but we're expecting
7967 inform (input_location
,
7968 " expected a constant of type %qT, got %qT",
7970 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
7971 /* [temp.arg]/2: "In a template-argument, an ambiguity
7972 between a type-id and an expression is resolved to a
7973 type-id, regardless of the form of the corresponding
7974 template-parameter." So give the user a clue. */
7975 if (TREE_CODE (arg
) == FUNCTION_TYPE
)
7976 inform (input_location
, " ambiguous template argument "
7977 "for non-type template parameter is treated as "
7980 else if (requires_tmpl_type
)
7981 inform (input_location
,
7982 " expected a class template, got %qE", orig_arg
);
7984 inform (input_location
,
7985 " expected a type, got %qE", orig_arg
);
7988 return error_mark_node
;
7990 if (is_tmpl_type
^ requires_tmpl_type
)
7992 if (in_decl
&& (complain
& tf_error
))
7994 error ("type/value mismatch at argument %d in template "
7995 "parameter list for %qD",
7998 inform (input_location
,
7999 " expected a type, got %qT", DECL_NAME (arg
));
8001 inform (input_location
,
8002 " expected a class template, got %qT", orig_arg
);
8004 return error_mark_node
;
8007 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
8008 /* We already did the appropriate conversion when packing args. */
8012 if (requires_tmpl_type
)
8014 if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
8015 /* The number of argument required is not known yet.
8016 Just accept it for now. */
8020 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
8023 /* Strip alias templates that are equivalent to another
8025 arg
= get_underlying_template (arg
);
8026 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
8028 if (coerce_template_template_parms (parmparm
, argparm
,
8034 /* TEMPLATE_TEMPLATE_PARM node is preferred over
8036 if (val
!= error_mark_node
)
8038 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
8039 val
= TREE_TYPE (val
);
8040 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
8041 val
= make_pack_expansion (val
, complain
);
8046 if (in_decl
&& (complain
& tf_error
))
8048 error ("type/value mismatch at argument %d in "
8049 "template parameter list for %qD",
8051 inform (input_location
,
8052 " expected a template of type %qD, got %qT",
8056 val
= error_mark_node
;
8059 // Check that the constraints are compatible before allowing the
8061 if (val
!= error_mark_node
)
8062 if (!is_compatible_template_arg (parm
, arg
))
8064 if (in_decl
&& (complain
& tf_error
))
8066 error ("constraint mismatch at argument %d in "
8067 "template parameter list for %qD",
8069 inform (input_location
, " expected %qD but got %qD",
8072 val
= error_mark_node
;
8078 /* We only form one instance of each template specialization.
8079 Therefore, if we use a non-canonical variant (i.e., a
8080 typedef), any future messages referring to the type will use
8081 the typedef, which is confusing if those future uses do not
8082 themselves also use the typedef. */
8084 val
= canonicalize_type_argument (val
, complain
);
8088 tree t
= TREE_TYPE (parm
);
8090 if (TEMPLATE_PARM_LEVEL (get_template_parm_index (parm
))
8091 > TMPL_ARGS_DEPTH (args
))
8092 /* We don't have enough levels of args to do any substitution. This
8093 can happen in the context of -fnew-ttp-matching. */;
8094 else if (tree a
= type_uses_auto (t
))
8096 t
= do_auto_deduction (t
, arg
, a
, complain
, adc_unify
, args
);
8097 if (t
== error_mark_node
)
8098 return error_mark_node
;
8101 t
= tsubst (t
, args
, complain
, in_decl
);
8103 if (invalid_nontype_parm_type_p (t
, complain
))
8104 return error_mark_node
;
8106 if (t
!= TREE_TYPE (parm
))
8107 t
= canonicalize_type_argument (t
, complain
);
8109 if (!type_dependent_expression_p (orig_arg
)
8110 && !uses_template_parms (t
))
8111 /* We used to call digest_init here. However, digest_init
8112 will report errors, which we don't want when complain
8113 is zero. More importantly, digest_init will try too
8114 hard to convert things: for example, `0' should not be
8115 converted to pointer type at this point according to
8116 the standard. Accepting this is not merely an
8117 extension, since deciding whether or not these
8118 conversions can occur is part of determining which
8119 function template to call, or whether a given explicit
8120 argument specification is valid. */
8121 val
= convert_nontype_argument (t
, orig_arg
, complain
);
8124 val
= canonicalize_expr_argument (orig_arg
, complain
);
8125 val
= maybe_convert_nontype_argument (t
, val
);
8129 if (val
== NULL_TREE
)
8130 val
= error_mark_node
;
8131 else if (val
== error_mark_node
&& (complain
& tf_error
))
8132 error ("could not convert template argument %qE from %qT to %qT",
8133 orig_arg
, TREE_TYPE (orig_arg
), t
);
8135 if (INDIRECT_REF_P (val
))
8137 /* Reject template arguments that are references to built-in
8138 functions with no library fallbacks. */
8139 const_tree inner
= TREE_OPERAND (val
, 0);
8140 const_tree innertype
= TREE_TYPE (inner
);
8142 && TYPE_REF_P (innertype
)
8143 && TREE_CODE (TREE_TYPE (innertype
)) == FUNCTION_TYPE
8144 && TREE_OPERAND_LENGTH (inner
) > 0
8145 && reject_gcc_builtin (TREE_OPERAND (inner
, 0)))
8146 return error_mark_node
;
8149 if (TREE_CODE (val
) == SCOPE_REF
)
8151 /* Strip typedefs from the SCOPE_REF. */
8152 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
8153 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
8155 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
8156 QUALIFIED_NAME_IS_TEMPLATE (val
));
8163 /* Coerces the remaining template arguments in INNER_ARGS (from
8164 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
8165 Returns the coerced argument pack. PARM_IDX is the position of this
8166 parameter in the template parameter list. ARGS is the original
8167 template argument list. */
8169 coerce_template_parameter_pack (tree parms
,
8177 tsubst_flags_t complain
)
8179 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
8180 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
8183 tree packed_parms
= NULL_TREE
;
8185 if (arg_idx
> nargs
)
8188 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
8190 /* When the template parameter is a non-type template parameter pack
8191 or template template parameter pack whose type or template
8192 parameters use parameter packs, we know exactly how many arguments
8193 we are looking for. Build a vector of the instantiated decls for
8194 these template parameters in PACKED_PARMS. */
8195 /* We can't use make_pack_expansion here because it would interpret a
8196 _DECL as a use rather than a declaration. */
8197 tree decl
= TREE_VALUE (parm
);
8198 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
8199 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
8200 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
8201 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
8203 TREE_VEC_LENGTH (args
)--;
8204 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
8205 TREE_VEC_LENGTH (args
)++;
8207 if (packed_parms
== error_mark_node
)
8208 return error_mark_node
;
8210 /* If we're doing a partial instantiation of a member template,
8211 verify that all of the types used for the non-type
8212 template parameter pack are, in fact, valid for non-type
8213 template parameters. */
8215 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
8217 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
8218 for (j
= 0; j
< len
; ++j
)
8220 tree t
= TREE_VEC_ELT (packed_parms
, j
);
8221 if (TREE_CODE (t
) == PARM_DECL
8222 && invalid_nontype_parm_type_p (TREE_TYPE (t
), complain
))
8223 return error_mark_node
;
8225 /* We don't know how many args we have yet, just
8226 use the unconverted ones for now. */
8230 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
8232 /* Check if we have a placeholder pack, which indicates we're
8233 in the context of a introduction list. In that case we want
8234 to match this pack to the single placeholder. */
8235 else if (arg_idx
< nargs
8236 && TREE_CODE (TREE_VEC_ELT (inner_args
, arg_idx
)) == WILDCARD_DECL
8237 && WILDCARD_PACK_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
8239 nargs
= arg_idx
+ 1;
8240 packed_args
= make_tree_vec (1);
8243 packed_args
= make_tree_vec (nargs
- arg_idx
);
8245 /* Convert the remaining arguments, which will be a part of the
8246 parameter pack "parm". */
8247 int first_pack_arg
= arg_idx
;
8248 for (; arg_idx
< nargs
; ++arg_idx
)
8250 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
8251 tree actual_parm
= TREE_VALUE (parm
);
8252 int pack_idx
= arg_idx
- first_pack_arg
;
8256 /* Once we've packed as many args as we have types, stop. */
8257 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
8259 else if (PACK_EXPANSION_P (arg
))
8260 /* We don't know how many args we have yet, just
8261 use the unconverted ones for now. */
8264 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
8267 if (arg
== error_mark_node
)
8269 if (complain
& tf_error
)
8270 error ("template argument %d is invalid", arg_idx
+ 1);
8273 arg
= convert_template_argument (actual_parm
,
8274 arg
, new_args
, complain
, parm_idx
,
8276 if (arg
== error_mark_node
)
8278 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
8281 if (arg_idx
- first_pack_arg
< TREE_VEC_LENGTH (packed_args
)
8282 && TREE_VEC_LENGTH (packed_args
) > 0)
8284 if (complain
& tf_error
)
8285 error ("wrong number of template arguments (%d, should be %d)",
8286 arg_idx
- first_pack_arg
, TREE_VEC_LENGTH (packed_args
));
8287 return error_mark_node
;
8290 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
8291 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
8292 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
8295 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
8296 TREE_CONSTANT (argument_pack
) = 1;
8299 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
8301 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
8302 TREE_VEC_LENGTH (packed_args
));
8303 return argument_pack
;
8306 /* Returns the number of pack expansions in the template argument vector
8310 pack_expansion_args_count (tree args
)
8315 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
8317 tree elt
= TREE_VEC_ELT (args
, i
);
8318 if (elt
&& PACK_EXPANSION_P (elt
))
8324 /* Convert all template arguments to their appropriate types, and
8325 return a vector containing the innermost resulting template
8326 arguments. If any error occurs, return error_mark_node. Error and
8327 warning messages are issued under control of COMPLAIN.
8329 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
8330 for arguments not specified in ARGS. Otherwise, if
8331 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
8332 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
8333 USE_DEFAULT_ARGS is false, then all arguments must be specified in
8337 coerce_template_parms (tree parms
,
8340 tsubst_flags_t complain
,
8341 bool require_all_args
,
8342 bool use_default_args
)
8344 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
8345 tree orig_inner_args
;
8348 tree new_inner_args
;
8350 /* When used as a boolean value, indicates whether this is a
8351 variadic template parameter list. Since it's an int, we can also
8352 subtract it from nparms to get the number of non-variadic
8355 int variadic_args_p
= 0;
8356 int post_variadic_parms
= 0;
8358 /* Adjustment to nparms for fixed parameter packs. */
8359 int fixed_pack_adjust
= 0;
8360 int fixed_packs
= 0;
8363 /* Likewise for parameters with default arguments. */
8366 if (args
== error_mark_node
)
8367 return error_mark_node
;
8369 nparms
= TREE_VEC_LENGTH (parms
);
8371 /* Determine if there are any parameter packs or default arguments. */
8372 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
8374 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
8376 ++post_variadic_parms
;
8377 if (template_parameter_pack_p (TREE_VALUE (parm
)))
8379 if (TREE_PURPOSE (parm
))
8383 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
8384 /* If there are no parameters that follow a parameter pack, we need to
8385 expand any argument packs so that we can deduce a parameter pack from
8386 some non-packed args followed by an argument pack, as in variadic85.C.
8387 If there are such parameters, we need to leave argument packs intact
8388 so the arguments are assigned properly. This can happen when dealing
8389 with a nested class inside a partial specialization of a class
8390 template, as in variadic92.C, or when deducing a template parameter pack
8391 from a sub-declarator, as in variadic114.C. */
8392 if (!post_variadic_parms
)
8393 inner_args
= expand_template_argument_pack (inner_args
);
8395 /* Count any pack expansion args. */
8396 variadic_args_p
= pack_expansion_args_count (inner_args
);
8398 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
8399 if ((nargs
- variadic_args_p
> nparms
&& !variadic_p
)
8400 || (nargs
< nparms
- variadic_p
8403 && (!use_default_args
8404 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
8405 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
8408 if (complain
& tf_error
)
8410 if (variadic_p
|| default_p
)
8412 nparms
-= variadic_p
+ default_p
;
8413 error ("wrong number of template arguments "
8414 "(%d, should be at least %d)", nargs
, nparms
);
8417 error ("wrong number of template arguments "
8418 "(%d, should be %d)", nargs
, nparms
);
8421 inform (DECL_SOURCE_LOCATION (in_decl
),
8422 "provided for %qD", in_decl
);
8425 return error_mark_node
;
8427 /* We can't pass a pack expansion to a non-pack parameter of an alias
8428 template (DR 1430). */
8430 && (DECL_ALIAS_TEMPLATE_P (in_decl
)
8431 || concept_template_p (in_decl
))
8433 && nargs
- variadic_args_p
< nparms
- variadic_p
)
8435 if (complain
& tf_error
)
8437 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
8439 tree arg
= TREE_VEC_ELT (inner_args
, i
);
8440 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
8442 if (PACK_EXPANSION_P (arg
)
8443 && !template_parameter_pack_p (parm
))
8445 if (DECL_ALIAS_TEMPLATE_P (in_decl
))
8446 error_at (location_of (arg
),
8447 "pack expansion argument for non-pack parameter "
8448 "%qD of alias template %qD", parm
, in_decl
);
8450 error_at (location_of (arg
),
8451 "pack expansion argument for non-pack parameter "
8452 "%qD of concept %qD", parm
, in_decl
);
8453 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
8460 return error_mark_node
;
8463 /* We need to evaluate the template arguments, even though this
8464 template-id may be nested within a "sizeof". */
8467 new_inner_args
= make_tree_vec (nparms
);
8468 new_args
= add_outermost_template_args (args
, new_inner_args
);
8469 int pack_adjust
= 0;
8470 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
8475 /* Get the Ith template parameter. */
8476 parm
= TREE_VEC_ELT (parms
, parm_idx
);
8478 if (parm
== error_mark_node
)
8480 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
8484 /* Calculate the next argument. */
8485 if (arg_idx
< nargs
)
8486 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
8490 if (template_parameter_pack_p (TREE_VALUE (parm
))
8491 && (arg
|| require_all_args
|| !(complain
& tf_partial
))
8492 && !(arg
&& ARGUMENT_PACK_P (arg
)))
8494 /* Some arguments will be placed in the
8495 template parameter pack PARM. */
8496 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
8497 inner_args
, arg_idx
,
8501 if (arg
== NULL_TREE
)
8503 /* We don't know how many args we have yet, just use the
8504 unconverted (and still packed) ones for now. */
8505 new_inner_args
= orig_inner_args
;
8510 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
8512 /* Store this argument. */
8513 if (arg
== error_mark_node
)
8516 /* We are done with all of the arguments. */
8522 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
8523 arg_idx
+= pack_adjust
;
8524 if (fixed_parameter_pack_p (TREE_VALUE (parm
)))
8527 fixed_pack_adjust
+= pack_adjust
;
8535 if (PACK_EXPANSION_P (arg
))
8537 /* "If every valid specialization of a variadic template
8538 requires an empty template parameter pack, the template is
8539 ill-formed, no diagnostic required." So check that the
8540 pattern works with this parameter. */
8541 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
8542 tree conv
= convert_template_argument (TREE_VALUE (parm
),
8546 if (conv
== error_mark_node
)
8548 if (complain
& tf_error
)
8549 inform (input_location
, "so any instantiation with a "
8550 "non-empty parameter pack would be ill-formed");
8553 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
8554 /* Recover from missing typename. */
8555 TREE_VEC_ELT (inner_args
, arg_idx
)
8556 = make_pack_expansion (conv
, complain
);
8558 /* We don't know how many args we have yet, just
8559 use the unconverted ones for now. */
8560 new_inner_args
= inner_args
;
8565 else if (require_all_args
)
8567 /* There must be a default arg in this case. */
8568 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
8570 /* The position of the first default template argument,
8571 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
8573 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8574 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8575 arg_idx
- pack_adjust
);
8580 if (arg
== error_mark_node
)
8582 if (complain
& tf_error
)
8583 error ("template argument %d is invalid", arg_idx
+ 1);
8587 /* This can occur if there was an error in the template
8588 parameter list itself (which we would already have
8589 reported) that we are trying to recover from, e.g., a class
8590 template with a parameter list such as
8591 template<typename..., typename> (cpp0x/variadic150.C). */
8594 /* This can also happen with a fixed parameter pack (71834). */
8595 if (arg_idx
>= nargs
)
8599 arg
= convert_template_argument (TREE_VALUE (parm
),
8600 arg
, new_args
, complain
,
8603 if (arg
== error_mark_node
)
8605 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
8608 if (missing
|| arg_idx
< nargs
- variadic_args_p
)
8610 /* If we had fixed parameter packs, we didn't know how many arguments we
8611 actually needed earlier; now we do. */
8612 nparms
+= fixed_pack_adjust
;
8613 variadic_p
-= fixed_packs
;
8617 if (arg_idx
< nargs
)
8619 /* We had some pack expansion arguments that will only work if the packs
8620 are empty, but wait until instantiation time to complain.
8621 See variadic-ttp3.C. */
8622 int len
= nparms
+ (nargs
- arg_idx
);
8623 tree args
= make_tree_vec (len
);
8625 for (; i
< nparms
; ++i
)
8626 TREE_VEC_ELT (args
, i
) = TREE_VEC_ELT (new_inner_args
, i
);
8627 for (; i
< len
; ++i
, ++arg_idx
)
8628 TREE_VEC_ELT (args
, i
) = TREE_VEC_ELT (inner_args
,
8629 arg_idx
- pack_adjust
);
8630 new_inner_args
= args
;
8635 gcc_assert (!(complain
& tf_error
) || seen_error ());
8636 return error_mark_node
;
8639 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8640 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8641 TREE_VEC_LENGTH (new_inner_args
));
8643 return new_inner_args
;
8646 /* Convert all template arguments to their appropriate types, and
8647 return a vector containing the innermost resulting template
8648 arguments. If any error occurs, return error_mark_node. Error and
8649 warning messages are not issued.
8651 Note that no function argument deduction is performed, and default
8652 arguments are used to fill in unspecified arguments. */
8654 coerce_template_parms (tree parms
, tree args
, tree in_decl
)
8656 return coerce_template_parms (parms
, args
, in_decl
, tf_none
, true, true);
8659 /* Convert all template arguments to their appropriate type, and
8660 instantiate default arguments as needed. This returns a vector
8661 containing the innermost resulting template arguments, or
8662 error_mark_node if unsuccessful. */
8664 coerce_template_parms (tree parms
, tree args
, tree in_decl
,
8665 tsubst_flags_t complain
)
8667 return coerce_template_parms (parms
, args
, in_decl
, complain
, true, true);
8670 /* Like coerce_template_parms. If PARMS represents all template
8671 parameters levels, this function returns a vector of vectors
8672 representing all the resulting argument levels. Note that in this
8673 case, only the innermost arguments are coerced because the
8674 outermost ones are supposed to have been coerced already.
8676 Otherwise, if PARMS represents only (the innermost) vector of
8677 parameters, this function returns a vector containing just the
8678 innermost resulting arguments. */
8681 coerce_innermost_template_parms (tree parms
,
8684 tsubst_flags_t complain
,
8685 bool require_all_args
,
8686 bool use_default_args
)
8688 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
8689 int args_depth
= TMPL_ARGS_DEPTH (args
);
8692 if (parms_depth
> 1)
8694 coerced_args
= make_tree_vec (parms_depth
);
8698 for (level
= parms
, cur_depth
= parms_depth
;
8699 parms_depth
> 0 && level
!= NULL_TREE
;
8700 level
= TREE_CHAIN (level
), --cur_depth
)
8703 if (cur_depth
== args_depth
)
8704 l
= coerce_template_parms (TREE_VALUE (level
),
8705 args
, in_decl
, complain
,
8709 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
8711 if (l
== error_mark_node
)
8712 return error_mark_node
;
8714 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
8718 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
8719 args
, in_decl
, complain
,
8722 return coerced_args
;
8725 /* Returns 1 if template args OT and NT are equivalent. */
8728 template_args_equal (tree ot
, tree nt
, bool partial_order
/* = false */)
8732 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
8734 if (nt
== any_targ_node
|| ot
== any_targ_node
)
8737 if (TREE_CODE (nt
) == TREE_VEC
)
8738 /* For member templates */
8739 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
8740 else if (PACK_EXPANSION_P (ot
))
8741 return (PACK_EXPANSION_P (nt
)
8742 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
8743 PACK_EXPANSION_PATTERN (nt
))
8744 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
8745 PACK_EXPANSION_EXTRA_ARGS (nt
)));
8746 else if (ARGUMENT_PACK_P (ot
))
8751 if (!ARGUMENT_PACK_P (nt
))
8754 opack
= ARGUMENT_PACK_ARGS (ot
);
8755 npack
= ARGUMENT_PACK_ARGS (nt
);
8756 len
= TREE_VEC_LENGTH (opack
);
8757 if (TREE_VEC_LENGTH (npack
) != len
)
8759 for (i
= 0; i
< len
; ++i
)
8760 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
8761 TREE_VEC_ELT (npack
, i
)))
8765 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
8767 else if (TYPE_P (nt
))
8771 /* Don't treat an alias template specialization with dependent
8772 arguments as equivalent to its underlying type when used as a
8773 template argument; we need them to be distinct so that we
8774 substitute into the specialization arguments at instantiation
8775 time. And aliases can't be equivalent without being ==, so
8776 we don't need to look any deeper.
8778 During partial ordering, however, we need to treat them normally so
8779 that we can order uses of the same alias with different
8780 cv-qualification (79960). */
8782 && (TYPE_ALIAS_P (nt
) || TYPE_ALIAS_P (ot
)))
8785 return same_type_p (ot
, nt
);
8787 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
8791 /* Try to treat a template non-type argument that has been converted
8792 to the parameter type as equivalent to one that hasn't yet. */
8793 for (enum tree_code code1
= TREE_CODE (ot
);
8794 CONVERT_EXPR_CODE_P (code1
)
8795 || code1
== NON_LVALUE_EXPR
;
8796 code1
= TREE_CODE (ot
))
8797 ot
= TREE_OPERAND (ot
, 0);
8798 for (enum tree_code code2
= TREE_CODE (nt
);
8799 CONVERT_EXPR_CODE_P (code2
)
8800 || code2
== NON_LVALUE_EXPR
;
8801 code2
= TREE_CODE (nt
))
8802 nt
= TREE_OPERAND (nt
, 0);
8804 return cp_tree_equal (ot
, nt
);
8808 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
8809 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
8810 NEWARG_PTR with the offending arguments if they are non-NULL. */
8813 comp_template_args (tree oldargs
, tree newargs
,
8814 tree
*oldarg_ptr
, tree
*newarg_ptr
,
8819 if (oldargs
== newargs
)
8822 if (!oldargs
|| !newargs
)
8825 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
8828 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
8830 tree nt
= TREE_VEC_ELT (newargs
, i
);
8831 tree ot
= TREE_VEC_ELT (oldargs
, i
);
8833 if (! template_args_equal (ot
, nt
, partial_order
))
8835 if (oldarg_ptr
!= NULL
)
8837 if (newarg_ptr
!= NULL
)
8846 comp_template_args_porder (tree oargs
, tree nargs
)
8848 return comp_template_args (oargs
, nargs
, NULL
, NULL
, true);
8851 /* Implement a freelist interface for objects of type T.
8853 Head is a separate object, rather than a regular member, so that we
8854 can define it as a GTY deletable pointer, which is highly
8855 desirable. A data member could be declared that way, but then the
8856 containing object would implicitly get GTY((user)), which would
8857 prevent us from instantiating freelists as global objects.
8858 Although this way we can create freelist global objects, they're
8859 such thin wrappers that instantiating temporaries at every use
8860 loses nothing and saves permanent storage for the freelist object.
8862 Member functions next, anew, poison and reinit have default
8863 implementations that work for most of the types we're interested
8864 in, but if they don't work for some type, they should be explicitly
8865 specialized. See the comments before them for requirements, and
8866 the example specializations for the tree_list_freelist. */
8867 template <typename T
>
8870 /* Return the next object in a chain. We could just do type
8871 punning, but if we access the object with its underlying type, we
8872 avoid strict-aliasing trouble. This needs only work between
8873 poison and reinit. */
8874 static T
*&next (T
*obj
) { return obj
->next
; }
8876 /* Return a newly allocated, uninitialized or minimally-initialized
8877 object of type T. Any initialization performed by anew should
8878 either remain across the life of the object and the execution of
8879 poison, or be redone by reinit. */
8880 static T
*anew () { return ggc_alloc
<T
> (); }
8882 /* Optionally scribble all over the bits holding the object, so that
8883 they become (mostly?) uninitialized memory. This is called while
8884 preparing to make the object part of the free list. */
8885 static void poison (T
*obj
) {
8886 T
*p ATTRIBUTE_UNUSED
= obj
;
8887 T
**q ATTRIBUTE_UNUSED
= &next (obj
);
8889 #ifdef ENABLE_GC_CHECKING
8890 /* Poison the data, to indicate the data is garbage. */
8891 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (p
, sizeof (*p
)));
8892 memset (p
, 0xa5, sizeof (*p
));
8894 /* Let valgrind know the object is free. */
8895 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (p
, sizeof (*p
)));
8897 /* Let valgrind know the next portion of the object is available,
8898 but uninitialized. */
8899 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (q
, sizeof (*q
)));
8902 /* Bring an object that underwent at least one lifecycle after anew
8903 and before the most recent free and poison, back to a usable
8904 state, reinitializing whatever is needed for it to be
8905 functionally equivalent to an object just allocated and returned
8906 by anew. This may poison or clear the next field, used by
8907 freelist housekeeping after poison was called. */
8908 static void reinit (T
*obj
) {
8909 T
**q ATTRIBUTE_UNUSED
= &next (obj
);
8911 #ifdef ENABLE_GC_CHECKING
8912 memset (q
, 0xa5, sizeof (*q
));
8914 /* Let valgrind know the entire object is available, but
8916 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (*obj
)));
8919 /* Reference a GTY-deletable pointer that points to the first object
8920 in the free list proper. */
8923 /* Construct a freelist object chaining objects off of HEAD. */
8924 freelist (T
*&head
) : head(head
) {}
8926 /* Add OBJ to the free object list. The former head becomes OBJ's
8935 /* Take an object from the free list, if one is available, or
8936 allocate a new one. Objects taken from the free list should be
8937 regarded as filled with garbage, except for bits that are
8938 configured to be preserved across free and alloc. */
8953 /* Explicitly specialize the interfaces for freelist<tree_node>: we
8954 want to allocate a TREE_LIST using the usual interface, and ensure
8955 TREE_CHAIN remains functional. Alas, we have to duplicate a bit of
8956 build_tree_list logic in reinit, so this could go out of sync. */
8959 freelist
<tree_node
>::next (tree obj
)
8961 return TREE_CHAIN (obj
);
8965 freelist
<tree_node
>::anew ()
8967 return build_tree_list (NULL
, NULL
);
8971 freelist
<tree_node
>::poison (tree obj ATTRIBUTE_UNUSED
)
8973 int size ATTRIBUTE_UNUSED
= sizeof (tree_list
);
8974 tree p ATTRIBUTE_UNUSED
= obj
;
8975 tree_base
*b ATTRIBUTE_UNUSED
= &obj
->base
;
8976 tree
*q ATTRIBUTE_UNUSED
= &next (obj
);
8978 #ifdef ENABLE_GC_CHECKING
8979 gcc_checking_assert (TREE_CODE (obj
) == TREE_LIST
);
8981 /* Poison the data, to indicate the data is garbage. */
8982 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (p
, size
));
8983 memset (p
, 0xa5, size
);
8985 /* Let valgrind know the object is free. */
8986 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (p
, size
));
8987 /* But we still want to use the TREE_CODE and TREE_CHAIN parts. */
8988 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
8989 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (q
, sizeof (*q
)));
8991 #ifdef ENABLE_GC_CHECKING
8992 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (b
, sizeof (*b
)));
8993 /* Keep TREE_CHAIN functional. */
8994 TREE_SET_CODE (obj
, TREE_LIST
);
8996 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
9001 freelist
<tree_node
>::reinit (tree obj ATTRIBUTE_UNUSED
)
9003 tree_base
*b ATTRIBUTE_UNUSED
= &obj
->base
;
9005 #ifdef ENABLE_GC_CHECKING
9006 gcc_checking_assert (TREE_CODE (obj
) == TREE_LIST
);
9007 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (tree_list
)));
9008 memset (obj
, 0, sizeof (tree_list
));
9011 /* Let valgrind know the entire object is available, but
9013 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (tree_list
)));
9015 #ifdef ENABLE_GC_CHECKING
9016 TREE_SET_CODE (obj
, TREE_LIST
);
9018 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
9022 /* Point to the first object in the TREE_LIST freelist. */
9023 static GTY((deletable
)) tree tree_list_freelist_head
;
9024 /* Return the/an actual TREE_LIST freelist. */
9025 static inline freelist
<tree_node
>
9026 tree_list_freelist ()
9028 return tree_list_freelist_head
;
9031 /* Point to the first object in the tinst_level freelist. */
9032 static GTY((deletable
)) tinst_level
*tinst_level_freelist_head
;
9033 /* Return the/an actual tinst_level freelist. */
9034 static inline freelist
<tinst_level
>
9035 tinst_level_freelist ()
9037 return tinst_level_freelist_head
;
9040 /* Point to the first object in the pending_template freelist. */
9041 static GTY((deletable
)) pending_template
*pending_template_freelist_head
;
9042 /* Return the/an actual pending_template freelist. */
9043 static inline freelist
<pending_template
>
9044 pending_template_freelist ()
9046 return pending_template_freelist_head
;
9049 /* Build the TREE_LIST object out of a split list, store it
9050 permanently, and return it. */
9052 tinst_level::to_list ()
9054 gcc_assert (split_list_p ());
9055 tree ret
= tree_list_freelist ().alloc ();
9056 TREE_PURPOSE (ret
) = tldcl
;
9057 TREE_VALUE (ret
) = targs
;
9060 gcc_assert (tree_list_p ());
9064 const unsigned short tinst_level::refcount_infinity
;
9066 /* Increment OBJ's refcount unless it is already infinite. */
9067 static tinst_level
*
9068 inc_refcount_use (tinst_level
*obj
)
9070 if (obj
&& obj
->refcount
!= tinst_level::refcount_infinity
)
9075 /* Release storage for OBJ and node, if it's a TREE_LIST. */
9077 tinst_level::free (tinst_level
*obj
)
9079 if (obj
->tree_list_p ())
9080 tree_list_freelist ().free (obj
->get_node ());
9081 tinst_level_freelist ().free (obj
);
9084 /* Decrement OBJ's refcount if not infinite. If it reaches zero, release
9085 OBJ's DECL and OBJ, and start over with the tinst_level object that
9086 used to be referenced by OBJ's NEXT. */
9088 dec_refcount_use (tinst_level
*obj
)
9091 && obj
->refcount
!= tinst_level::refcount_infinity
9092 && !--obj
->refcount
)
9094 tinst_level
*next
= obj
->next
;
9095 tinst_level::free (obj
);
9100 /* Modify PTR so that it points to OBJ, adjusting the refcounts of OBJ
9101 and of the former PTR. Omitting the second argument is equivalent
9102 to passing (T*)NULL; this is allowed because passing the
9103 zero-valued integral constant NULL confuses type deduction and/or
9104 overload resolution. */
9105 template <typename T
>
9107 set_refcount_ptr (T
*& ptr
, T
*obj
= NULL
)
9110 ptr
= inc_refcount_use (obj
);
9111 dec_refcount_use (save
);
9115 add_pending_template (tree d
)
9117 tree ti
= (TYPE_P (d
)
9118 ? CLASSTYPE_TEMPLATE_INFO (d
)
9119 : DECL_TEMPLATE_INFO (d
));
9120 struct pending_template
*pt
;
9123 if (TI_PENDING_TEMPLATE_FLAG (ti
))
9126 /* We are called both from instantiate_decl, where we've already had a
9127 tinst_level pushed, and instantiate_template, where we haven't.
9129 gcc_assert (TREE_CODE (d
) != TREE_LIST
);
9130 level
= !current_tinst_level
9131 || current_tinst_level
->maybe_get_node () != d
;
9134 push_tinst_level (d
);
9136 pt
= pending_template_freelist ().alloc ();
9139 set_refcount_ptr (pt
->tinst
, current_tinst_level
);
9140 if (last_pending_template
)
9141 last_pending_template
->next
= pt
;
9143 pending_templates
= pt
;
9145 last_pending_template
= pt
;
9147 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
9154 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
9155 ARGLIST. Valid choices for FNS are given in the cp-tree.def
9156 documentation for TEMPLATE_ID_EXPR. */
9159 lookup_template_function (tree fns
, tree arglist
)
9161 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
9162 return error_mark_node
;
9164 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
9166 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
9168 error ("%q#D is not a function template", fns
);
9169 return error_mark_node
;
9172 if (BASELINK_P (fns
))
9174 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
9176 BASELINK_FUNCTIONS (fns
),
9181 return build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fns
, arglist
);
9184 /* Within the scope of a template class S<T>, the name S gets bound
9185 (in build_self_reference) to a TYPE_DECL for the class, not a
9186 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
9187 or one of its enclosing classes, and that type is a template,
9188 return the associated TEMPLATE_DECL. Otherwise, the original
9191 Also handle the case when DECL is a TREE_LIST of ambiguous
9192 injected-class-names from different bases. */
9195 maybe_get_template_decl_from_type_decl (tree decl
)
9197 if (decl
== NULL_TREE
)
9200 /* DR 176: A lookup that finds an injected-class-name (10.2
9201 [class.member.lookup]) can result in an ambiguity in certain cases
9202 (for example, if it is found in more than one base class). If all of
9203 the injected-class-names that are found refer to specializations of
9204 the same class template, and if the name is followed by a
9205 template-argument-list, the reference refers to the class template
9206 itself and not a specialization thereof, and is not ambiguous. */
9207 if (TREE_CODE (decl
) == TREE_LIST
)
9209 tree t
, tmpl
= NULL_TREE
;
9210 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
9212 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
9215 else if (tmpl
!= elt
)
9218 if (tmpl
&& t
== NULL_TREE
)
9224 return (decl
!= NULL_TREE
9225 && DECL_SELF_REFERENCE_P (decl
)
9226 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
9227 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
9230 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
9231 parameters, find the desired type.
9233 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
9235 IN_DECL, if non-NULL, is the template declaration we are trying to
9238 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
9239 the class we are looking up.
9241 Issue error and warning messages under control of COMPLAIN.
9243 If the template class is really a local class in a template
9244 function, then the FUNCTION_CONTEXT is the function in which it is
9247 ??? Note that this function is currently called *twice* for each
9248 template-id: the first time from the parser, while creating the
9249 incomplete type (finish_template_type), and the second type during the
9250 real instantiation (instantiate_template_class). This is surely something
9251 that we want to avoid. It also causes some problems with argument
9252 coercion (see convert_nontype_argument for more information on this). */
9255 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
9256 int entering_scope
, tsubst_flags_t complain
)
9258 tree templ
= NULL_TREE
, parmlist
;
9265 if (identifier_p (d1
))
9267 tree value
= innermost_non_namespace_value (d1
);
9268 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
9273 push_decl_namespace (context
);
9274 templ
= lookup_name (d1
);
9275 templ
= maybe_get_template_decl_from_type_decl (templ
);
9277 pop_decl_namespace ();
9280 context
= DECL_CONTEXT (templ
);
9282 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
9284 tree type
= TREE_TYPE (d1
);
9286 /* If we are declaring a constructor, say A<T>::A<T>, we will get
9287 an implicit typename for the second A. Deal with it. */
9288 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
9289 type
= TREE_TYPE (type
);
9291 if (CLASSTYPE_TEMPLATE_INFO (type
))
9293 templ
= CLASSTYPE_TI_TEMPLATE (type
);
9294 d1
= DECL_NAME (templ
);
9297 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
9298 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
9300 templ
= TYPE_TI_TEMPLATE (d1
);
9301 d1
= DECL_NAME (templ
);
9303 else if (DECL_TYPE_TEMPLATE_P (d1
))
9306 d1
= DECL_NAME (templ
);
9307 context
= DECL_CONTEXT (templ
);
9309 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
9312 d1
= DECL_NAME (templ
);
9315 /* Issue an error message if we didn't find a template. */
9318 if (complain
& tf_error
)
9319 error ("%qT is not a template", d1
);
9320 return error_mark_node
;
9323 if (TREE_CODE (templ
) != TEMPLATE_DECL
9324 /* Make sure it's a user visible template, if it was named by
9326 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
9327 && !PRIMARY_TEMPLATE_P (templ
)))
9329 if (complain
& tf_error
)
9331 error ("non-template type %qT used as a template", d1
);
9333 error ("for template declaration %q+D", in_decl
);
9335 return error_mark_node
;
9338 complain
&= ~tf_user
;
9340 /* An alias that just changes the name of a template is equivalent to the
9341 other template, so if any of the arguments are pack expansions, strip
9342 the alias to avoid problems with a pack expansion passed to a non-pack
9343 alias template parameter (DR 1430). */
9344 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
9345 templ
= get_underlying_template (templ
);
9347 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
9350 tree arglist2
= coerce_template_args_for_ttp (templ
, arglist
, complain
);
9351 if (arglist2
== error_mark_node
9352 || (!uses_template_parms (arglist2
)
9353 && check_instantiated_args (templ
, arglist2
, complain
)))
9354 return error_mark_node
;
9356 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
9361 tree template_type
= TREE_TYPE (templ
);
9364 tree found
= NULL_TREE
;
9367 int is_dependent_type
;
9368 int use_partial_inst_tmpl
= false;
9370 if (template_type
== error_mark_node
)
9371 /* An error occurred while building the template TEMPL, and a
9372 diagnostic has most certainly been emitted for that
9373 already. Let's propagate that error. */
9374 return error_mark_node
;
9376 gen_tmpl
= most_general_template (templ
);
9377 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
9378 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
9379 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
9381 if (arg_depth
== 1 && parm_depth
> 1)
9383 /* We've been given an incomplete set of template arguments.
9386 template <class T> struct S1 {
9387 template <class U> struct S2 {};
9388 template <class U> struct S2<U*> {};
9391 we will be called with an ARGLIST of `U*', but the
9392 TEMPLATE will be `template <class T> template
9393 <class U> struct S1<T>::S2'. We must fill in the missing
9395 tree ti
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (templ
));
9396 arglist
= add_outermost_template_args (TI_ARGS (ti
), arglist
);
9397 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
9400 /* Now we should have enough arguments. */
9401 gcc_assert (parm_depth
== arg_depth
);
9403 /* From here on, we're only interested in the most general
9406 /* Calculate the BOUND_ARGS. These will be the args that are
9407 actually tsubst'd into the definition to create the
9409 arglist
= coerce_innermost_template_parms (parmlist
, arglist
, gen_tmpl
,
9411 /*require_all_args=*/true,
9412 /*use_default_args=*/true);
9414 if (arglist
== error_mark_node
)
9415 /* We were unable to bind the arguments. */
9416 return error_mark_node
;
9418 /* In the scope of a template class, explicit references to the
9419 template class refer to the type of the template, not any
9420 instantiation of it. For example, in:
9422 template <class T> class C { void f(C<T>); }
9424 the `C<T>' is just the same as `C'. Outside of the
9425 class, however, such a reference is an instantiation. */
9427 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
9428 || currently_open_class (template_type
))
9430 tree tinfo
= TYPE_TEMPLATE_INFO (template_type
);
9432 if (tinfo
&& comp_template_args (TI_ARGS (tinfo
), arglist
))
9433 return template_type
;
9436 /* If we already have this specialization, return it. */
9437 elt
.tmpl
= gen_tmpl
;
9439 elt
.spec
= NULL_TREE
;
9440 hash
= spec_hasher::hash (&elt
);
9441 entry
= type_specializations
->find_with_hash (&elt
, hash
);
9446 /* If the the template's constraints are not satisfied,
9447 then we cannot form a valid type.
9449 Note that the check is deferred until after the hash
9450 lookup. This prevents redundant checks on previously
9451 instantiated specializations. */
9452 if (flag_concepts
&& !constraints_satisfied_p (gen_tmpl
, arglist
))
9454 if (complain
& tf_error
)
9456 auto_diagnostic_group d
;
9457 error ("template constraint failure");
9458 diagnose_constraints (input_location
, gen_tmpl
, arglist
);
9460 return error_mark_node
;
9463 is_dependent_type
= uses_template_parms (arglist
);
9465 /* If the deduced arguments are invalid, then the binding
9467 if (!is_dependent_type
9468 && check_instantiated_args (gen_tmpl
,
9469 INNERMOST_TEMPLATE_ARGS (arglist
),
9471 return error_mark_node
;
9473 if (!is_dependent_type
9474 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
9475 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
9476 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
9478 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
9479 DECL_NAME (gen_tmpl
),
9480 /*tag_scope=*/ts_global
);
9484 context
= DECL_CONTEXT (gen_tmpl
);
9485 if (context
&& TYPE_P (context
))
9487 context
= tsubst_aggr_type (context
, arglist
, complain
, in_decl
, true);
9488 context
= complete_type (context
);
9491 context
= tsubst (context
, arglist
, complain
, in_decl
);
9493 if (context
== error_mark_node
)
9494 return error_mark_node
;
9497 context
= global_namespace
;
9499 /* Create the type. */
9500 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9502 /* The user referred to a specialization of an alias
9503 template represented by GEN_TMPL.
9505 [temp.alias]/2 says:
9507 When a template-id refers to the specialization of an
9508 alias template, it is equivalent to the associated
9509 type obtained by substitution of its
9510 template-arguments for the template-parameters in the
9511 type-id of the alias template. */
9513 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
9514 /* Note that the call above (by indirectly calling
9515 register_specialization in tsubst_decl) registers the
9516 TYPE_DECL representing the specialization of the alias
9517 template. So next time someone substitutes ARGLIST for
9518 the template parms into the alias template (GEN_TMPL),
9519 she'll get that TYPE_DECL back. */
9521 if (t
== error_mark_node
)
9524 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
9526 if (!is_dependent_type
)
9528 set_current_access_from_decl (TYPE_NAME (template_type
));
9529 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
9530 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
9531 arglist
, complain
, in_decl
),
9532 tsubst_attributes (TYPE_ATTRIBUTES (template_type
),
9533 arglist
, complain
, in_decl
),
9534 SCOPED_ENUM_P (template_type
), NULL
);
9536 if (t
== error_mark_node
)
9541 /* We don't want to call start_enum for this type, since
9542 the values for the enumeration constants may involve
9543 template parameters. And, no one should be interested
9544 in the enumeration constants for such a type. */
9545 t
= cxx_make_type (ENUMERAL_TYPE
);
9546 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
9548 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
9549 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
9550 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
9552 else if (CLASS_TYPE_P (template_type
))
9554 /* Lambda closures are regenerated in tsubst_lambda_expr, not
9555 instantiated here. */
9556 gcc_assert (!LAMBDA_TYPE_P (template_type
));
9558 t
= make_class_type (TREE_CODE (template_type
));
9559 CLASSTYPE_DECLARED_CLASS (t
)
9560 = CLASSTYPE_DECLARED_CLASS (template_type
);
9561 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
9563 /* A local class. Make sure the decl gets registered properly. */
9564 if (context
== current_function_decl
)
9565 if (pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
)
9567 return error_mark_node
;
9569 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
9570 /* This instantiation is another name for the primary
9571 template type. Set the TYPE_CANONICAL field
9573 TYPE_CANONICAL (t
) = template_type
;
9574 else if (any_template_arguments_need_structural_equality_p (arglist
))
9575 /* Some of the template arguments require structural
9576 equality testing, so this template class requires
9577 structural equality testing. */
9578 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9583 /* If we called start_enum or pushtag above, this information
9584 will already be set up. */
9587 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
9589 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
9590 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
9591 DECL_SOURCE_LOCATION (type_decl
)
9592 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
9595 type_decl
= TYPE_NAME (t
);
9597 if (CLASS_TYPE_P (template_type
))
9599 TREE_PRIVATE (type_decl
)
9600 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
9601 TREE_PROTECTED (type_decl
)
9602 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
9603 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
9605 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
9606 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
9610 if (OVERLOAD_TYPE_P (t
)
9611 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9613 static const char *tags
[] = {"abi_tag", "may_alias"};
9615 for (unsigned ix
= 0; ix
!= 2; ix
++)
9618 = lookup_attribute (tags
[ix
], TYPE_ATTRIBUTES (template_type
));
9622 = tree_cons (TREE_PURPOSE (attributes
),
9623 TREE_VALUE (attributes
),
9624 TYPE_ATTRIBUTES (t
));
9628 /* Let's consider the explicit specialization of a member
9629 of a class template specialization that is implicitly instantiated,
9634 template<class U> struct M {}; //#0
9639 struct S<int>::M<char> //#1
9643 [temp.expl.spec]/4 says this is valid.
9645 In this case, when we write:
9648 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
9651 When we encounter #1, we want to store the partial instantiation
9652 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
9654 For all cases other than this "explicit specialization of member of a
9655 class template", we just want to store the most general template into
9656 the CLASSTYPE_TI_TEMPLATE of M.
9658 This case of "explicit specialization of member of a class template"
9660 1/ the enclosing class is an instantiation of, and therefore not
9661 the same as, the context of the most general template, and
9662 2/ we aren't looking at the partial instantiation itself, i.e.
9663 the innermost arguments are not the same as the innermost parms of
9664 the most general template.
9666 So it's only when 1/ and 2/ happens that we want to use the partial
9667 instantiation of the member template in lieu of its most general
9670 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
9671 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
9672 /* the enclosing class must be an instantiation... */
9673 && CLASS_TYPE_P (context
)
9674 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
9676 TREE_VEC_LENGTH (arglist
)--;
9677 ++processing_template_decl
;
9678 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (gen_tmpl
));
9679 tree partial_inst_args
=
9680 tsubst (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
)),
9681 arglist
, complain
, NULL_TREE
);
9682 --processing_template_decl
;
9683 TREE_VEC_LENGTH (arglist
)++;
9684 if (partial_inst_args
== error_mark_node
)
9685 return error_mark_node
;
9686 use_partial_inst_tmpl
=
9687 /*...and we must not be looking at the partial instantiation
9689 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
9693 if (!use_partial_inst_tmpl
)
9694 /* This case is easy; there are no member templates involved. */
9698 /* This is a full instantiation of a member template. Find
9699 the partial instantiation of which this is an instance. */
9701 /* Temporarily reduce by one the number of levels in the ARGLIST
9702 so as to avoid comparing the last set of arguments. */
9703 TREE_VEC_LENGTH (arglist
)--;
9704 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
9705 TREE_VEC_LENGTH (arglist
)++;
9706 /* FOUND is either a proper class type, or an alias
9707 template specialization. In the later case, it's a
9708 TYPE_DECL, resulting from the substituting of arguments
9709 for parameters in the TYPE_DECL of the alias template
9710 done earlier. So be careful while getting the template
9712 found
= (TREE_CODE (found
) == TEMPLATE_DECL
9714 : (TREE_CODE (found
) == TYPE_DECL
9715 ? DECL_TI_TEMPLATE (found
)
9716 : CLASSTYPE_TI_TEMPLATE (found
)));
9718 if (DECL_CLASS_TEMPLATE_P (found
)
9719 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (found
)))
9721 /* If this partial instantiation is specialized, we want to
9722 use it for hash table lookup. */
9724 elt
.args
= arglist
= INNERMOST_TEMPLATE_ARGS (arglist
);
9725 hash
= spec_hasher::hash (&elt
);
9729 // Build template info for the new specialization.
9730 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
9733 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
9734 gcc_checking_assert (*slot
== NULL
);
9735 entry
= ggc_alloc
<spec_entry
> ();
9739 /* Note this use of the partial instantiation so we can check it
9740 later in maybe_process_partial_specialization. */
9741 DECL_TEMPLATE_INSTANTIATIONS (found
)
9742 = tree_cons (arglist
, t
,
9743 DECL_TEMPLATE_INSTANTIATIONS (found
));
9745 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
9746 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9747 /* Now that the type has been registered on the instantiations
9748 list, we set up the enumerators. Because the enumeration
9749 constants may involve the enumeration type itself, we make
9750 sure to register the type first, and then create the
9751 constants. That way, doing tsubst_expr for the enumeration
9752 constants won't result in recursive calls here; we'll find
9753 the instantiation and exit above. */
9754 tsubst_enum (template_type
, t
, arglist
);
9756 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
9757 /* If the type makes use of template parameters, the
9758 code that generates debugging information will crash. */
9759 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
9761 /* Possibly limit visibility based on template args. */
9762 TREE_PUBLIC (type_decl
) = 1;
9763 determine_visibility (type_decl
);
9765 inherit_targ_abi_tags (t
);
9771 /* Wrapper for lookup_template_class_1. */
9774 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
9775 int entering_scope
, tsubst_flags_t complain
)
9778 timevar_push (TV_TEMPLATE_INST
);
9779 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
9780 entering_scope
, complain
);
9781 timevar_pop (TV_TEMPLATE_INST
);
9785 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
9788 lookup_template_variable (tree templ
, tree arglist
)
9790 /* The type of the expression is NULL_TREE since the template-id could refer
9791 to an explicit or partial specialization. */
9792 tree type
= NULL_TREE
;
9793 if (flag_concepts
&& variable_concept_p (templ
))
9794 /* Except that concepts are always bool. */
9795 type
= boolean_type_node
;
9796 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
9799 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
9802 finish_template_variable (tree var
, tsubst_flags_t complain
)
9804 tree templ
= TREE_OPERAND (var
, 0);
9805 tree arglist
= TREE_OPERAND (var
, 1);
9807 /* We never want to return a VAR_DECL for a variable concept, since they
9808 aren't instantiated. In a template, leave the TEMPLATE_ID_EXPR alone. */
9809 bool concept_p
= flag_concepts
&& variable_concept_p (templ
);
9810 if (concept_p
&& processing_template_decl
)
9813 tree tmpl_args
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ
));
9814 arglist
= add_outermost_template_args (tmpl_args
, arglist
);
9816 templ
= most_general_template (templ
);
9817 tree parms
= DECL_TEMPLATE_PARMS (templ
);
9818 arglist
= coerce_innermost_template_parms (parms
, arglist
, templ
, complain
,
9820 /*use_default*/true);
9822 if (flag_concepts
&& !constraints_satisfied_p (templ
, arglist
))
9824 if (complain
& tf_error
)
9826 auto_diagnostic_group d
;
9827 error ("use of invalid variable template %qE", var
);
9828 diagnose_constraints (location_of (var
), templ
, arglist
);
9830 return error_mark_node
;
9833 /* If a template-id refers to a specialization of a variable
9834 concept, then the expression is true if and only if the
9835 concept's constraints are satisfied by the given template
9838 NOTE: This is an extension of Concepts Lite TS that
9839 allows constraints to be used in expressions. */
9842 tree decl
= DECL_TEMPLATE_RESULT (templ
);
9843 return evaluate_variable_concept (decl
, arglist
);
9846 return instantiate_template (templ
, arglist
, complain
);
9849 /* Construct a TEMPLATE_ID_EXPR for the given variable template TEMPL having
9850 TARGS template args, and instantiate it if it's not dependent. */
9853 lookup_and_finish_template_variable (tree templ
, tree targs
,
9854 tsubst_flags_t complain
)
9856 templ
= lookup_template_variable (templ
, targs
);
9857 if (!any_dependent_template_arguments_p (targs
))
9859 templ
= finish_template_variable (templ
, complain
);
9863 return convert_from_reference (templ
);
9872 /* True when we should also visit template parameters that occur in
9873 non-deduced contexts. */
9874 bool include_nondeduced_p
;
9875 hash_set
<tree
> *visited
;
9878 /* Called from for_each_template_parm via walk_tree. */
9881 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
9884 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
9885 tree_fn_t fn
= pfd
->fn
;
9886 void *data
= pfd
->data
;
9887 tree result
= NULL_TREE
;
9889 #define WALK_SUBTREE(NODE) \
9892 result = for_each_template_parm (NODE, fn, data, pfd->visited, \
9893 pfd->include_nondeduced_p, \
9895 if (result) goto out; \
9899 if (pfd
->any_fn
&& (*pfd
->any_fn
)(t
, data
))
9903 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
))
9904 WALK_SUBTREE (TYPE_CONTEXT (t
));
9906 switch (TREE_CODE (t
))
9909 if (TYPE_PTRMEMFUNC_P (t
))
9915 if (!TYPE_TEMPLATE_INFO (t
))
9918 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9922 WALK_SUBTREE (TYPE_MIN_VALUE (t
));
9923 WALK_SUBTREE (TYPE_MAX_VALUE (t
));
9927 /* Since we're not going to walk subtrees, we have to do this
9929 WALK_SUBTREE (TYPE_METHOD_BASETYPE (t
));
9933 /* Check the return type. */
9934 WALK_SUBTREE (TREE_TYPE (t
));
9936 /* Check the parameter types. Since default arguments are not
9937 instantiated until they are needed, the TYPE_ARG_TYPES may
9938 contain expressions that involve template parameters. But,
9939 no-one should be looking at them yet. And, once they're
9940 instantiated, they don't contain template parameters, so
9941 there's no point in looking at them then, either. */
9945 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
9946 WALK_SUBTREE (TREE_VALUE (parm
));
9948 /* Since we've already handled the TYPE_ARG_TYPES, we don't
9949 want walk_tree walking into them itself. */
9953 if (flag_noexcept_type
)
9955 tree spec
= TYPE_RAISES_EXCEPTIONS (t
);
9957 WALK_SUBTREE (TREE_PURPOSE (spec
));
9963 case UNDERLYING_TYPE
:
9964 if (pfd
->include_nondeduced_p
9965 && for_each_template_parm (TYPE_VALUES_RAW (t
), fn
, data
,
9967 pfd
->include_nondeduced_p
,
9969 return error_mark_node
;
9970 *walk_subtrees
= false;
9975 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
9976 WALK_SUBTREE (DECL_TI_ARGS (t
));
9981 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
))
9982 WALK_SUBTREE (DECL_INITIAL (t
));
9983 if (DECL_CONTEXT (t
)
9984 && pfd
->include_nondeduced_p
)
9985 WALK_SUBTREE (DECL_CONTEXT (t
));
9988 case BOUND_TEMPLATE_TEMPLATE_PARM
:
9989 /* Record template parameters such as `T' inside `TT<T>'. */
9990 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9993 case TEMPLATE_TEMPLATE_PARM
:
9994 case TEMPLATE_TYPE_PARM
:
9995 case TEMPLATE_PARM_INDEX
:
9996 if (fn
&& (*fn
)(t
, data
))
10002 case TEMPLATE_DECL
:
10003 /* A template template parameter is encountered. */
10004 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10005 WALK_SUBTREE (TREE_TYPE (t
));
10007 /* Already substituted template template parameter */
10008 *walk_subtrees
= 0;
10011 case TYPENAME_TYPE
:
10012 /* A template-id in a TYPENAME_TYPE might be a deduced context after
10013 partial instantiation. */
10014 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t
));
10018 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
10019 && pfd
->include_nondeduced_p
)
10020 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
10024 case COMPONENT_REF
:
10025 /* If there's no type, then this thing must be some expression
10026 involving template parameters. */
10027 if (!fn
&& !TREE_TYPE (t
))
10028 return error_mark_node
;
10033 case IMPLICIT_CONV_EXPR
:
10034 case REINTERPRET_CAST_EXPR
:
10035 case CONST_CAST_EXPR
:
10036 case STATIC_CAST_EXPR
:
10037 case DYNAMIC_CAST_EXPR
:
10041 case PSEUDO_DTOR_EXPR
:
10043 return error_mark_node
;
10050 #undef WALK_SUBTREE
10052 /* We didn't find any template parameters we liked. */
10057 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
10058 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
10059 call FN with the parameter and the DATA.
10060 If FN returns nonzero, the iteration is terminated, and
10061 for_each_template_parm returns 1. Otherwise, the iteration
10062 continues. If FN never returns a nonzero value, the value
10063 returned by for_each_template_parm is 0. If FN is NULL, it is
10064 considered to be the function which always returns 1.
10066 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
10067 parameters that occur in non-deduced contexts. When false, only
10068 visits those template parameters that can be deduced. */
10071 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
10072 hash_set
<tree
> *visited
,
10073 bool include_nondeduced_p
,
10076 struct pair_fn_data pfd
;
10081 pfd
.any_fn
= any_fn
;
10083 pfd
.include_nondeduced_p
= include_nondeduced_p
;
10085 /* Walk the tree. (Conceptually, we would like to walk without
10086 duplicates, but for_each_template_parm_r recursively calls
10087 for_each_template_parm, so we would need to reorganize a fair
10088 bit to use walk_tree_without_duplicates, so we keep our own
10091 pfd
.visited
= visited
;
10093 pfd
.visited
= new hash_set
<tree
>;
10094 result
= cp_walk_tree (&t
,
10095 for_each_template_parm_r
,
10102 delete pfd
.visited
;
10109 /* Returns true if T depends on any template parameter. */
10112 uses_template_parms (tree t
)
10114 if (t
== NULL_TREE
)
10118 int saved_processing_template_decl
;
10120 saved_processing_template_decl
= processing_template_decl
;
10121 if (!saved_processing_template_decl
)
10122 processing_template_decl
= 1;
10124 dependent_p
= dependent_type_p (t
);
10125 else if (TREE_CODE (t
) == TREE_VEC
)
10126 dependent_p
= any_dependent_template_arguments_p (t
);
10127 else if (TREE_CODE (t
) == TREE_LIST
)
10128 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
10129 || uses_template_parms (TREE_CHAIN (t
)));
10130 else if (TREE_CODE (t
) == TYPE_DECL
)
10131 dependent_p
= dependent_type_p (TREE_TYPE (t
));
10132 else if (DECL_P (t
)
10134 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
10135 || TREE_CODE (t
) == OVERLOAD
10137 || identifier_p (t
)
10138 || TREE_CODE (t
) == TRAIT_EXPR
10139 || TREE_CODE (t
) == CONSTRUCTOR
10140 || CONSTANT_CLASS_P (t
))
10141 dependent_p
= (type_dependent_expression_p (t
)
10142 || value_dependent_expression_p (t
));
10145 gcc_assert (t
== error_mark_node
);
10146 dependent_p
= false;
10149 processing_template_decl
= saved_processing_template_decl
;
10151 return dependent_p
;
10154 /* Returns true iff current_function_decl is an incompletely instantiated
10155 template. Useful instead of processing_template_decl because the latter
10156 is set to 0 during instantiate_non_dependent_expr. */
10159 in_template_function (void)
10161 tree fn
= current_function_decl
;
10163 ++processing_template_decl
;
10164 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
10165 && DECL_TEMPLATE_INFO (fn
)
10166 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
10167 --processing_template_decl
;
10171 /* Returns true if T depends on any template parameter with level LEVEL. */
10174 uses_template_parms_level (tree t
, int level
)
10176 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
10177 /*include_nondeduced_p=*/true);
10180 /* Returns true if the signature of DECL depends on any template parameter from
10181 its enclosing class. */
10184 uses_outer_template_parms (tree decl
)
10186 int depth
= template_class_depth (CP_DECL_CONTEXT (decl
));
10189 if (for_each_template_parm (TREE_TYPE (decl
), template_parm_outer_level
,
10190 &depth
, NULL
, /*include_nondeduced_p=*/true))
10192 if (PRIMARY_TEMPLATE_P (decl
)
10193 && for_each_template_parm (INNERMOST_TEMPLATE_PARMS
10194 (DECL_TEMPLATE_PARMS (decl
)),
10195 template_parm_outer_level
,
10196 &depth
, NULL
, /*include_nondeduced_p=*/true))
10198 tree ci
= get_constraints (decl
);
10200 ci
= CI_ASSOCIATED_CONSTRAINTS (ci
);
10201 if (ci
&& for_each_template_parm (ci
, template_parm_outer_level
,
10202 &depth
, NULL
, /*nondeduced*/true))
10207 /* Returns TRUE iff INST is an instantiation we don't need to do in an
10208 ill-formed translation unit, i.e. a variable or function that isn't
10209 usable in a constant expression. */
10212 neglectable_inst_p (tree d
)
10214 return (d
&& DECL_P (d
)
10215 && !undeduced_auto_decl (d
)
10216 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
10217 : decl_maybe_constant_var_p (d
)));
10220 /* Returns TRUE iff we should refuse to instantiate DECL because it's
10221 neglectable and instantiated from within an erroneous instantiation. */
10224 limit_bad_template_recursion (tree decl
)
10226 struct tinst_level
*lev
= current_tinst_level
;
10227 int errs
= errorcount
+ sorrycount
;
10228 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
10231 for (; lev
; lev
= lev
->next
)
10232 if (neglectable_inst_p (lev
->maybe_get_node ()))
10235 return (lev
&& errs
> lev
->errors
);
10238 static int tinst_depth
;
10239 extern int max_tinst_depth
;
10242 static GTY(()) struct tinst_level
*last_error_tinst_level
;
10244 /* We're starting to instantiate D; record the template instantiation context
10245 at LOC for diagnostics and to restore it later. */
10248 push_tinst_level_loc (tree tldcl
, tree targs
, location_t loc
)
10250 struct tinst_level
*new_level
;
10252 if (tinst_depth
>= max_tinst_depth
)
10254 /* Tell error.c not to try to instantiate any templates. */
10256 fatal_error (input_location
,
10257 "template instantiation depth exceeds maximum of %d"
10258 " (use %<-ftemplate-depth=%> to increase the maximum)",
10263 /* If the current instantiation caused problems, don't let it instantiate
10264 anything else. Do allow deduction substitution and decls usable in
10265 constant expressions. */
10266 if (!targs
&& limit_bad_template_recursion (tldcl
))
10269 /* When not -quiet, dump template instantiations other than functions, since
10270 announce_function will take care of those. */
10271 if (!quiet_flag
&& !targs
10272 && TREE_CODE (tldcl
) != TREE_LIST
10273 && TREE_CODE (tldcl
) != FUNCTION_DECL
)
10274 fprintf (stderr
, " %s", decl_as_string (tldcl
, TFF_DECL_SPECIFIERS
));
10276 new_level
= tinst_level_freelist ().alloc ();
10277 new_level
->tldcl
= tldcl
;
10278 new_level
->targs
= targs
;
10279 new_level
->locus
= loc
;
10280 new_level
->errors
= errorcount
+ sorrycount
;
10281 new_level
->next
= NULL
;
10282 new_level
->refcount
= 0;
10283 set_refcount_ptr (new_level
->next
, current_tinst_level
);
10284 set_refcount_ptr (current_tinst_level
, new_level
);
10287 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
10288 depth_reached
= tinst_depth
;
10293 /* We're starting substitution of TMPL<ARGS>; record the template
10294 substitution context for diagnostics and to restore it later. */
10297 push_tinst_level (tree tmpl
, tree args
)
10299 return push_tinst_level_loc (tmpl
, args
, input_location
);
10302 /* We're starting to instantiate D; record INPUT_LOCATION and the
10303 template instantiation context for diagnostics and to restore it
10307 push_tinst_level (tree d
)
10309 return push_tinst_level_loc (d
, input_location
);
10312 /* Likewise, but record LOC as the program location. */
10315 push_tinst_level_loc (tree d
, location_t loc
)
10317 gcc_assert (TREE_CODE (d
) != TREE_LIST
);
10318 return push_tinst_level_loc (d
, NULL
, loc
);
10321 /* We're done instantiating this template; return to the instantiation
10325 pop_tinst_level (void)
10327 /* Restore the filename and line number stashed away when we started
10328 this instantiation. */
10329 input_location
= current_tinst_level
->locus
;
10330 set_refcount_ptr (current_tinst_level
, current_tinst_level
->next
);
10334 /* We're instantiating a deferred template; restore the template
10335 instantiation context in which the instantiation was requested, which
10336 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
10339 reopen_tinst_level (struct tinst_level
*level
)
10341 struct tinst_level
*t
;
10344 for (t
= level
; t
; t
= t
->next
)
10347 set_refcount_ptr (current_tinst_level
, level
);
10348 pop_tinst_level ();
10349 if (current_tinst_level
)
10350 current_tinst_level
->errors
= errorcount
+sorrycount
;
10351 return level
->maybe_get_node ();
10354 /* Returns the TINST_LEVEL which gives the original instantiation
10357 struct tinst_level
*
10358 outermost_tinst_level (void)
10360 struct tinst_level
*level
= current_tinst_level
;
10362 while (level
->next
)
10363 level
= level
->next
;
10367 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
10368 vector of template arguments, as for tsubst.
10370 Returns an appropriate tsubst'd friend declaration. */
10373 tsubst_friend_function (tree decl
, tree args
)
10377 if (TREE_CODE (decl
) == FUNCTION_DECL
10378 && DECL_TEMPLATE_INSTANTIATION (decl
)
10379 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
10380 /* This was a friend declared with an explicit template
10381 argument list, e.g.:
10383 friend void f<>(T);
10385 to indicate that f was a template instantiation, not a new
10386 function declaration. Now, we have to figure out what
10387 instantiation of what template. */
10389 tree template_id
, arglist
, fns
;
10392 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
10394 /* Friend functions are looked up in the containing namespace scope.
10395 We must enter that scope, to avoid finding member functions of the
10396 current class with same name. */
10397 push_nested_namespace (ns
);
10398 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
10399 tf_warning_or_error
, NULL_TREE
,
10400 /*integral_constant_expression_p=*/false);
10401 pop_nested_namespace (ns
);
10402 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
10403 tf_warning_or_error
, NULL_TREE
);
10404 template_id
= lookup_template_function (fns
, arglist
);
10406 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
10407 tmpl
= determine_specialization (template_id
, new_friend
,
10409 /*need_member_template=*/0,
10410 TREE_VEC_LENGTH (args
),
10412 return instantiate_template (tmpl
, new_args
, tf_error
);
10415 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
10417 /* The NEW_FRIEND will look like an instantiation, to the
10418 compiler, but is not an instantiation from the point of view of
10419 the language. For example, we might have had:
10421 template <class T> struct S {
10422 template <class U> friend void f(T, U);
10425 Then, in S<int>, template <class U> void f(int, U) is not an
10426 instantiation of anything. */
10427 if (new_friend
== error_mark_node
)
10428 return error_mark_node
;
10430 DECL_USE_TEMPLATE (new_friend
) = 0;
10431 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
10433 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
10434 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
10435 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
10438 /* The mangled name for the NEW_FRIEND is incorrect. The function
10439 is not a template instantiation and should not be mangled like
10440 one. Therefore, we forget the mangling here; we'll recompute it
10441 later if we need it. */
10442 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
10444 SET_DECL_RTL (new_friend
, NULL
);
10445 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
10448 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
10451 tree new_friend_template_info
;
10452 tree new_friend_result_template_info
;
10454 int new_friend_is_defn
;
10456 /* We must save some information from NEW_FRIEND before calling
10457 duplicate decls since that function will free NEW_FRIEND if
10459 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
10460 new_friend_is_defn
=
10461 (DECL_INITIAL (DECL_TEMPLATE_RESULT
10462 (template_for_substitution (new_friend
)))
10464 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
10466 /* This declaration is a `primary' template. */
10467 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
10469 new_friend_result_template_info
10470 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
10473 new_friend_result_template_info
= NULL_TREE
;
10475 /* Inside pushdecl_namespace_level, we will push into the
10476 current namespace. However, the friend function should go
10477 into the namespace of the template. */
10478 ns
= decl_namespace_context (new_friend
);
10479 push_nested_namespace (ns
);
10480 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
10481 pop_nested_namespace (ns
);
10483 if (old_decl
== error_mark_node
)
10484 return error_mark_node
;
10486 if (old_decl
!= new_friend
)
10488 /* This new friend declaration matched an existing
10489 declaration. For example, given:
10491 template <class T> void f(T);
10492 template <class U> class C {
10493 template <class T> friend void f(T) {}
10496 the friend declaration actually provides the definition
10497 of `f', once C has been instantiated for some type. So,
10498 old_decl will be the out-of-class template declaration,
10499 while new_friend is the in-class definition.
10501 But, if `f' was called before this point, the
10502 instantiation of `f' will have DECL_TI_ARGS corresponding
10503 to `T' but not to `U', references to which might appear
10504 in the definition of `f'. Previously, the most general
10505 template for an instantiation of `f' was the out-of-class
10506 version; now it is the in-class version. Therefore, we
10507 run through all specialization of `f', adding to their
10508 DECL_TI_ARGS appropriately. In particular, they need a
10509 new set of outer arguments, corresponding to the
10510 arguments for this class instantiation.
10512 The same situation can arise with something like this:
10514 friend void f(int);
10515 template <class T> class C {
10516 friend void f(T) {}
10519 when `C<int>' is instantiated. Now, `f(int)' is defined
10522 if (!new_friend_is_defn
)
10523 /* On the other hand, if the in-class declaration does
10524 *not* provide a definition, then we don't want to alter
10525 existing definitions. We can just leave everything
10530 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
10531 tree new_args
= TI_ARGS (new_friend_template_info
);
10533 /* Overwrite whatever template info was there before, if
10534 any, with the new template information pertaining to
10535 the declaration. */
10536 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
10538 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
10540 /* We should have called reregister_specialization in
10541 duplicate_decls. */
10542 gcc_assert (retrieve_specialization (new_template
,
10546 /* Instantiate it if the global has already been used. */
10547 if (DECL_ODR_USED (old_decl
))
10548 instantiate_decl (old_decl
, /*defer_ok=*/true,
10549 /*expl_inst_class_mem_p=*/false);
10555 /* Indicate that the old function template is a partial
10557 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
10558 = new_friend_result_template_info
;
10560 gcc_assert (new_template
10561 == most_general_template (new_template
));
10562 gcc_assert (new_template
!= old_decl
);
10564 /* Reassign any specializations already in the hash table
10565 to the new more general template, and add the
10566 additional template args. */
10567 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
10569 t
= TREE_CHAIN (t
))
10571 tree spec
= TREE_VALUE (t
);
10574 elt
.tmpl
= old_decl
;
10575 elt
.args
= DECL_TI_ARGS (spec
);
10576 elt
.spec
= NULL_TREE
;
10578 decl_specializations
->remove_elt (&elt
);
10580 DECL_TI_ARGS (spec
)
10581 = add_outermost_template_args (new_args
,
10582 DECL_TI_ARGS (spec
));
10584 register_specialization
10585 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
10588 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
10592 /* The information from NEW_FRIEND has been merged into OLD_DECL
10593 by duplicate_decls. */
10594 new_friend
= old_decl
;
10599 tree context
= DECL_CONTEXT (new_friend
);
10603 template <class T> class C {
10604 template <class U> friend void C1<U>::f (); // case 1
10605 friend void C2<T>::f (); // case 2
10607 we only need to make sure CONTEXT is a complete type for
10608 case 2. To distinguish between the two cases, we note that
10609 CONTEXT of case 1 remains dependent type after tsubst while
10610 this isn't true for case 2. */
10611 ++processing_template_decl
;
10612 dependent_p
= dependent_type_p (context
);
10613 --processing_template_decl
;
10616 && !complete_type_or_else (context
, NULL_TREE
))
10617 return error_mark_node
;
10619 if (COMPLETE_TYPE_P (context
))
10621 tree fn
= new_friend
;
10622 /* do_friend adds the TEMPLATE_DECL for any member friend
10623 template even if it isn't a member template, i.e.
10624 template <class T> friend A<T>::f();
10625 Look through it in that case. */
10626 if (TREE_CODE (fn
) == TEMPLATE_DECL
10627 && !PRIMARY_TEMPLATE_P (fn
))
10628 fn
= DECL_TEMPLATE_RESULT (fn
);
10629 /* Check to see that the declaration is really present, and,
10630 possibly obtain an improved declaration. */
10631 fn
= check_classfn (context
, fn
, NULL_TREE
);
10641 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
10642 template arguments, as for tsubst.
10644 Returns an appropriate tsubst'd friend type or error_mark_node on
10648 tsubst_friend_class (tree friend_tmpl
, tree args
)
10652 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
10654 tmpl
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
10655 return TREE_TYPE (tmpl
);
10658 tree context
= CP_DECL_CONTEXT (friend_tmpl
);
10659 if (TREE_CODE (context
) == NAMESPACE_DECL
)
10660 push_nested_namespace (context
);
10663 context
= tsubst (context
, args
, tf_error
, NULL_TREE
);
10664 push_nested_class (context
);
10667 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), /*prefer_type=*/false,
10668 /*non_class=*/false, /*block_p=*/false,
10669 /*namespaces_only=*/false, LOOKUP_HIDDEN
);
10671 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
10673 /* The friend template has already been declared. Just
10674 check to see that the declarations match, and install any new
10675 default parameters. We must tsubst the default parameters,
10676 of course. We only need the innermost template parameters
10677 because that is all that redeclare_class_template will look
10679 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
10680 > TMPL_ARGS_DEPTH (args
))
10682 tree parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
10683 args
, tf_warning_or_error
);
10684 location_t saved_input_location
= input_location
;
10685 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
10686 tree cons
= get_constraints (tmpl
);
10687 redeclare_class_template (TREE_TYPE (tmpl
), parms
, cons
);
10688 input_location
= saved_input_location
;
10693 /* The friend template has not already been declared. In this
10694 case, the instantiation of the template class will cause the
10695 injection of this template into the namespace scope. */
10696 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
10698 if (tmpl
!= error_mark_node
)
10700 /* The new TMPL is not an instantiation of anything, so we
10701 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE
10702 for the new type because that is supposed to be the
10703 corresponding template decl, i.e., TMPL. */
10704 DECL_USE_TEMPLATE (tmpl
) = 0;
10705 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
10706 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
10707 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
10708 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
10710 /* It is hidden. */
10711 retrofit_lang_decl (DECL_TEMPLATE_RESULT (tmpl
));
10712 DECL_ANTICIPATED (tmpl
)
10713 = DECL_ANTICIPATED (DECL_TEMPLATE_RESULT (tmpl
)) = true;
10715 /* Inject this template into the enclosing namspace scope. */
10716 tmpl
= pushdecl_namespace_level (tmpl
, true);
10720 if (TREE_CODE (context
) == NAMESPACE_DECL
)
10721 pop_nested_namespace (context
);
10723 pop_nested_class ();
10725 return TREE_TYPE (tmpl
);
10728 /* Returns zero if TYPE cannot be completed later due to circularity.
10729 Otherwise returns one. */
10732 can_complete_type_without_circularity (tree type
)
10734 if (type
== NULL_TREE
|| type
== error_mark_node
)
10736 else if (COMPLETE_TYPE_P (type
))
10738 else if (TREE_CODE (type
) == ARRAY_TYPE
)
10739 return can_complete_type_without_circularity (TREE_TYPE (type
));
10740 else if (CLASS_TYPE_P (type
)
10741 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
10747 static tree
tsubst_omp_clauses (tree
, enum c_omp_region_type
, tree
,
10748 tsubst_flags_t
, tree
);
10750 /* Instantiate a single dependent attribute T (a TREE_LIST), and return either
10751 T or a new TREE_LIST, possibly a chain in the case of a pack expansion. */
10754 tsubst_attribute (tree t
, tree
*decl_p
, tree args
,
10755 tsubst_flags_t complain
, tree in_decl
)
10757 gcc_assert (ATTR_IS_DEPENDENT (t
));
10759 tree val
= TREE_VALUE (t
);
10760 if (val
== NULL_TREE
)
10761 /* Nothing to do. */;
10762 else if ((flag_openmp
|| flag_openmp_simd
)
10763 && is_attribute_p ("omp declare simd",
10764 get_attribute_name (t
)))
10766 tree clauses
= TREE_VALUE (val
);
10767 clauses
= tsubst_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
, args
,
10768 complain
, in_decl
);
10769 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
10770 clauses
= finish_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
);
10771 tree parms
= DECL_ARGUMENTS (*decl_p
);
10773 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
10775 val
= build_tree_list (NULL_TREE
, clauses
);
10779 /* If the first attribute argument is an identifier, don't
10780 pass it through tsubst. Attributes like mode, format,
10781 cleanup and several target specific attributes expect it
10783 else if (attribute_takes_identifier_p (get_attribute_name (t
)))
10786 = tsubst_expr (TREE_CHAIN (val
), args
, complain
, in_decl
,
10787 /*integral_constant_expression_p=*/false);
10788 if (chain
!= TREE_CHAIN (val
))
10789 val
= tree_cons (NULL_TREE
, TREE_VALUE (val
), chain
);
10791 else if (PACK_EXPANSION_P (val
))
10793 /* An attribute pack expansion. */
10794 tree purp
= TREE_PURPOSE (t
);
10795 tree pack
= tsubst_pack_expansion (val
, args
, complain
, in_decl
);
10796 if (pack
== error_mark_node
)
10797 return error_mark_node
;
10798 int len
= TREE_VEC_LENGTH (pack
);
10799 tree list
= NULL_TREE
;
10801 for (int i
= 0; i
< len
; ++i
)
10803 tree elt
= TREE_VEC_ELT (pack
, i
);
10804 *q
= build_tree_list (purp
, elt
);
10805 q
= &TREE_CHAIN (*q
);
10810 val
= tsubst_expr (val
, args
, complain
, in_decl
,
10811 /*integral_constant_expression_p=*/false);
10813 if (val
!= TREE_VALUE (t
))
10814 return build_tree_list (TREE_PURPOSE (t
), val
);
10818 /* Instantiate any dependent attributes in ATTRIBUTES, returning either it
10819 unchanged or a new TREE_LIST chain. */
10822 tsubst_attributes (tree attributes
, tree args
,
10823 tsubst_flags_t complain
, tree in_decl
)
10825 tree last_dep
= NULL_TREE
;
10827 for (tree t
= attributes
; t
; t
= TREE_CHAIN (t
))
10828 if (ATTR_IS_DEPENDENT (t
))
10831 attributes
= copy_list (attributes
);
10836 for (tree
*p
= &attributes
; *p
; )
10839 if (ATTR_IS_DEPENDENT (t
))
10841 tree subst
= tsubst_attribute (t
, NULL
, args
, complain
, in_decl
);
10846 p
= &TREE_CHAIN (*p
);
10847 *p
= TREE_CHAIN (t
);
10851 p
= &TREE_CHAIN (*p
);
10857 /* Apply any attributes which had to be deferred until instantiation
10858 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
10859 ARGS, COMPLAIN, IN_DECL are as tsubst. */
10862 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
10863 tree args
, tsubst_flags_t complain
, tree in_decl
)
10865 tree last_dep
= NULL_TREE
;
10869 if (attributes
== NULL_TREE
)
10872 if (DECL_P (*decl_p
))
10874 if (TREE_TYPE (*decl_p
) == error_mark_node
)
10876 p
= &DECL_ATTRIBUTES (*decl_p
);
10877 /* DECL_ATTRIBUTES comes from copy_node in tsubst_decl, and is identical
10878 to our attributes parameter. */
10879 gcc_assert (*p
== attributes
);
10883 p
= &TYPE_ATTRIBUTES (*decl_p
);
10884 /* TYPE_ATTRIBUTES was set up (with abi_tag and may_alias) in
10885 lookup_template_class_1, and should be preserved. */
10886 gcc_assert (*p
!= attributes
);
10888 p
= &TREE_CHAIN (*p
);
10891 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
10892 if (ATTR_IS_DEPENDENT (t
))
10895 attributes
= copy_list (attributes
);
10902 tree late_attrs
= NULL_TREE
;
10903 tree
*q
= &late_attrs
;
10908 if (ATTR_IS_DEPENDENT (t
))
10910 *p
= TREE_CHAIN (t
);
10911 TREE_CHAIN (t
) = NULL_TREE
;
10912 *q
= tsubst_attribute (t
, decl_p
, args
, complain
, in_decl
);
10914 q
= &TREE_CHAIN (*q
);
10917 p
= &TREE_CHAIN (t
);
10920 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
10924 /* Perform (or defer) access check for typedefs that were referenced
10925 from within the template TMPL code.
10926 This is a subroutine of instantiate_decl and instantiate_class_template.
10927 TMPL is the template to consider and TARGS is the list of arguments of
10931 perform_typedefs_access_check (tree tmpl
, tree targs
)
10933 location_t saved_location
;
10935 qualified_typedef_usage_t
*iter
;
10938 || (!CLASS_TYPE_P (tmpl
)
10939 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
10942 saved_location
= input_location
;
10943 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
10945 tree type_decl
= iter
->typedef_decl
;
10946 tree type_scope
= iter
->context
;
10948 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
10951 if (uses_template_parms (type_decl
))
10952 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
10953 if (uses_template_parms (type_scope
))
10954 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
10956 /* Make access check error messages point to the location
10957 of the use of the typedef. */
10958 input_location
= iter
->locus
;
10959 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
10960 type_decl
, type_decl
,
10961 tf_warning_or_error
);
10963 input_location
= saved_location
;
10967 instantiate_class_template_1 (tree type
)
10969 tree templ
, args
, pattern
, t
, member
;
10973 unsigned int saved_maximum_field_alignment
;
10976 if (type
== error_mark_node
)
10977 return error_mark_node
;
10979 if (COMPLETE_OR_OPEN_TYPE_P (type
)
10980 || uses_template_parms (type
))
10983 /* Figure out which template is being instantiated. */
10984 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
10985 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
10987 /* Mark the type as in the process of being defined. */
10988 TYPE_BEING_DEFINED (type
) = 1;
10990 /* We may be in the middle of deferred access check. Disable
10992 deferring_access_check_sentinel
acs (dk_no_deferred
);
10994 /* Determine what specialization of the original template to
10996 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
10997 if (t
== error_mark_node
)
10998 return error_mark_node
;
11001 /* This TYPE is actually an instantiation of a partial
11002 specialization. We replace the innermost set of ARGS with
11003 the arguments appropriate for substitution. For example,
11006 template <class T> struct S {};
11007 template <class T> struct S<T*> {};
11009 and supposing that we are instantiating S<int*>, ARGS will
11010 presently be {int*} -- but we need {int}. */
11011 pattern
= TREE_TYPE (t
);
11012 args
= TREE_PURPOSE (t
);
11016 pattern
= TREE_TYPE (templ
);
11017 args
= CLASSTYPE_TI_ARGS (type
);
11020 /* If the template we're instantiating is incomplete, then clearly
11021 there's nothing we can do. */
11022 if (!COMPLETE_TYPE_P (pattern
))
11024 /* We can try again later. */
11025 TYPE_BEING_DEFINED (type
) = 0;
11029 /* If we've recursively instantiated too many templates, stop. */
11030 if (! push_tinst_level (type
))
11033 int saved_unevaluated_operand
= cp_unevaluated_operand
;
11034 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
11036 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
11037 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
11038 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
11039 fn_context
= error_mark_node
;
11041 push_to_top_level ();
11044 cp_unevaluated_operand
= 0;
11045 c_inhibit_evaluation_warnings
= 0;
11047 /* Use #pragma pack from the template context. */
11048 saved_maximum_field_alignment
= maximum_field_alignment
;
11049 maximum_field_alignment
= TYPE_PRECISION (pattern
);
11051 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
11053 /* Set the input location to the most specialized template definition.
11054 This is needed if tsubsting causes an error. */
11055 typedecl
= TYPE_MAIN_DECL (pattern
);
11056 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
11057 DECL_SOURCE_LOCATION (typedecl
);
11059 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
11060 SET_TYPE_ALIGN (type
, TYPE_ALIGN (pattern
));
11061 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
11062 CLASSTYPE_NON_AGGREGATE (type
) = CLASSTYPE_NON_AGGREGATE (pattern
);
11063 if (ANON_AGGR_TYPE_P (pattern
))
11064 SET_ANON_AGGR_TYPE_P (type
);
11065 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
11067 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
11068 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
11069 /* Adjust visibility for template arguments. */
11070 determine_visibility (TYPE_MAIN_DECL (type
));
11072 if (CLASS_TYPE_P (type
))
11073 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
11075 pbinfo
= TYPE_BINFO (pattern
);
11077 /* We should never instantiate a nested class before its enclosing
11078 class; we need to look up the nested class by name before we can
11079 instantiate it, and that lookup should instantiate the enclosing
11081 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
11082 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
11084 base_list
= NULL_TREE
;
11085 if (BINFO_N_BASE_BINFOS (pbinfo
))
11091 /* We must enter the scope containing the type, as that is where
11092 the accessibility of types named in dependent bases are
11094 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
11096 /* Substitute into each of the bases to determine the actual
11098 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
11101 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
11102 tree expanded_bases
= NULL_TREE
;
11105 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
11108 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
11109 args
, tf_error
, NULL_TREE
);
11110 if (expanded_bases
== error_mark_node
)
11113 len
= TREE_VEC_LENGTH (expanded_bases
);
11116 for (idx
= 0; idx
< len
; idx
++)
11118 if (expanded_bases
)
11119 /* Extract the already-expanded base class. */
11120 base
= TREE_VEC_ELT (expanded_bases
, idx
);
11122 /* Substitute to figure out the base class. */
11123 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
11126 if (base
== error_mark_node
)
11129 base_list
= tree_cons (access
, base
, base_list
);
11130 if (BINFO_VIRTUAL_P (pbase_binfo
))
11131 TREE_TYPE (base_list
) = integer_type_node
;
11135 /* The list is now in reverse order; correct that. */
11136 base_list
= nreverse (base_list
);
11139 pop_scope (pushed_scope
);
11141 /* Now call xref_basetypes to set up all the base-class
11143 xref_basetypes (type
, base_list
);
11145 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
11146 (int) ATTR_FLAG_TYPE_IN_PLACE
,
11147 args
, tf_error
, NULL_TREE
);
11148 fixup_attribute_variants (type
);
11150 /* Now that our base classes are set up, enter the scope of the
11151 class, so that name lookups into base classes, etc. will work
11152 correctly. This is precisely analogous to what we do in
11153 begin_class_definition when defining an ordinary non-template
11154 class, except we also need to push the enclosing classes. */
11155 push_nested_class (type
);
11157 /* Now members are processed in the order of declaration. */
11158 for (member
= CLASSTYPE_DECL_LIST (pattern
);
11159 member
; member
= TREE_CHAIN (member
))
11161 tree t
= TREE_VALUE (member
);
11163 if (TREE_PURPOSE (member
))
11167 if (LAMBDA_TYPE_P (t
))
11168 /* A closure type for a lambda in an NSDMI or default argument.
11169 Ignore it; it will be regenerated when needed. */
11172 /* Build new CLASSTYPE_NESTED_UTDS. */
11175 bool class_template_p
;
11177 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
11178 && TYPE_LANG_SPECIFIC (t
)
11179 && CLASSTYPE_IS_TEMPLATE (t
));
11180 /* If the member is a class template, then -- even after
11181 substitution -- there may be dependent types in the
11182 template argument list for the class. We increment
11183 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
11184 that function will assume that no types are dependent
11185 when outside of a template. */
11186 if (class_template_p
)
11187 ++processing_template_decl
;
11188 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
11189 if (class_template_p
)
11190 --processing_template_decl
;
11191 if (newtag
== error_mark_node
)
11194 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
11196 tree name
= TYPE_IDENTIFIER (t
);
11198 if (class_template_p
)
11199 /* Unfortunately, lookup_template_class sets
11200 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
11201 instantiation (i.e., for the type of a member
11202 template class nested within a template class.)
11203 This behavior is required for
11204 maybe_process_partial_specialization to work
11205 correctly, but is not accurate in this case;
11206 the TAG is not an instantiation of anything.
11207 (The corresponding TEMPLATE_DECL is an
11208 instantiation, but the TYPE is not.) */
11209 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
11211 /* Now, we call pushtag to put this NEWTAG into the scope of
11212 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
11213 pushtag calling push_template_decl. We don't have to do
11214 this for enums because it will already have been done in
11217 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
11218 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
11221 else if (DECL_DECLARES_FUNCTION_P (t
))
11225 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11226 ++processing_template_decl
;
11227 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
11228 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11229 --processing_template_decl
;
11230 set_current_access_from_decl (r
);
11231 finish_member_declaration (r
);
11232 /* Instantiate members marked with attribute used. */
11233 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
11235 if (TREE_CODE (r
) == FUNCTION_DECL
11236 && DECL_OMP_DECLARE_REDUCTION_P (r
))
11237 cp_check_omp_declare_reduction (r
);
11239 else if ((DECL_CLASS_TEMPLATE_P (t
) || DECL_IMPLICIT_TYPEDEF_P (t
))
11240 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
11241 /* A closure type for a lambda in an NSDMI or default argument.
11242 Ignore it; it will be regenerated when needed. */;
11245 /* Build new TYPE_FIELDS. */
11246 if (TREE_CODE (t
) == STATIC_ASSERT
)
11250 ++c_inhibit_evaluation_warnings
;
11252 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
11253 tf_warning_or_error
, NULL_TREE
,
11254 /*integral_constant_expression_p=*/true);
11255 --c_inhibit_evaluation_warnings
;
11257 finish_static_assert (condition
,
11258 STATIC_ASSERT_MESSAGE (t
),
11259 STATIC_ASSERT_SOURCE_LOCATION (t
),
11260 /*member_p=*/true);
11262 else if (TREE_CODE (t
) != CONST_DECL
)
11265 tree vec
= NULL_TREE
;
11268 /* The file and line for this declaration, to
11269 assist in error message reporting. Since we
11270 called push_tinst_level above, we don't need to
11272 input_location
= DECL_SOURCE_LOCATION (t
);
11274 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11275 ++processing_template_decl
;
11276 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
11277 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11278 --processing_template_decl
;
11280 if (TREE_CODE (r
) == TREE_VEC
)
11282 /* A capture pack became multiple fields. */
11284 len
= TREE_VEC_LENGTH (vec
);
11287 for (int i
= 0; i
< len
; ++i
)
11290 r
= TREE_VEC_ELT (vec
, i
);
11295 [t]he initialization (and any associated
11296 side-effects) of a static data member does
11297 not occur unless the static data member is
11298 itself used in a way that requires the
11299 definition of the static data member to
11302 Therefore, we do not substitute into the
11303 initialized for the static data member here. */
11304 finish_static_data_member_decl
11306 /*init=*/NULL_TREE
,
11307 /*init_const_expr_p=*/false,
11308 /*asmspec_tree=*/NULL_TREE
,
11310 /* Instantiate members marked with attribute used. */
11311 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
11314 else if (TREE_CODE (r
) == FIELD_DECL
)
11316 /* Determine whether R has a valid type and can be
11317 completed later. If R is invalid, then its type
11318 is replaced by error_mark_node. */
11319 tree rtype
= TREE_TYPE (r
);
11320 if (can_complete_type_without_circularity (rtype
))
11321 complete_type (rtype
);
11323 if (!complete_or_array_type_p (rtype
))
11325 /* If R's type couldn't be completed and
11326 it isn't a flexible array member (whose
11327 type is incomplete by definition) give
11329 cxx_incomplete_type_error (r
, rtype
);
11330 TREE_TYPE (r
) = error_mark_node
;
11332 else if (TREE_CODE (rtype
) == ARRAY_TYPE
11333 && TYPE_DOMAIN (rtype
) == NULL_TREE
11334 && (TREE_CODE (type
) == UNION_TYPE
11335 || TREE_CODE (type
) == QUAL_UNION_TYPE
))
11337 error ("flexible array member %qD in union", r
);
11338 TREE_TYPE (r
) = error_mark_node
;
11342 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
11343 such a thing will already have been added to the field
11344 list by tsubst_enum in finish_member_declaration in the
11345 CLASSTYPE_NESTED_UTDS case above. */
11346 if (!(TREE_CODE (r
) == TYPE_DECL
11347 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
11348 && DECL_ARTIFICIAL (r
)))
11350 set_current_access_from_decl (r
);
11351 finish_member_declaration (r
);
11359 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
11360 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
11362 /* Build new CLASSTYPE_FRIEND_CLASSES. */
11364 tree friend_type
= t
;
11365 bool adjust_processing_template_decl
= false;
11367 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
11369 /* template <class T> friend class C; */
11370 friend_type
= tsubst_friend_class (friend_type
, args
);
11371 adjust_processing_template_decl
= true;
11373 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
11375 /* template <class T> friend class C::D; */
11376 friend_type
= tsubst (friend_type
, args
,
11377 tf_warning_or_error
, NULL_TREE
);
11378 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
11379 friend_type
= TREE_TYPE (friend_type
);
11380 adjust_processing_template_decl
= true;
11382 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
11383 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
11385 /* This could be either
11389 when dependent_type_p is false or
11391 template <class U> friend class T::C;
11394 /* Bump processing_template_decl in case this is something like
11395 template <class T> friend struct A<T>::B. */
11396 ++processing_template_decl
;
11397 friend_type
= tsubst (friend_type
, args
,
11398 tf_warning_or_error
, NULL_TREE
);
11399 if (dependent_type_p (friend_type
))
11400 adjust_processing_template_decl
= true;
11401 --processing_template_decl
;
11403 else if (TREE_CODE (friend_type
) != BOUND_TEMPLATE_TEMPLATE_PARM
11404 && !CLASSTYPE_USE_TEMPLATE (friend_type
)
11405 && TYPE_HIDDEN_P (friend_type
))
11409 where C hasn't been declared yet. Let's lookup name
11410 from namespace scope directly, bypassing any name that
11411 come from dependent base class. */
11412 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
11414 /* The call to xref_tag_from_type does injection for friend
11416 push_nested_namespace (ns
);
11418 xref_tag_from_type (friend_type
, NULL_TREE
,
11419 /*tag_scope=*/ts_current
);
11420 pop_nested_namespace (ns
);
11422 else if (uses_template_parms (friend_type
))
11423 /* friend class C<T>; */
11424 friend_type
= tsubst (friend_type
, args
,
11425 tf_warning_or_error
, NULL_TREE
);
11430 where C is already declared or
11432 friend class C<int>;
11434 We don't have to do anything in these cases. */
11436 if (adjust_processing_template_decl
)
11437 /* Trick make_friend_class into realizing that the friend
11438 we're adding is a template, not an ordinary class. It's
11439 important that we use make_friend_class since it will
11440 perform some error-checking and output cross-reference
11442 ++processing_template_decl
;
11444 if (friend_type
!= error_mark_node
)
11445 make_friend_class (type
, friend_type
, /*complain=*/false);
11447 if (adjust_processing_template_decl
)
11448 --processing_template_decl
;
11452 /* Build new DECL_FRIENDLIST. */
11455 /* The file and line for this declaration, to
11456 assist in error message reporting. Since we
11457 called push_tinst_level above, we don't need to
11459 input_location
= DECL_SOURCE_LOCATION (t
);
11461 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11463 ++processing_template_decl
;
11464 push_deferring_access_checks (dk_no_check
);
11467 r
= tsubst_friend_function (t
, args
);
11468 add_friend (type
, r
, /*complain=*/false);
11469 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11471 pop_deferring_access_checks ();
11472 --processing_template_decl
;
11480 /* Restore these before substituting into the lambda capture
11482 cp_unevaluated_operand
= saved_unevaluated_operand
;
11483 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
11486 /* Set the file and line number information to whatever is given for
11487 the class itself. This puts error messages involving generated
11488 implicit functions at a predictable point, and the same point
11489 that would be used for non-template classes. */
11490 input_location
= DECL_SOURCE_LOCATION (typedecl
);
11492 unreverse_member_declarations (type
);
11493 finish_struct_1 (type
);
11494 TYPE_BEING_DEFINED (type
) = 0;
11496 /* We don't instantiate default arguments for member functions. 14.7.1:
11498 The implicit instantiation of a class template specialization causes
11499 the implicit instantiation of the declarations, but not of the
11500 definitions or default arguments, of the class member functions,
11501 member classes, static data members and member templates.... */
11503 /* Some typedefs referenced from within the template code need to be access
11504 checked at template instantiation time, i.e now. These types were
11505 added to the template at parsing time. Let's get those and perform
11506 the access checks then. */
11507 perform_typedefs_access_check (pattern
, args
);
11508 perform_deferred_access_checks (tf_warning_or_error
);
11509 pop_nested_class ();
11510 maximum_field_alignment
= saved_maximum_field_alignment
;
11512 pop_from_top_level ();
11513 pop_tinst_level ();
11515 /* The vtable for a template class can be emitted in any translation
11516 unit in which the class is instantiated. When there is no key
11517 method, however, finish_struct_1 will already have added TYPE to
11518 the keyed_classes. */
11519 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
11520 vec_safe_push (keyed_classes
, type
);
11525 /* Wrapper for instantiate_class_template_1. */
11528 instantiate_class_template (tree type
)
11531 timevar_push (TV_TEMPLATE_INST
);
11532 ret
= instantiate_class_template_1 (type
);
11533 timevar_pop (TV_TEMPLATE_INST
);
11538 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11544 else if (TYPE_P (t
))
11545 r
= tsubst (t
, args
, complain
, in_decl
);
11548 if (!(complain
& tf_warning
))
11549 ++c_inhibit_evaluation_warnings
;
11550 r
= tsubst_expr (t
, args
, complain
, in_decl
,
11551 /*integral_constant_expression_p=*/true);
11552 if (!(complain
& tf_warning
))
11553 --c_inhibit_evaluation_warnings
;
11558 /* Given a function parameter pack TMPL_PARM and some function parameters
11559 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
11560 and set *SPEC_P to point at the next point in the list. */
11563 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
11565 /* Collect all of the extra "packed" parameters into an
11568 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
11569 tree spec_parm
= *spec_p
;
11572 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
11574 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
11577 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
11578 parmvec
= make_tree_vec (len
);
11579 spec_parm
= *spec_p
;
11580 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
11582 tree elt
= spec_parm
;
11583 if (DECL_PACK_P (elt
))
11584 elt
= make_pack_expansion (elt
);
11585 TREE_VEC_ELT (parmvec
, i
) = elt
;
11588 /* Build the argument packs. */
11589 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
11590 *spec_p
= spec_parm
;
11595 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
11596 NONTYPE_ARGUMENT_PACK. */
11599 make_fnparm_pack (tree spec_parm
)
11601 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
11604 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
11605 pack expansion with no extra args, 2 if it has extra args, or 0
11606 if it is not a pack expansion. */
11609 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
11611 if (TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
11612 /* We're being called before this happens in tsubst_pack_expansion. */
11613 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
11614 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
11615 if (i
>= TREE_VEC_LENGTH (vec
))
11617 tree elt
= TREE_VEC_ELT (vec
, i
);
11619 /* A decl pack is itself an expansion. */
11620 elt
= TREE_TYPE (elt
);
11621 if (!PACK_EXPANSION_P (elt
))
11623 if (PACK_EXPANSION_EXTRA_ARGS (elt
))
11629 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
11632 make_argument_pack_select (tree arg_pack
, unsigned index
)
11634 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
11636 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
11637 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
11642 /* This is a subroutine of tsubst_pack_expansion.
11644 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
11645 mechanism to store the (non complete list of) arguments of the
11646 substitution and return a non substituted pack expansion, in order
11647 to wait for when we have enough arguments to really perform the
11651 use_pack_expansion_extra_args_p (tree parm_packs
,
11653 bool has_empty_arg
)
11655 /* If one pack has an expansion and another pack has a normal
11656 argument or if one pack has an empty argument and an another
11657 one hasn't then tsubst_pack_expansion cannot perform the
11658 substitution and need to fall back on the
11659 PACK_EXPANSION_EXTRA mechanism. */
11660 if (parm_packs
== NULL_TREE
)
11662 else if (has_empty_arg
)
11665 bool has_expansion_arg
= false;
11666 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
11668 bool has_non_expansion_arg
= false;
11669 for (tree parm_pack
= parm_packs
;
11671 parm_pack
= TREE_CHAIN (parm_pack
))
11673 tree arg
= TREE_VALUE (parm_pack
);
11675 int exp
= argument_pack_element_is_expansion_p (arg
, i
);
11677 /* We can't substitute a pack expansion with extra args into
11681 has_expansion_arg
= true;
11683 has_non_expansion_arg
= true;
11686 if (has_expansion_arg
&& has_non_expansion_arg
)
11692 /* [temp.variadic]/6 says that:
11694 The instantiation of a pack expansion [...]
11695 produces a list E1,E2, ..., En, where N is the number of elements
11696 in the pack expansion parameters.
11698 This subroutine of tsubst_pack_expansion produces one of these Ei.
11700 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
11701 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
11702 PATTERN, and each TREE_VALUE is its corresponding argument pack.
11703 INDEX is the index 'i' of the element Ei to produce. ARGS,
11704 COMPLAIN, and IN_DECL are the same parameters as for the
11705 tsubst_pack_expansion function.
11707 The function returns the resulting Ei upon successful completion,
11708 or error_mark_node.
11710 Note that this function possibly modifies the ARGS parameter, so
11711 it's the responsibility of the caller to restore it. */
11714 gen_elem_of_pack_expansion_instantiation (tree pattern
,
11717 tree args
/* This parm gets
11719 tsubst_flags_t complain
,
11723 bool ith_elem_is_expansion
= false;
11725 /* For each parameter pack, change the substitution of the parameter
11726 pack to the ith argument in its argument pack, then expand the
11728 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
11730 tree parm
= TREE_PURPOSE (pack
);
11731 tree arg_pack
= TREE_VALUE (pack
);
11732 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
11734 ith_elem_is_expansion
|=
11735 argument_pack_element_is_expansion_p (arg_pack
, index
);
11737 /* Select the Ith argument from the pack. */
11738 if (TREE_CODE (parm
) == PARM_DECL
11740 || TREE_CODE (parm
) == FIELD_DECL
)
11744 aps
= make_argument_pack_select (arg_pack
, index
);
11745 if (!mark_used (parm
, complain
) && !(complain
& tf_error
))
11746 return error_mark_node
;
11747 register_local_specialization (aps
, parm
);
11750 aps
= retrieve_local_specialization (parm
);
11755 template_parm_level_and_index (parm
, &level
, &idx
);
11759 aps
= make_argument_pack_select (arg_pack
, index
);
11760 /* Update the corresponding argument. */
11761 TMPL_ARG (args
, level
, idx
) = aps
;
11764 /* Re-use the ARGUMENT_PACK_SELECT. */
11765 aps
= TMPL_ARG (args
, level
, idx
);
11767 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
11770 // Any local specialization bindings arising from this substitution
11771 // cannot be reused for a different INDEX.
11772 local_specialization_stack
lss (lss_copy
);
11774 /* Substitute into the PATTERN with the (possibly altered)
11776 if (pattern
== in_decl
)
11777 /* Expanding a fixed parameter pack from
11778 coerce_template_parameter_pack. */
11779 t
= tsubst_decl (pattern
, args
, complain
);
11780 else if (pattern
== error_mark_node
)
11781 t
= error_mark_node
;
11782 else if (constraint_p (pattern
))
11784 if (processing_template_decl
)
11785 t
= tsubst_constraint (pattern
, args
, complain
, in_decl
);
11787 t
= (constraints_satisfied_p (pattern
, args
)
11788 ? boolean_true_node
: boolean_false_node
);
11790 else if (!TYPE_P (pattern
))
11791 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
11792 /*integral_constant_expression_p=*/false);
11794 t
= tsubst (pattern
, args
, complain
, in_decl
);
11796 /* If the Ith argument pack element is a pack expansion, then
11797 the Ith element resulting from the substituting is going to
11798 be a pack expansion as well. */
11799 if (ith_elem_is_expansion
)
11800 t
= make_pack_expansion (t
, complain
);
11805 /* When the unexpanded parameter pack in a fold expression expands to an empty
11806 sequence, the value of the expression is as follows; the program is
11807 ill-formed if the operator is not listed in this table.
11814 expand_empty_fold (tree t
, tsubst_flags_t complain
)
11816 tree_code code
= (tree_code
)TREE_INT_CST_LOW (TREE_OPERAND (t
, 0));
11817 if (!FOLD_EXPR_MODIFY_P (t
))
11820 case TRUTH_ANDIF_EXPR
:
11821 return boolean_true_node
;
11822 case TRUTH_ORIF_EXPR
:
11823 return boolean_false_node
;
11824 case COMPOUND_EXPR
:
11830 if (complain
& tf_error
)
11831 error_at (location_of (t
),
11832 "fold of empty expansion over %O", code
);
11833 return error_mark_node
;
11836 /* Given a fold-expression T and a current LEFT and RIGHT operand,
11837 form an expression that combines the two terms using the
11841 fold_expression (tree t
, tree left
, tree right
, tsubst_flags_t complain
)
11843 tree op
= FOLD_EXPR_OP (t
);
11844 tree_code code
= (tree_code
)TREE_INT_CST_LOW (op
);
11846 // Handle compound assignment operators.
11847 if (FOLD_EXPR_MODIFY_P (t
))
11848 return build_x_modify_expr (input_location
, left
, code
, right
, complain
);
11852 case COMPOUND_EXPR
:
11853 return build_x_compound_expr (input_location
, left
, right
, complain
);
11855 return build_x_binary_op (input_location
, code
,
11856 left
, TREE_CODE (left
),
11857 right
, TREE_CODE (right
),
11863 /* Substitute ARGS into the pack of a fold expression T. */
11866 tsubst_fold_expr_pack (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11868 return tsubst_pack_expansion (FOLD_EXPR_PACK (t
), args
, complain
, in_decl
);
11871 /* Substitute ARGS into the pack of a fold expression T. */
11874 tsubst_fold_expr_init (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11876 return tsubst_expr (FOLD_EXPR_INIT (t
), args
, complain
, in_decl
, false);
11879 /* Expand a PACK of arguments into a grouped as left fold.
11880 Given a pack containing elements A0, A1, ..., An and an
11881 operator @, this builds the expression:
11883 ((A0 @ A1) @ A2) ... @ An
11885 Note that PACK must not be empty.
11887 The operator is defined by the original fold expression T. */
11890 expand_left_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11892 tree left
= TREE_VEC_ELT (pack
, 0);
11893 for (int i
= 1; i
< TREE_VEC_LENGTH (pack
); ++i
)
11895 tree right
= TREE_VEC_ELT (pack
, i
);
11896 left
= fold_expression (t
, left
, right
, complain
);
11901 /* Substitute into a unary left fold expression. */
11904 tsubst_unary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11907 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11908 if (pack
== error_mark_node
)
11909 return error_mark_node
;
11910 if (PACK_EXPANSION_P (pack
))
11912 tree r
= copy_node (t
);
11913 FOLD_EXPR_PACK (r
) = pack
;
11916 if (TREE_VEC_LENGTH (pack
) == 0)
11917 return expand_empty_fold (t
, complain
);
11919 return expand_left_fold (t
, pack
, complain
);
11922 /* Substitute into a binary left fold expression.
11924 Do ths by building a single (non-empty) vector of argumnts and
11925 building the expression from those elements. */
11928 tsubst_binary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11931 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11932 if (pack
== error_mark_node
)
11933 return error_mark_node
;
11934 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
11935 if (init
== error_mark_node
)
11936 return error_mark_node
;
11938 if (PACK_EXPANSION_P (pack
))
11940 tree r
= copy_node (t
);
11941 FOLD_EXPR_PACK (r
) = pack
;
11942 FOLD_EXPR_INIT (r
) = init
;
11946 tree vec
= make_tree_vec (TREE_VEC_LENGTH (pack
) + 1);
11947 TREE_VEC_ELT (vec
, 0) = init
;
11948 for (int i
= 0; i
< TREE_VEC_LENGTH (pack
); ++i
)
11949 TREE_VEC_ELT (vec
, i
+ 1) = TREE_VEC_ELT (pack
, i
);
11951 return expand_left_fold (t
, vec
, complain
);
11954 /* Expand a PACK of arguments into a grouped as right fold.
11955 Given a pack containing elementns A0, A1, ..., and an
11956 operator @, this builds the expression:
11958 A0@ ... (An-2 @ (An-1 @ An))
11960 Note that PACK must not be empty.
11962 The operator is defined by the original fold expression T. */
11965 expand_right_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11967 // Build the expression.
11968 int n
= TREE_VEC_LENGTH (pack
);
11969 tree right
= TREE_VEC_ELT (pack
, n
- 1);
11970 for (--n
; n
!= 0; --n
)
11972 tree left
= TREE_VEC_ELT (pack
, n
- 1);
11973 right
= fold_expression (t
, left
, right
, complain
);
11978 /* Substitute into a unary right fold expression. */
11981 tsubst_unary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
11984 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11985 if (pack
== error_mark_node
)
11986 return error_mark_node
;
11987 if (PACK_EXPANSION_P (pack
))
11989 tree r
= copy_node (t
);
11990 FOLD_EXPR_PACK (r
) = pack
;
11993 if (TREE_VEC_LENGTH (pack
) == 0)
11994 return expand_empty_fold (t
, complain
);
11996 return expand_right_fold (t
, pack
, complain
);
11999 /* Substitute into a binary right fold expression.
12001 Do ths by building a single (non-empty) vector of arguments and
12002 building the expression from those elements. */
12005 tsubst_binary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
12008 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
12009 if (pack
== error_mark_node
)
12010 return error_mark_node
;
12011 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
12012 if (init
== error_mark_node
)
12013 return error_mark_node
;
12015 if (PACK_EXPANSION_P (pack
))
12017 tree r
= copy_node (t
);
12018 FOLD_EXPR_PACK (r
) = pack
;
12019 FOLD_EXPR_INIT (r
) = init
;
12023 int n
= TREE_VEC_LENGTH (pack
);
12024 tree vec
= make_tree_vec (n
+ 1);
12025 for (int i
= 0; i
< n
; ++i
)
12026 TREE_VEC_ELT (vec
, i
) = TREE_VEC_ELT (pack
, i
);
12027 TREE_VEC_ELT (vec
, n
) = init
;
12029 return expand_right_fold (t
, vec
, complain
);
12032 /* Walk through the pattern of a pack expansion, adding everything in
12033 local_specializations to a list. */
12038 hash_set
<tree
> internal
;
12040 tsubst_flags_t complain
;
12042 el_data (tsubst_flags_t c
)
12043 : extra (NULL_TREE
), complain (c
) {}
12046 extract_locals_r (tree
*tp
, int */
*walk_subtrees*/
, void *data_
)
12048 el_data
&data
= *reinterpret_cast<el_data
*>(data_
);
12049 tree
*extra
= &data
.extra
;
12050 tsubst_flags_t complain
= data
.complain
;
12052 if (TYPE_P (*tp
) && typedef_variant_p (*tp
))
12053 /* Remember local typedefs (85214). */
12054 tp
= &TYPE_NAME (*tp
);
12056 if (TREE_CODE (*tp
) == DECL_EXPR
)
12057 data
.internal
.add (DECL_EXPR_DECL (*tp
));
12058 else if (tree spec
= retrieve_local_specialization (*tp
))
12060 if (data
.internal
.contains (*tp
))
12061 /* Don't mess with variables declared within the pattern. */
12063 if (TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
)
12065 /* Maybe pull out the PARM_DECL for a partial instantiation. */
12066 tree args
= ARGUMENT_PACK_ARGS (spec
);
12067 if (TREE_VEC_LENGTH (args
) == 1)
12069 tree elt
= TREE_VEC_ELT (args
, 0);
12070 if (PACK_EXPANSION_P (elt
))
12071 elt
= PACK_EXPANSION_PATTERN (elt
);
12072 if (DECL_PACK_P (elt
))
12075 if (TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
)
12077 /* Handle lambda capture here, since we aren't doing any
12078 substitution now, and so tsubst_copy won't call
12079 process_outer_var_ref. */
12080 tree args
= ARGUMENT_PACK_ARGS (spec
);
12081 int len
= TREE_VEC_LENGTH (args
);
12082 for (int i
= 0; i
< len
; ++i
)
12084 tree arg
= TREE_VEC_ELT (args
, i
);
12086 if (outer_automatic_var_p (arg
))
12087 carg
= process_outer_var_ref (arg
, complain
);
12090 /* Make a new NONTYPE_ARGUMENT_PACK of the capture
12094 spec
= copy_node (spec
);
12095 args
= copy_node (args
);
12096 SET_ARGUMENT_PACK_ARGS (spec
, args
);
12097 register_local_specialization (spec
, *tp
);
12099 TREE_VEC_ELT (args
, i
) = carg
;
12104 if (outer_automatic_var_p (spec
))
12105 spec
= process_outer_var_ref (spec
, complain
);
12106 *extra
= tree_cons (*tp
, spec
, *extra
);
12111 extract_local_specs (tree pattern
, tsubst_flags_t complain
)
12113 el_data
data (complain
);
12114 cp_walk_tree_without_duplicates (&pattern
, extract_locals_r
, &data
);
12118 /* Extract any uses of local_specializations from PATTERN and add them to ARGS
12119 for use in PACK_EXPANSION_EXTRA_ARGS. */
12122 build_extra_args (tree pattern
, tree args
, tsubst_flags_t complain
)
12125 if (local_specializations
)
12126 if (tree locals
= extract_local_specs (pattern
, complain
))
12127 extra
= tree_cons (NULL_TREE
, extra
, locals
);
12131 /* Apply any local specializations from PACK_EXPANSION_EXTRA_ARGS and add the
12132 normal template args to ARGS. */
12135 add_extra_args (tree extra
, tree args
)
12137 if (extra
&& TREE_CODE (extra
) == TREE_LIST
)
12139 for (tree elt
= TREE_CHAIN (extra
); elt
; elt
= TREE_CHAIN (elt
))
12141 /* The partial instantiation involved local declarations collected in
12142 extract_local_specs; map from the general template to our local
12144 tree gen
= TREE_PURPOSE (elt
);
12145 tree inst
= TREE_VALUE (elt
);
12147 if (tree local
= retrieve_local_specialization (inst
))
12149 /* else inst is already a full instantiation of the pack. */
12150 register_local_specialization (inst
, gen
);
12152 gcc_assert (!TREE_PURPOSE (extra
));
12153 extra
= TREE_VALUE (extra
);
12155 return add_to_template_args (extra
, args
);
12158 /* Substitute ARGS into T, which is an pack expansion
12159 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
12160 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
12161 (if only a partial substitution could be performed) or
12162 ERROR_MARK_NODE if there was an error. */
12164 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
12168 tree pack
, packs
= NULL_TREE
;
12169 bool unsubstituted_packs
= false;
12170 bool unsubstituted_fn_pack
= false;
12173 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
12174 bool need_local_specializations
= false;
12177 gcc_assert (PACK_EXPANSION_P (t
));
12178 pattern
= PACK_EXPANSION_PATTERN (t
);
12180 /* Add in any args remembered from an earlier partial instantiation. */
12181 args
= add_extra_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
12183 levels
= TMPL_ARGS_DEPTH (args
);
12185 /* Determine the argument packs that will instantiate the parameter
12186 packs used in the expansion expression. While we're at it,
12187 compute the number of arguments to be expanded and make sure it
12189 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
12190 pack
= TREE_CHAIN (pack
))
12192 tree parm_pack
= TREE_VALUE (pack
);
12193 tree arg_pack
= NULL_TREE
;
12194 tree orig_arg
= NULL_TREE
;
12197 if (TREE_CODE (parm_pack
) == BASES
)
12199 gcc_assert (parm_pack
== pattern
);
12200 if (BASES_DIRECT (parm_pack
))
12201 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
12206 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
12207 args
, complain
, in_decl
,
12210 else if (builtin_pack_call_p (parm_pack
))
12212 if (parm_pack
!= pattern
)
12214 if (complain
& tf_error
)
12215 sorry ("%qE is not the entire pattern of the pack expansion",
12217 return error_mark_node
;
12219 return expand_builtin_pack_call (parm_pack
, args
,
12220 complain
, in_decl
);
12222 else if (TREE_CODE (parm_pack
) == PARM_DECL
)
12224 /* We know we have correct local_specializations if this
12225 expansion is at function scope, or if we're dealing with a
12226 local parameter in a requires expression; for the latter,
12227 tsubst_requires_expr set it up appropriately. */
12228 if (PACK_EXPANSION_LOCAL_P (t
) || CONSTRAINT_VAR_P (parm_pack
))
12229 arg_pack
= retrieve_local_specialization (parm_pack
);
12231 /* We can't rely on local_specializations for a parameter
12232 name used later in a function declaration (such as in a
12233 late-specified return type). Even if it exists, it might
12234 have the wrong value for a recursive call. */
12235 need_local_specializations
= true;
12239 /* This parameter pack was used in an unevaluated context. Just
12240 make a dummy decl, since it's only used for its type. */
12241 ++cp_unevaluated_operand
;
12242 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
12243 --cp_unevaluated_operand
;
12244 if (arg_pack
&& DECL_PACK_P (arg_pack
))
12245 /* Partial instantiation of the parm_pack, we can't build
12246 up an argument pack yet. */
12247 arg_pack
= NULL_TREE
;
12249 arg_pack
= make_fnparm_pack (arg_pack
);
12251 else if (argument_pack_element_is_expansion_p (arg_pack
, 0))
12252 /* This argument pack isn't fully instantiated yet. We set this
12253 flag rather than clear arg_pack because we do want to do the
12254 optimization below, and we don't want to substitute directly
12255 into the pattern (as that would expose a NONTYPE_ARGUMENT_PACK
12256 where it isn't expected). */
12257 unsubstituted_fn_pack
= true;
12259 else if (is_capture_proxy (parm_pack
))
12261 arg_pack
= retrieve_local_specialization (parm_pack
);
12262 if (argument_pack_element_is_expansion_p (arg_pack
, 0))
12263 unsubstituted_fn_pack
= true;
12268 template_parm_level_and_index (parm_pack
, &level
, &idx
);
12270 if (level
<= levels
)
12271 arg_pack
= TMPL_ARG (args
, level
, idx
);
12274 orig_arg
= arg_pack
;
12275 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
12276 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
12278 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
12279 /* This can only happen if we forget to expand an argument
12280 pack somewhere else. Just return an error, silently. */
12282 result
= make_tree_vec (1);
12283 TREE_VEC_ELT (result
, 0) = error_mark_node
;
12290 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
12292 /* Don't bother trying to do a partial substitution with
12293 incomplete packs; we'll try again after deduction. */
12294 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
12299 else if (len
!= my_len
12300 && !unsubstituted_fn_pack
)
12302 if (!(complain
& tf_error
))
12303 /* Fail quietly. */;
12304 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
12305 error ("mismatched argument pack lengths while expanding %qT",
12308 error ("mismatched argument pack lengths while expanding %qE",
12310 return error_mark_node
;
12313 /* Keep track of the parameter packs and their corresponding
12315 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
12316 TREE_TYPE (packs
) = orig_arg
;
12320 /* We can't substitute for this parameter pack. We use a flag as
12321 well as the missing_level counter because function parameter
12322 packs don't have a level. */
12323 gcc_assert (processing_template_decl
|| is_auto (parm_pack
));
12324 unsubstituted_packs
= true;
12328 /* If the expansion is just T..., return the matching argument pack, unless
12329 we need to call convert_from_reference on all the elements. This is an
12330 important optimization; see c++/68422. */
12331 if (!unsubstituted_packs
12332 && TREE_PURPOSE (packs
) == pattern
)
12334 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
12336 /* If the argument pack is a single pack expansion, pull it out. */
12337 if (TREE_VEC_LENGTH (args
) == 1
12338 && pack_expansion_args_count (args
))
12339 return TREE_VEC_ELT (args
, 0);
12341 /* Types need no adjustment, nor does sizeof..., and if we still have
12342 some pack expansion args we won't do anything yet. */
12343 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
12344 || PACK_EXPANSION_SIZEOF_P (t
)
12345 || pack_expansion_args_count (args
))
12347 /* Also optimize expression pack expansions if we can tell that the
12348 elements won't have reference type. */
12349 tree type
= TREE_TYPE (pattern
);
12350 if (type
&& !TYPE_REF_P (type
)
12351 && !PACK_EXPANSION_P (type
)
12352 && !WILDCARD_TYPE_P (type
))
12354 /* Otherwise use the normal path so we get convert_from_reference. */
12357 /* We cannot expand this expansion expression, because we don't have
12358 all of the argument packs we need. */
12359 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
12361 /* We got some full packs, but we can't substitute them in until we
12362 have values for all the packs. So remember these until then. */
12364 t
= make_pack_expansion (pattern
, complain
);
12365 PACK_EXPANSION_EXTRA_ARGS (t
)
12366 = build_extra_args (pattern
, args
, complain
);
12369 else if (unsubstituted_packs
)
12371 /* There were no real arguments, we're just replacing a parameter
12372 pack with another version of itself. Substitute into the
12373 pattern and return a PACK_EXPANSION_*. The caller will need to
12375 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
12376 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
12377 /*integral_constant_expression_p=*/false);
12379 t
= tsubst (pattern
, args
, complain
, in_decl
);
12380 t
= make_pack_expansion (t
, complain
);
12384 gcc_assert (len
>= 0);
12386 if (need_local_specializations
)
12388 /* We're in a late-specified return type, so create our own local
12389 specializations map; the current map is either NULL or (in the
12390 case of recursive unification) might have bindings that we don't
12391 want to use or alter. */
12392 saved_local_specializations
= local_specializations
;
12393 local_specializations
= new hash_map
<tree
, tree
>;
12396 /* For each argument in each argument pack, substitute into the
12398 result
= make_tree_vec (len
);
12399 tree elem_args
= copy_template_args (args
);
12400 for (i
= 0; i
< len
; ++i
)
12402 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
12404 elem_args
, complain
,
12406 TREE_VEC_ELT (result
, i
) = t
;
12407 if (t
== error_mark_node
)
12409 result
= error_mark_node
;
12414 /* Update ARGS to restore the substitution from parameter packs to
12415 their argument packs. */
12416 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12418 tree parm
= TREE_PURPOSE (pack
);
12420 if (TREE_CODE (parm
) == PARM_DECL
12422 || TREE_CODE (parm
) == FIELD_DECL
)
12423 register_local_specialization (TREE_TYPE (pack
), parm
);
12428 if (TREE_VALUE (pack
) == NULL_TREE
)
12431 template_parm_level_and_index (parm
, &level
, &idx
);
12433 /* Update the corresponding argument. */
12434 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
12435 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
12438 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
12442 if (need_local_specializations
)
12444 delete local_specializations
;
12445 local_specializations
= saved_local_specializations
;
12448 /* If the dependent pack arguments were such that we end up with only a
12449 single pack expansion again, there's no need to keep it in a TREE_VEC. */
12450 if (len
== 1 && TREE_CODE (result
) == TREE_VEC
12451 && PACK_EXPANSION_P (TREE_VEC_ELT (result
, 0)))
12452 return TREE_VEC_ELT (result
, 0);
12457 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
12458 TMPL. We do this using DECL_PARM_INDEX, which should work even with
12459 parameter packs; all parms generated from a function parameter pack will
12460 have the same DECL_PARM_INDEX. */
12463 get_pattern_parm (tree parm
, tree tmpl
)
12465 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
12468 if (DECL_ARTIFICIAL (parm
))
12470 for (patparm
= DECL_ARGUMENTS (pattern
);
12471 patparm
; patparm
= DECL_CHAIN (patparm
))
12472 if (DECL_ARTIFICIAL (patparm
)
12473 && DECL_NAME (parm
) == DECL_NAME (patparm
))
12478 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
12479 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
12480 gcc_assert (DECL_PARM_INDEX (patparm
)
12481 == DECL_PARM_INDEX (parm
));
12487 /* Make an argument pack out of the TREE_VEC VEC. */
12490 make_argument_pack (tree vec
)
12493 tree elt
= TREE_VEC_ELT (vec
, 0);
12495 pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
12498 pack
= make_node (NONTYPE_ARGUMENT_PACK
);
12499 TREE_CONSTANT (pack
) = 1;
12501 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
12505 /* Return an exact copy of template args T that can be modified
12509 copy_template_args (tree t
)
12511 if (t
== error_mark_node
)
12514 int len
= TREE_VEC_LENGTH (t
);
12515 tree new_vec
= make_tree_vec (len
);
12517 for (int i
= 0; i
< len
; ++i
)
12519 tree elt
= TREE_VEC_ELT (t
, i
);
12520 if (elt
&& TREE_CODE (elt
) == TREE_VEC
)
12521 elt
= copy_template_args (elt
);
12522 TREE_VEC_ELT (new_vec
, i
) = elt
;
12525 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_vec
)
12526 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
12531 /* Substitute ARGS into the vector or list of template arguments T. */
12534 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12537 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
12540 if (t
== error_mark_node
)
12541 return error_mark_node
;
12543 len
= TREE_VEC_LENGTH (t
);
12544 elts
= XALLOCAVEC (tree
, len
);
12546 for (i
= 0; i
< len
; i
++)
12548 tree orig_arg
= TREE_VEC_ELT (t
, i
);
12551 if (TREE_CODE (orig_arg
) == TREE_VEC
)
12552 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
12553 else if (PACK_EXPANSION_P (orig_arg
))
12555 /* Substitute into an expansion expression. */
12556 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
12558 if (TREE_CODE (new_arg
) == TREE_VEC
)
12559 /* Add to the expanded length adjustment the number of
12560 expanded arguments. We subtract one from this
12561 measurement, because the argument pack expression
12562 itself is already counted as 1 in
12563 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
12564 the argument pack is empty. */
12565 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
12567 else if (ARGUMENT_PACK_P (orig_arg
))
12569 /* Substitute into each of the arguments. */
12570 new_arg
= TYPE_P (orig_arg
)
12571 ? cxx_make_type (TREE_CODE (orig_arg
))
12572 : make_node (TREE_CODE (orig_arg
));
12574 tree pack_args
= tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
12575 args
, complain
, in_decl
);
12576 if (pack_args
== error_mark_node
)
12577 new_arg
= error_mark_node
;
12579 SET_ARGUMENT_PACK_ARGS (new_arg
, pack_args
);
12581 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
)
12582 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
12585 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
12587 if (new_arg
== error_mark_node
)
12588 return error_mark_node
;
12591 if (new_arg
!= orig_arg
)
12598 /* Make space for the expanded arguments coming from template
12600 t
= make_tree_vec (len
+ expanded_len_adjust
);
12601 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
12602 arguments for a member template.
12603 In that case each TREE_VEC in ORIG_T represents a level of template
12604 arguments, and ORIG_T won't carry any non defaulted argument count.
12605 It will rather be the nested TREE_VECs that will carry one.
12606 In other words, ORIG_T carries a non defaulted argument count only
12607 if it doesn't contain any nested TREE_VEC. */
12608 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
12610 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
12611 count
+= expanded_len_adjust
;
12612 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
12614 for (i
= 0, out
= 0; i
< len
; i
++)
12616 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
12617 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
12618 && TREE_CODE (elts
[i
]) == TREE_VEC
)
12622 /* Now expand the template argument pack "in place". */
12623 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
12624 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
12628 TREE_VEC_ELT (t
, out
) = elts
[i
];
12636 /* Substitute ARGS into one level PARMS of template parameters. */
12639 tsubst_template_parms_level (tree parms
, tree args
, tsubst_flags_t complain
)
12641 if (parms
== error_mark_node
)
12642 return error_mark_node
;
12644 tree new_vec
= make_tree_vec (TREE_VEC_LENGTH (parms
));
12646 for (int i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
12648 tree tuple
= TREE_VEC_ELT (parms
, i
);
12650 if (tuple
== error_mark_node
)
12653 TREE_VEC_ELT (new_vec
, i
) =
12654 tsubst_template_parm (tuple
, args
, complain
);
12660 /* Return the result of substituting ARGS into the template parameters
12661 given by PARMS. If there are m levels of ARGS and m + n levels of
12662 PARMS, then the result will contain n levels of PARMS. For
12663 example, if PARMS is `template <class T> template <class U>
12664 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
12665 result will be `template <int*, double, class V>'. */
12668 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
12670 tree r
= NULL_TREE
;
12673 /* When substituting into a template, we must set
12674 PROCESSING_TEMPLATE_DECL as the template parameters may be
12675 dependent if they are based on one-another, and the dependency
12676 predicates are short-circuit outside of templates. */
12677 ++processing_template_decl
;
12679 for (new_parms
= &r
;
12680 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
12681 new_parms
= &(TREE_CHAIN (*new_parms
)),
12682 parms
= TREE_CHAIN (parms
))
12684 tree new_vec
= tsubst_template_parms_level (TREE_VALUE (parms
),
12687 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
12688 - TMPL_ARGS_DEPTH (args
)),
12689 new_vec
, NULL_TREE
);
12692 --processing_template_decl
;
12697 /* Return the result of substituting ARGS into one template parameter
12698 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
12699 parameter and which TREE_PURPOSE is the default argument of the
12700 template parameter. */
12703 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
12705 tree default_value
, parm_decl
;
12707 if (args
== NULL_TREE
12709 || t
== error_mark_node
)
12712 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
12714 default_value
= TREE_PURPOSE (t
);
12715 parm_decl
= TREE_VALUE (t
);
12717 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
12718 if (TREE_CODE (parm_decl
) == PARM_DECL
12719 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
12720 parm_decl
= error_mark_node
;
12721 default_value
= tsubst_template_arg (default_value
, args
,
12722 complain
, NULL_TREE
);
12724 return build_tree_list (default_value
, parm_decl
);
12727 /* Substitute the ARGS into the indicated aggregate (or enumeration)
12728 type T. If T is not an aggregate or enumeration type, it is
12729 handled as if by tsubst. IN_DECL is as for tsubst. If
12730 ENTERING_SCOPE is nonzero, T is the context for a template which
12731 we are presently tsubst'ing. Return the substituted value. */
12734 tsubst_aggr_type (tree t
,
12736 tsubst_flags_t complain
,
12738 int entering_scope
)
12740 if (t
== NULL_TREE
)
12743 switch (TREE_CODE (t
))
12746 if (TYPE_PTRMEMFUNC_P (t
))
12747 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
12749 /* Fall through. */
12750 case ENUMERAL_TYPE
:
12752 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
12758 /* In "sizeof(X<I>)" we need to evaluate "I". */
12761 /* First, determine the context for the type we are looking
12763 context
= TYPE_CONTEXT (t
);
12764 if (context
&& TYPE_P (context
))
12766 context
= tsubst_aggr_type (context
, args
, complain
,
12767 in_decl
, /*entering_scope=*/1);
12768 /* If context is a nested class inside a class template,
12769 it may still need to be instantiated (c++/33959). */
12770 context
= complete_type (context
);
12773 /* Then, figure out what arguments are appropriate for the
12774 type we are trying to find. For example, given:
12776 template <class T> struct S;
12777 template <class T, class U> void f(T, U) { S<U> su; }
12779 and supposing that we are instantiating f<int, double>,
12780 then our ARGS will be {int, double}, but, when looking up
12781 S we only want {double}. */
12782 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
12783 complain
, in_decl
);
12784 if (argvec
== error_mark_node
)
12785 r
= error_mark_node
;
12788 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
12789 entering_scope
, complain
);
12790 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12796 /* This is not a template type, so there's nothing to do. */
12800 return tsubst (t
, args
, complain
, in_decl
);
12804 static GTY((cache
)) tree_cache_map
*defarg_inst
;
12806 /* Substitute into the default argument ARG (a default argument for
12807 FN), which has the indicated TYPE. */
12810 tsubst_default_argument (tree fn
, int parmnum
, tree type
, tree arg
,
12811 tsubst_flags_t complain
)
12813 int errs
= errorcount
+ sorrycount
;
12815 /* This can happen in invalid code. */
12816 if (TREE_CODE (arg
) == DEFERRED_PARSE
)
12819 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
12820 parm
= chain_index (parmnum
, parm
);
12821 tree parmtype
= TREE_TYPE (parm
);
12822 if (DECL_BY_REFERENCE (parm
))
12823 parmtype
= TREE_TYPE (parmtype
);
12824 if (parmtype
== error_mark_node
)
12825 return error_mark_node
;
12827 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, parmtype
));
12830 if (defarg_inst
&& (slot
= defarg_inst
->get (parm
)))
12833 /* This default argument came from a template. Instantiate the
12834 default argument here, not in tsubst. In the case of
12843 we must be careful to do name lookup in the scope of S<T>,
12844 rather than in the current class. */
12845 push_to_top_level ();
12846 push_access_scope (fn
);
12847 push_deferring_access_checks (dk_no_deferred
);
12848 start_lambda_scope (parm
);
12850 /* The default argument expression may cause implicitly defined
12851 member functions to be synthesized, which will result in garbage
12852 collection. We must treat this situation as if we were within
12853 the body of function so as to avoid collecting live data on the
12856 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
12857 complain
, NULL_TREE
,
12858 /*integral_constant_expression_p=*/false);
12861 finish_lambda_scope ();
12863 /* Make sure the default argument is reasonable. */
12864 arg
= check_default_argument (type
, arg
, complain
);
12866 if (errorcount
+sorrycount
> errs
12867 && (complain
& tf_warning_or_error
))
12868 inform (input_location
,
12869 " when instantiating default argument for call to %qD", fn
);
12871 pop_deferring_access_checks ();
12872 pop_access_scope (fn
);
12873 pop_from_top_level ();
12875 if (arg
!= error_mark_node
&& !cp_unevaluated_operand
)
12878 defarg_inst
= tree_cache_map::create_ggc (37);
12879 defarg_inst
->put (parm
, arg
);
12885 /* Substitute into all the default arguments for FN. */
12888 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
12893 tmpl_args
= DECL_TI_ARGS (fn
);
12895 /* If this function is not yet instantiated, we certainly don't need
12896 its default arguments. */
12897 if (uses_template_parms (tmpl_args
))
12899 /* Don't do this again for clones. */
12900 if (DECL_CLONED_FUNCTION_P (fn
))
12904 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
12906 arg
= TREE_CHAIN (arg
), ++i
)
12907 if (TREE_PURPOSE (arg
))
12908 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
, i
,
12910 TREE_PURPOSE (arg
),
12914 /* Hash table mapping a FUNCTION_DECL to its dependent explicit-specifier. */
12915 static GTY((cache
)) tree_cache_map
*explicit_specifier_map
;
12917 /* Store a pair to EXPLICIT_SPECIFIER_MAP. */
12920 store_explicit_specifier (tree v
, tree t
)
12922 if (!explicit_specifier_map
)
12923 explicit_specifier_map
= tree_cache_map::create_ggc (37);
12924 DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (v
) = true;
12925 explicit_specifier_map
->put (v
, t
);
12928 /* Lookup an element in EXPLICIT_SPECIFIER_MAP. */
12931 lookup_explicit_specifier (tree v
)
12933 return *explicit_specifier_map
->get (v
);
12936 /* Subroutine of tsubst_decl for the case when T is a FUNCTION_DECL. */
12939 tsubst_function_decl (tree t
, tree args
, tsubst_flags_t complain
,
12940 tree lambda_fntype
)
12942 tree gen_tmpl
, argvec
;
12943 hashval_t hash
= 0;
12946 /* Nobody should be tsubst'ing into non-template functions. */
12947 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
12949 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
12951 /* If T is not dependent, just return it. */
12952 if (!uses_template_parms (DECL_TI_ARGS (t
))
12953 && !LAMBDA_FUNCTION_P (t
))
12956 /* Calculate the most general template of which R is a
12958 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
12960 /* We're substituting a lambda function under tsubst_lambda_expr but not
12961 directly from it; find the matching function we're already inside.
12962 But don't do this if T is a generic lambda with a single level of
12963 template parms, as in that case we're doing a normal instantiation. */
12964 if (LAMBDA_FUNCTION_P (t
) && !lambda_fntype
12965 && (!generic_lambda_fn_p (t
)
12966 || TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
)) > 1))
12967 return enclosing_instantiation_of (t
);
12969 /* Calculate the complete set of arguments used to
12971 argvec
= tsubst_template_args (DECL_TI_ARGS
12972 (DECL_TEMPLATE_RESULT
12973 (DECL_TI_TEMPLATE (t
))),
12974 args
, complain
, in_decl
);
12975 if (argvec
== error_mark_node
)
12976 return error_mark_node
;
12978 /* Check to see if we already have this specialization. */
12979 if (!lambda_fntype
)
12981 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
12982 if (tree spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
))
12986 /* We can see more levels of arguments than parameters if
12987 there was a specialization of a member template, like
12990 template <class T> struct S { template <class U> void f(); }
12991 template <> template <class U> void S<int>::f(U);
12993 Here, we'll be substituting into the specialization,
12994 because that's where we can find the code we actually
12995 want to generate, but we'll have enough arguments for
12996 the most general template.
12998 We also deal with the peculiar case:
13000 template <class T> struct S {
13001 template <class U> friend void f();
13003 template <class U> void f() {}
13005 template void f<double>();
13007 Here, the ARGS for the instantiation of will be {int,
13008 double}. But, we only need as many ARGS as there are
13009 levels of template parameters in CODE_PATTERN. We are
13010 careful not to get fooled into reducing the ARGS in
13013 template <class T> struct S { template <class U> void f(U); }
13014 template <class T> template <> void S<T>::f(int) {}
13016 which we can spot because the pattern will be a
13017 specialization in this case. */
13018 int args_depth
= TMPL_ARGS_DEPTH (args
);
13020 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
13022 if (args_depth
> parms_depth
&& !DECL_TEMPLATE_SPECIALIZATION (t
))
13023 args
= get_innermost_template_args (args
, parms_depth
);
13027 /* This special case arises when we have something like this:
13029 template <class T> struct S {
13030 friend void f<int>(int, double);
13033 Here, the DECL_TI_TEMPLATE for the friend declaration
13034 will be an IDENTIFIER_NODE. We are being called from
13035 tsubst_friend_function, and we want only to create a
13036 new decl (R) with appropriate types so that we can call
13037 determine_specialization. */
13038 gen_tmpl
= NULL_TREE
;
13039 argvec
= NULL_TREE
;
13042 tree closure
= (lambda_fntype
? TYPE_METHOD_BASETYPE (lambda_fntype
)
13044 tree ctx
= closure
? closure
: DECL_CONTEXT (t
);
13045 bool member
= ctx
&& TYPE_P (ctx
);
13047 if (member
&& !closure
)
13048 ctx
= tsubst_aggr_type (ctx
, args
,
13049 complain
, t
, /*entering_scope=*/1);
13051 tree type
= (lambda_fntype
? lambda_fntype
13052 : tsubst (TREE_TYPE (t
), args
,
13053 complain
| tf_fndecl_type
, in_decl
));
13054 if (type
== error_mark_node
)
13055 return error_mark_node
;
13057 /* If we hit excessive deduction depth, the type is bogus even if
13058 it isn't error_mark_node, so don't build a decl. */
13059 if (excessive_deduction_depth
)
13060 return error_mark_node
;
13062 /* We do NOT check for matching decls pushed separately at this
13063 point, as they may not represent instantiations of this
13064 template, and in any case are considered separate under the
13066 tree r
= copy_decl (t
);
13067 DECL_USE_TEMPLATE (r
) = 0;
13068 TREE_TYPE (r
) = type
;
13069 /* Clear out the mangled name and RTL for the instantiation. */
13070 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
13071 SET_DECL_RTL (r
, NULL
);
13072 /* Leave DECL_INITIAL set on deleted instantiations. */
13073 if (!DECL_DELETED_FN (r
))
13074 DECL_INITIAL (r
) = NULL_TREE
;
13075 DECL_CONTEXT (r
) = ctx
;
13077 /* Handle explicit(dependent-expr). */
13078 if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t
))
13080 tree spec
= lookup_explicit_specifier (t
);
13081 spec
= tsubst_copy_and_build (spec
, args
, complain
, in_decl
,
13082 /*function_p=*/false,
13084 spec
= build_explicit_specifier (spec
, complain
);
13085 DECL_NONCONVERTING_P (r
) = (spec
== boolean_true_node
);
13088 /* OpenMP UDRs have the only argument a reference to the declared
13089 type. We want to diagnose if the declared type is a reference,
13090 which is invalid, but as references to references are usually
13091 quietly merged, diagnose it here. */
13092 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
13095 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
13096 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
13097 if (TYPE_REF_P (argtype
))
13098 error_at (DECL_SOURCE_LOCATION (t
),
13099 "reference type %qT in "
13100 "%<#pragma omp declare reduction%>", argtype
);
13101 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
13102 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
13106 if (member
&& DECL_CONV_FN_P (r
))
13107 /* Type-conversion operator. Reconstruct the name, in
13108 case it's the name of one of the template's parameters. */
13109 DECL_NAME (r
) = make_conv_op_name (TREE_TYPE (type
));
13111 tree parms
= DECL_ARGUMENTS (t
);
13113 parms
= DECL_CHAIN (parms
);
13114 parms
= tsubst (parms
, args
, complain
, t
);
13115 for (tree parm
= parms
; parm
; parm
= DECL_CHAIN (parm
))
13116 DECL_CONTEXT (parm
) = r
;
13119 tree tparm
= build_this_parm (r
, closure
, type_memfn_quals (type
));
13120 DECL_CHAIN (tparm
) = parms
;
13123 DECL_ARGUMENTS (r
) = parms
;
13124 DECL_RESULT (r
) = NULL_TREE
;
13126 TREE_STATIC (r
) = 0;
13127 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
13128 DECL_EXTERNAL (r
) = 1;
13129 /* If this is an instantiation of a function with internal
13130 linkage, we already know what object file linkage will be
13131 assigned to the instantiation. */
13132 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
13133 DECL_DEFER_OUTPUT (r
) = 0;
13134 DECL_CHAIN (r
) = NULL_TREE
;
13135 DECL_PENDING_INLINE_INFO (r
) = 0;
13136 DECL_PENDING_INLINE_P (r
) = 0;
13137 DECL_SAVED_TREE (r
) = NULL_TREE
;
13138 DECL_STRUCT_FUNCTION (r
) = NULL
;
13140 /* We'll re-clone as appropriate in instantiate_template. */
13141 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
13143 /* If we aren't complaining now, return on error before we register
13144 the specialization so that we'll complain eventually. */
13145 if ((complain
& tf_error
) == 0
13146 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
13147 && !grok_op_properties (r
, /*complain=*/false))
13148 return error_mark_node
;
13150 /* When instantiating a constrained member, substitute
13151 into the constraints to create a new constraint. */
13152 if (tree ci
= get_constraints (t
))
13155 ci
= tsubst_constraint_info (ci
, argvec
, complain
, NULL_TREE
);
13156 set_constraints (r
, ci
);
13159 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
13160 SET_DECL_FRIEND_CONTEXT (r
,
13161 tsubst (DECL_FRIEND_CONTEXT (t
),
13162 args
, complain
, in_decl
));
13164 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
13165 this in the special friend case mentioned above where
13166 GEN_TMPL is NULL. */
13167 if (gen_tmpl
&& !closure
)
13169 DECL_TEMPLATE_INFO (r
)
13170 = build_template_info (gen_tmpl
, argvec
);
13171 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13174 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
13176 /* We instantiated this while substituting into
13177 the type earlier (template/friend54.C). */
13180 /* We're not supposed to instantiate default arguments
13181 until they are called, for a template. But, for a
13184 template <class T> void f ()
13185 { extern void g(int i = T()); }
13187 we should do the substitution when the template is
13188 instantiated. We handle the member function case in
13189 instantiate_class_template since the default arguments
13190 might refer to other members of the class. */
13192 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
13193 && !uses_template_parms (argvec
))
13194 tsubst_default_arguments (r
, complain
);
13197 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13199 /* Copy the list of befriending classes. */
13200 for (tree
*friends
= &DECL_BEFRIENDING_CLASSES (r
);
13202 friends
= &TREE_CHAIN (*friends
))
13204 *friends
= copy_node (*friends
);
13205 TREE_VALUE (*friends
)
13206 = tsubst (TREE_VALUE (*friends
), args
, complain
, in_decl
);
13209 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
13211 maybe_retrofit_in_chrg (r
);
13212 if (DECL_CONSTRUCTOR_P (r
) && !grok_ctor_properties (ctx
, r
))
13213 return error_mark_node
;
13214 /* If this is an instantiation of a member template, clone it.
13215 If it isn't, that'll be handled by
13216 clone_constructors_and_destructors. */
13217 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
13218 clone_function_decl (r
, /*update_methods=*/false);
13220 else if ((complain
& tf_error
) != 0
13221 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
13222 && !grok_op_properties (r
, /*complain=*/true))
13223 return error_mark_node
;
13225 /* Possibly limit visibility based on template args. */
13226 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
13227 if (DECL_VISIBILITY_SPECIFIED (t
))
13229 DECL_VISIBILITY_SPECIFIED (r
) = 0;
13230 DECL_ATTRIBUTES (r
)
13231 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
13233 determine_visibility (r
);
13234 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
13235 && !processing_template_decl
)
13236 defaulted_late_check (r
);
13238 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
13239 args
, complain
, in_decl
);
13243 /* Subroutine of tsubst_decl for the case when T is a TEMPLATE_DECL. */
13246 tsubst_template_decl (tree t
, tree args
, tsubst_flags_t complain
,
13247 tree lambda_fntype
)
13249 /* We can get here when processing a member function template,
13250 member class template, or template template parameter. */
13251 tree decl
= DECL_TEMPLATE_RESULT (t
);
13257 hashval_t hash
= 0;
13259 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
13261 /* Template template parameter is treated here. */
13262 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13263 if (new_type
== error_mark_node
)
13264 r
= error_mark_node
;
13265 /* If we get a real template back, return it. This can happen in
13266 the context of most_specialized_partial_spec. */
13267 else if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
13270 /* The new TEMPLATE_DECL was built in
13271 reduce_template_parm_level. */
13272 r
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (new_type
);
13276 if (!lambda_fntype
)
13278 /* We might already have an instance of this template.
13279 The ARGS are for the surrounding class type, so the
13280 full args contain the tsubst'd args for the context,
13281 plus the innermost args from the template decl. */
13282 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
13283 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
13284 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
13285 /* Because this is a template, the arguments will still be
13286 dependent, even after substitution. If
13287 PROCESSING_TEMPLATE_DECL is not set, the dependency
13288 predicates will short-circuit. */
13289 ++processing_template_decl
;
13290 full_args
= tsubst_template_args (tmpl_args
, args
,
13291 complain
, in_decl
);
13292 --processing_template_decl
;
13293 if (full_args
== error_mark_node
)
13294 return error_mark_node
;
13296 /* If this is a default template template argument,
13297 tsubst might not have changed anything. */
13298 if (full_args
== tmpl_args
)
13301 hash
= hash_tmpl_and_args (t
, full_args
);
13302 spec
= retrieve_specialization (t
, full_args
, hash
);
13303 if (spec
!= NULL_TREE
)
13306 /* Type partial instantiations are stored as the type by
13307 lookup_template_class_1, not here as the template. */
13308 spec
= CLASSTYPE_TI_TEMPLATE (spec
);
13313 /* Make a new template decl. It will be similar to the
13314 original, but will record the current template arguments.
13315 We also create a new function declaration, which is just
13316 like the old one, but points to this new template, rather
13317 than the old one. */
13319 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
13320 DECL_CHAIN (r
) = NULL_TREE
;
13322 // Build new template info linking to the original template decl.
13323 if (!lambda_fntype
)
13325 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
13326 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13329 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13331 /* The template parameters for this new template are all the
13332 template parameters for the old template, except the
13333 outermost level of parameters. */
13334 DECL_TEMPLATE_PARMS (r
)
13335 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
13338 if (TREE_CODE (decl
) == TYPE_DECL
13339 && !TYPE_DECL_ALIAS_P (decl
))
13342 ++processing_template_decl
;
13343 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13344 --processing_template_decl
;
13345 if (new_type
== error_mark_node
)
13346 return error_mark_node
;
13348 TREE_TYPE (r
) = new_type
;
13349 /* For a partial specialization, we need to keep pointing to
13350 the primary template. */
13351 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
13352 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
13353 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
13354 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
13355 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
13360 ++processing_template_decl
;
13361 if (TREE_CODE (decl
) == FUNCTION_DECL
)
13362 new_decl
= tsubst_function_decl (decl
, args
, complain
, lambda_fntype
);
13364 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
13365 --processing_template_decl
;
13366 if (new_decl
== error_mark_node
)
13367 return error_mark_node
;
13369 DECL_TEMPLATE_RESULT (r
) = new_decl
;
13370 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
13371 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
13374 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (r
));
13375 DECL_TEMPLATE_INFO (new_decl
) = build_template_info (r
, args
);
13379 DECL_TI_TEMPLATE (new_decl
) = r
;
13380 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
13384 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
13385 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
13387 if (PRIMARY_TEMPLATE_P (t
))
13388 DECL_PRIMARY_TEMPLATE (r
) = r
;
13390 if (TREE_CODE (decl
) != TYPE_DECL
&& !VAR_P (decl
)
13392 /* Record this non-type partial instantiation. */
13393 register_specialization (r
, t
,
13394 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
13400 /* True if FN is the op() for a lambda in an uninstantiated template. */
13403 lambda_fn_in_template_p (tree fn
)
13405 if (!fn
|| !LAMBDA_FUNCTION_P (fn
))
13407 tree closure
= DECL_CONTEXT (fn
);
13408 return CLASSTYPE_TEMPLATE_INFO (closure
) != NULL_TREE
;
13411 /* True if FN is the substitution (via tsubst_lambda_expr) of a function for
13412 which the above is true. */
13415 instantiated_lambda_fn_p (tree fn
)
13417 if (!fn
|| !LAMBDA_FUNCTION_P (fn
))
13419 tree closure
= DECL_CONTEXT (fn
);
13420 tree lam
= CLASSTYPE_LAMBDA_EXPR (closure
);
13421 return LAMBDA_EXPR_INSTANTIATED (lam
);
13424 /* We're instantiating a variable from template function TCTX. Return the
13425 corresponding current enclosing scope. This gets complicated because lambda
13426 functions in templates are regenerated rather than instantiated, but generic
13427 lambda functions are subsequently instantiated. */
13430 enclosing_instantiation_of (tree otctx
)
13433 tree fn
= current_function_decl
;
13434 int lambda_count
= 0;
13436 for (; tctx
&& (lambda_fn_in_template_p (tctx
)
13437 || instantiated_lambda_fn_p (tctx
));
13438 tctx
= decl_function_context (tctx
))
13440 for (; fn
; fn
= decl_function_context (fn
))
13443 int flambda_count
= 0;
13444 for (; fn
&& instantiated_lambda_fn_p (fn
);
13445 fn
= decl_function_context (fn
))
13447 if ((fn
&& DECL_TEMPLATE_INFO (fn
))
13448 ? most_general_template (fn
) != most_general_template (tctx
)
13451 if (flambda_count
!= lambda_count
)
13453 gcc_assert (flambda_count
> lambda_count
);
13454 for (; flambda_count
> lambda_count
; --flambda_count
)
13455 ofn
= decl_function_context (ofn
);
13457 gcc_assert (DECL_NAME (ofn
) == DECL_NAME (otctx
)
13458 || DECL_CONV_FN_P (ofn
));
13461 gcc_unreachable ();
13464 /* Substitute the ARGS into the T, which is a _DECL. Return the
13465 result of the substitution. Issue error and warning messages under
13466 control of COMPLAIN. */
13469 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
13471 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13472 location_t saved_loc
;
13473 tree r
= NULL_TREE
;
13475 hashval_t hash
= 0;
13477 /* Set the filename and linenumber to improve error-reporting. */
13478 saved_loc
= input_location
;
13479 input_location
= DECL_SOURCE_LOCATION (t
);
13481 switch (TREE_CODE (t
))
13483 case TEMPLATE_DECL
:
13484 r
= tsubst_template_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
13487 case FUNCTION_DECL
:
13488 r
= tsubst_function_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
13493 tree type
= NULL_TREE
;
13495 tree expanded_types
= NULL_TREE
;
13496 tree prev_r
= NULL_TREE
;
13497 tree first_r
= NULL_TREE
;
13499 if (DECL_PACK_P (t
))
13501 /* If there is a local specialization that isn't a
13502 parameter pack, it means that we're doing a "simple"
13503 substitution from inside tsubst_pack_expansion. Just
13504 return the local specialization (which will be a single
13506 tree spec
= retrieve_local_specialization (t
);
13508 && TREE_CODE (spec
) == PARM_DECL
13509 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
13512 /* Expand the TYPE_PACK_EXPANSION that provides the types for
13513 the parameters in this function parameter pack. */
13514 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
13515 complain
, in_decl
);
13516 if (TREE_CODE (expanded_types
) == TREE_VEC
)
13518 len
= TREE_VEC_LENGTH (expanded_types
);
13520 /* Zero-length parameter packs are boring. Just substitute
13523 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
13528 /* All we did was update the type. Make a note of that. */
13529 type
= expanded_types
;
13530 expanded_types
= NULL_TREE
;
13534 /* Loop through all of the parameters we'll build. When T is
13535 a function parameter pack, LEN is the number of expanded
13536 types in EXPANDED_TYPES; otherwise, LEN is 1. */
13538 for (i
= 0; i
< len
; ++i
)
13542 if (DECL_TEMPLATE_PARM_P (t
))
13543 SET_DECL_TEMPLATE_PARM_P (r
);
13545 if (expanded_types
)
13546 /* We're on the Ith parameter of the function parameter
13549 /* Get the Ith type. */
13550 type
= TREE_VEC_ELT (expanded_types
, i
);
13552 /* Rename the parameter to include the index. */
13554 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
13557 /* We're dealing with a normal parameter. */
13558 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13560 type
= type_decays_to (type
);
13561 TREE_TYPE (r
) = type
;
13562 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13564 if (DECL_INITIAL (r
))
13566 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
13567 DECL_INITIAL (r
) = TREE_TYPE (r
);
13569 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
13570 complain
, in_decl
);
13573 DECL_CONTEXT (r
) = NULL_TREE
;
13575 if (!DECL_TEMPLATE_PARM_P (r
))
13576 DECL_ARG_TYPE (r
) = type_passed_as (type
);
13578 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
13579 args
, complain
, in_decl
);
13581 /* Keep track of the first new parameter we
13582 generate. That's what will be returned to the
13587 /* Build a proper chain of parameters when substituting
13588 into a function parameter pack. */
13590 DECL_CHAIN (prev_r
) = r
;
13593 /* If cp_unevaluated_operand is set, we're just looking for a
13594 single dummy parameter, so don't keep going. */
13595 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
13596 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
13597 complain
, DECL_CHAIN (t
));
13599 /* FIRST_R contains the start of the chain we've built. */
13606 tree type
= NULL_TREE
;
13607 tree vec
= NULL_TREE
;
13608 tree expanded_types
= NULL_TREE
;
13611 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
13613 /* This field is a lambda capture pack. Return a TREE_VEC of
13614 the expanded fields to instantiate_class_template_1. */
13615 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
13616 complain
, in_decl
);
13617 if (TREE_CODE (expanded_types
) == TREE_VEC
)
13619 len
= TREE_VEC_LENGTH (expanded_types
);
13620 vec
= make_tree_vec (len
);
13624 /* All we did was update the type. Make a note of that. */
13625 type
= expanded_types
;
13626 expanded_types
= NULL_TREE
;
13630 for (int i
= 0; i
< len
; ++i
)
13633 if (expanded_types
)
13635 type
= TREE_VEC_ELT (expanded_types
, i
);
13637 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
13640 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13642 if (type
== error_mark_node
)
13643 RETURN (error_mark_node
);
13644 TREE_TYPE (r
) = type
;
13645 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13647 if (DECL_C_BIT_FIELD (r
))
13648 /* For bit-fields, DECL_BIT_FIELD_REPRESENTATIVE gives the
13650 DECL_BIT_FIELD_REPRESENTATIVE (r
)
13651 = tsubst_expr (DECL_BIT_FIELD_REPRESENTATIVE (t
), args
,
13653 /*integral_constant_expression_p=*/true);
13654 if (DECL_INITIAL (t
))
13656 /* Set up DECL_TEMPLATE_INFO so that we can get at the
13657 NSDMI in perform_member_init. Still set DECL_INITIAL
13658 so that we know there is one. */
13659 DECL_INITIAL (r
) = void_node
;
13660 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
13661 retrofit_lang_decl (r
);
13662 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
13664 /* We don't have to set DECL_CONTEXT here; it is set by
13665 finish_member_declaration. */
13666 DECL_CHAIN (r
) = NULL_TREE
;
13668 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
13669 args
, complain
, in_decl
);
13672 TREE_VEC_ELT (vec
, i
) = r
;
13681 /* We reach here only for member using decls. We also need to check
13682 uses_template_parms because DECL_DEPENDENT_P is not set for a
13683 using-declaration that designates a member of the current
13684 instantiation (c++/53549). */
13685 if (DECL_DEPENDENT_P (t
)
13686 || uses_template_parms (USING_DECL_SCOPE (t
)))
13688 tree scope
= USING_DECL_SCOPE (t
);
13689 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
13690 if (PACK_EXPANSION_P (scope
))
13692 tree vec
= tsubst_pack_expansion (scope
, args
, complain
, in_decl
);
13693 int len
= TREE_VEC_LENGTH (vec
);
13694 r
= make_tree_vec (len
);
13695 for (int i
= 0; i
< len
; ++i
)
13697 tree escope
= TREE_VEC_ELT (vec
, i
);
13698 tree elt
= do_class_using_decl (escope
, name
);
13701 r
= error_mark_node
;
13706 TREE_PROTECTED (elt
) = TREE_PROTECTED (t
);
13707 TREE_PRIVATE (elt
) = TREE_PRIVATE (t
);
13709 TREE_VEC_ELT (r
, i
) = elt
;
13714 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
13715 complain
, in_decl
);
13716 r
= do_class_using_decl (inst_scope
, name
);
13718 r
= error_mark_node
;
13721 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
13722 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
13729 DECL_CHAIN (r
) = NULL_TREE
;
13736 tree argvec
= NULL_TREE
;
13737 tree gen_tmpl
= NULL_TREE
;
13739 tree tmpl
= NULL_TREE
;
13741 tree type
= NULL_TREE
;
13744 if (TREE_TYPE (t
) == error_mark_node
)
13745 RETURN (error_mark_node
);
13747 if (TREE_CODE (t
) == TYPE_DECL
13748 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
13750 /* If this is the canonical decl, we don't have to
13751 mess with instantiations, and often we can't (for
13752 typename, template type parms and such). Note that
13753 TYPE_NAME is not correct for the above test if
13754 we've copied the type for a typedef. */
13755 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13756 if (type
== error_mark_node
)
13757 RETURN (error_mark_node
);
13758 r
= TYPE_NAME (type
);
13762 /* Check to see if we already have the specialization we
13765 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
13767 /* T is a static data member or namespace-scope entity.
13768 We have to substitute into namespace-scope variables
13769 (not just variable templates) because of cases like:
13771 template <class T> void f() { extern T t; }
13773 where the entity referenced is not known until
13774 instantiation time. */
13776 ctx
= DECL_CONTEXT (t
);
13777 if (DECL_CLASS_SCOPE_P (t
))
13779 ctx
= tsubst_aggr_type (ctx
, args
,
13781 in_decl
, /*entering_scope=*/1);
13782 /* If CTX is unchanged, then T is in fact the
13783 specialization we want. That situation occurs when
13784 referencing a static data member within in its own
13785 class. We can use pointer equality, rather than
13786 same_type_p, because DECL_CONTEXT is always
13788 if (ctx
== DECL_CONTEXT (t
)
13789 /* ... unless T is a member template; in which
13790 case our caller can be willing to create a
13791 specialization of that template represented
13793 && !(DECL_TI_TEMPLATE (t
)
13794 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
13800 tmpl
= DECL_TI_TEMPLATE (t
);
13801 gen_tmpl
= most_general_template (tmpl
);
13802 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
13803 if (argvec
!= error_mark_node
)
13804 argvec
= (coerce_innermost_template_parms
13805 (DECL_TEMPLATE_PARMS (gen_tmpl
),
13806 argvec
, t
, complain
,
13807 /*all*/true, /*defarg*/true));
13808 if (argvec
== error_mark_node
)
13809 RETURN (error_mark_node
);
13810 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
13811 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
13816 /* A local variable. */
13818 /* Subsequent calls to pushdecl will fill this in. */
13820 /* Unless this is a reference to a static variable from an
13821 enclosing function, in which case we need to fill it in now. */
13822 if (TREE_STATIC (t
))
13824 tree fn
= enclosing_instantiation_of (DECL_CONTEXT (t
));
13825 if (fn
!= current_function_decl
)
13828 spec
= retrieve_local_specialization (t
);
13830 /* If we already have the specialization we need, there is
13831 nothing more to do. */
13838 /* Create a new node for the specialization we need. */
13839 if (type
== NULL_TREE
)
13841 if (is_typedef_decl (t
))
13842 type
= DECL_ORIGINAL_TYPE (t
);
13844 type
= TREE_TYPE (t
);
13846 && VAR_HAD_UNKNOWN_BOUND (t
)
13847 && type
!= error_mark_node
)
13848 type
= strip_array_domain (type
);
13849 tree sub_args
= args
;
13850 if (tree auto_node
= type_uses_auto (type
))
13852 /* Mask off any template args past the variable's context so we
13853 don't replace the auto with an unrelated argument. */
13854 int nouter
= TEMPLATE_TYPE_LEVEL (auto_node
) - 1;
13855 int extra
= TMPL_ARGS_DEPTH (args
) - nouter
;
13857 /* This should never happen with the new lambda instantiation
13858 model, but keep the handling just in case. */
13859 gcc_assert (!CHECKING_P
),
13860 sub_args
= strip_innermost_template_args (args
, extra
);
13862 type
= tsubst (type
, sub_args
, complain
, in_decl
);
13863 /* Substituting the type might have recursively instantiated this
13864 same alias (c++/86171). */
13865 if (gen_tmpl
&& DECL_ALIAS_TEMPLATE_P (gen_tmpl
)
13866 && (spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
)))
13875 DECL_INITIALIZED_P (r
) = 0;
13876 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
13877 if (type
== error_mark_node
)
13878 RETURN (error_mark_node
);
13879 if (TREE_CODE (type
) == FUNCTION_TYPE
)
13881 /* It may seem that this case cannot occur, since:
13886 declares a function, not a variable. However:
13889 template <typename T> void g() { T t; }
13890 template void g<f>();
13892 is an attempt to declare a variable with function
13894 error ("variable %qD has function type",
13895 /* R is not yet sufficiently initialized, so we
13896 just use its name. */
13898 RETURN (error_mark_node
);
13900 type
= complete_type (type
);
13901 /* Wait until cp_finish_decl to set this again, to handle
13902 circular dependency (template/instantiate6.C). */
13903 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
13904 type
= check_var_type (DECL_NAME (r
), type
);
13906 if (DECL_HAS_VALUE_EXPR_P (t
))
13908 tree ve
= DECL_VALUE_EXPR (t
);
13909 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
13910 /*constant_expression_p=*/false);
13911 if (REFERENCE_REF_P (ve
))
13913 gcc_assert (TYPE_REF_P (type
));
13914 ve
= TREE_OPERAND (ve
, 0);
13916 SET_DECL_VALUE_EXPR (r
, ve
);
13918 if (CP_DECL_THREAD_LOCAL_P (r
)
13919 && !processing_template_decl
)
13920 set_decl_tls_model (r
, decl_default_tls_model (r
));
13922 else if (DECL_SELF_REFERENCE_P (t
))
13923 SET_DECL_SELF_REFERENCE_P (r
);
13924 TREE_TYPE (r
) = type
;
13925 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13926 DECL_CONTEXT (r
) = ctx
;
13927 /* Clear out the mangled name and RTL for the instantiation. */
13928 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
13929 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
13930 SET_DECL_RTL (r
, NULL
);
13931 /* The initializer must not be expanded until it is required;
13932 see [temp.inst]. */
13933 DECL_INITIAL (r
) = NULL_TREE
;
13934 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
13937 if (DECL_LANG_SPECIFIC (r
))
13938 SET_DECL_DEPENDENT_INIT_P (r
, false);
13940 SET_DECL_MODE (r
, VOIDmode
);
13942 /* Possibly limit visibility based on template args. */
13943 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
13944 if (DECL_VISIBILITY_SPECIFIED (t
))
13946 DECL_VISIBILITY_SPECIFIED (r
) = 0;
13947 DECL_ATTRIBUTES (r
)
13948 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
13950 determine_visibility (r
);
13955 /* A static data member declaration is always marked
13956 external when it is declared in-class, even if an
13957 initializer is present. We mimic the non-template
13958 processing here. */
13959 DECL_EXTERNAL (r
) = 1;
13960 if (DECL_NAMESPACE_SCOPE_P (t
))
13961 DECL_NOT_REALLY_EXTERN (r
) = 1;
13963 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
13964 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13965 if (!error_operand_p (r
) || (complain
& tf_error
))
13966 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
13970 if (DECL_LANG_SPECIFIC (r
))
13971 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13972 if (!cp_unevaluated_operand
)
13973 register_local_specialization (r
, t
);
13976 DECL_CHAIN (r
) = NULL_TREE
;
13978 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
13980 args
, complain
, in_decl
);
13982 /* Preserve a typedef that names a type. */
13983 if (is_typedef_decl (r
) && type
!= error_mark_node
)
13985 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
13986 set_underlying_type (r
);
13987 if (TYPE_DECL_ALIAS_P (r
))
13988 /* An alias template specialization can be dependent
13989 even if its underlying type is not. */
13990 TYPE_DEPENDENT_P_VALID (TREE_TYPE (r
)) = false;
13993 layout_decl (r
, 0);
13998 gcc_unreachable ();
14003 /* Restore the file and line information. */
14004 input_location
= saved_loc
;
14009 /* Substitute into the ARG_TYPES of a function type.
14010 If END is a TREE_CHAIN, leave it and any following types
14014 tsubst_arg_types (tree arg_types
,
14017 tsubst_flags_t complain
,
14020 tree remaining_arg_types
;
14021 tree type
= NULL_TREE
;
14023 tree expanded_args
= NULL_TREE
;
14026 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
14029 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
14030 args
, end
, complain
, in_decl
);
14031 if (remaining_arg_types
== error_mark_node
)
14032 return error_mark_node
;
14034 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
14036 /* For a pack expansion, perform substitution on the
14037 entire expression. Later on, we'll handle the arguments
14039 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
14040 args
, complain
, in_decl
);
14042 if (TREE_CODE (expanded_args
) == TREE_VEC
)
14043 /* So that we'll spin through the parameters, one by one. */
14044 i
= TREE_VEC_LENGTH (expanded_args
);
14047 /* We only partially substituted into the parameter
14048 pack. Our type is TYPE_PACK_EXPANSION. */
14049 type
= expanded_args
;
14050 expanded_args
= NULL_TREE
;
14058 type
= TREE_VEC_ELT (expanded_args
, i
);
14060 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
14062 if (type
== error_mark_node
)
14063 return error_mark_node
;
14064 if (VOID_TYPE_P (type
))
14066 if (complain
& tf_error
)
14068 error ("invalid parameter type %qT", type
);
14070 error ("in declaration %q+D", in_decl
);
14072 return error_mark_node
;
14075 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
14076 return error_mark_node
;
14078 /* Do array-to-pointer, function-to-pointer conversion, and ignore
14079 top-level qualifiers as required. */
14080 type
= cv_unqualified (type_decays_to (type
));
14082 /* We do not substitute into default arguments here. The standard
14083 mandates that they be instantiated only when needed, which is
14084 done in build_over_call. */
14085 default_arg
= TREE_PURPOSE (arg_types
);
14087 /* Except that we do substitute default arguments under tsubst_lambda_expr,
14088 since the new op() won't have any associated template arguments for us
14089 to refer to later. */
14090 if (lambda_fn_in_template_p (in_decl
))
14091 default_arg
= tsubst_copy_and_build (default_arg
, args
, complain
, in_decl
,
14092 false/*fn*/, false/*constexpr*/);
14094 if (default_arg
&& TREE_CODE (default_arg
) == DEFERRED_PARSE
)
14096 /* We've instantiated a template before its default arguments
14097 have been parsed. This can happen for a nested template
14098 class, and is not an error unless we require the default
14099 argument in a call of this function. */
14100 remaining_arg_types
=
14101 tree_cons (default_arg
, type
, remaining_arg_types
);
14102 vec_safe_push (DEFPARSE_INSTANTIATIONS (default_arg
),
14103 remaining_arg_types
);
14106 remaining_arg_types
=
14107 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
14110 return remaining_arg_types
;
14113 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
14114 *not* handle the exception-specification for FNTYPE, because the
14115 initial substitution of explicitly provided template parameters
14116 during argument deduction forbids substitution into the
14117 exception-specification:
14121 All references in the function type of the function template to the
14122 corresponding template parameters are replaced by the specified tem-
14123 plate argument values. If a substitution in a template parameter or
14124 in the function type of the function template results in an invalid
14125 type, type deduction fails. [Note: The equivalent substitution in
14126 exception specifications is done only when the function is instanti-
14127 ated, at which point a program is ill-formed if the substitution
14128 results in an invalid type.] */
14131 tsubst_function_type (tree t
,
14133 tsubst_flags_t complain
,
14137 tree arg_types
= NULL_TREE
;
14140 /* The TYPE_CONTEXT is not used for function/method types. */
14141 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
14143 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
14145 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
14147 if (late_return_type_p
)
14149 /* Substitute the argument types. */
14150 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
14151 complain
, in_decl
);
14152 if (arg_types
== error_mark_node
)
14153 return error_mark_node
;
14155 tree save_ccp
= current_class_ptr
;
14156 tree save_ccr
= current_class_ref
;
14157 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
14158 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
14159 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
14162 /* DR 1207: 'this' is in scope in the trailing return type. */
14163 inject_this_parameter (this_type
, cp_type_quals (this_type
));
14166 /* Substitute the return type. */
14167 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14171 current_class_ptr
= save_ccp
;
14172 current_class_ref
= save_ccr
;
14176 /* Substitute the return type. */
14177 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14179 if (return_type
== error_mark_node
)
14180 return error_mark_node
;
14181 /* DR 486 clarifies that creation of a function type with an
14182 invalid return type is a deduction failure. */
14183 if (TREE_CODE (return_type
) == ARRAY_TYPE
14184 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
14186 if (complain
& tf_error
)
14188 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
14189 error ("function returning an array");
14191 error ("function returning a function");
14193 return error_mark_node
;
14196 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
14197 return error_mark_node
;
14199 if (!late_return_type_p
)
14201 /* Substitute the argument types. */
14202 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
14203 complain
, in_decl
);
14204 if (arg_types
== error_mark_node
)
14205 return error_mark_node
;
14208 /* Construct a new type node and return it. */
14209 if (TREE_CODE (t
) == FUNCTION_TYPE
)
14211 fntype
= build_function_type (return_type
, arg_types
);
14212 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (t
));
14216 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
14217 /* Don't pick up extra function qualifiers from the basetype. */
14218 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
14219 if (! MAYBE_CLASS_TYPE_P (r
))
14223 Type deduction may fail for any of the following
14226 -- Attempting to create "pointer to member of T" when T
14227 is not a class type. */
14228 if (complain
& tf_error
)
14229 error ("creating pointer to member function of non-class type %qT",
14231 return error_mark_node
;
14234 fntype
= build_method_type_directly (r
, return_type
,
14235 TREE_CHAIN (arg_types
));
14237 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
14239 /* See comment above. */
14240 tree raises
= NULL_TREE
;
14241 cp_ref_qualifier rqual
= type_memfn_rqual (t
);
14242 fntype
= build_cp_fntype_variant (fntype
, rqual
, raises
, late_return_type_p
);
14247 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
14248 ARGS into that specification, and return the substituted
14249 specification. If there is no specification, return NULL_TREE. */
14252 tsubst_exception_specification (tree fntype
,
14254 tsubst_flags_t complain
,
14261 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
14262 new_specs
= NULL_TREE
;
14263 if (specs
&& TREE_PURPOSE (specs
))
14265 /* A noexcept-specifier. */
14266 tree expr
= TREE_PURPOSE (specs
);
14267 if (TREE_CODE (expr
) == INTEGER_CST
)
14271 /* Defer instantiation of noexcept-specifiers to avoid
14272 excessive instantiations (c++/49107). */
14273 new_specs
= make_node (DEFERRED_NOEXCEPT
);
14274 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
14276 /* We already partially instantiated this member template,
14277 so combine the new args with the old. */
14278 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
14279 = DEFERRED_NOEXCEPT_PATTERN (expr
);
14280 DEFERRED_NOEXCEPT_ARGS (new_specs
)
14281 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
14285 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
14286 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
14291 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
14293 args
= add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
),
14295 expr
= DEFERRED_NOEXCEPT_PATTERN (expr
);
14297 new_specs
= tsubst_copy_and_build
14298 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
14299 /*integral_constant_expression_p=*/true);
14301 new_specs
= build_noexcept_spec (new_specs
, complain
);
14305 if (! TREE_VALUE (specs
))
14312 tree expanded_specs
= NULL_TREE
;
14314 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
14316 /* Expand the pack expansion type. */
14317 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
14321 if (expanded_specs
== error_mark_node
)
14322 return error_mark_node
;
14323 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
14324 len
= TREE_VEC_LENGTH (expanded_specs
);
14327 /* We're substituting into a member template, so
14328 we got a TYPE_PACK_EXPANSION back. Add that
14329 expansion and move on. */
14330 gcc_assert (TREE_CODE (expanded_specs
)
14331 == TYPE_PACK_EXPANSION
);
14332 new_specs
= add_exception_specifier (new_specs
,
14335 specs
= TREE_CHAIN (specs
);
14340 for (i
= 0; i
< len
; ++i
)
14342 if (expanded_specs
)
14343 spec
= TREE_VEC_ELT (expanded_specs
, i
);
14345 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
14346 if (spec
== error_mark_node
)
14348 new_specs
= add_exception_specifier (new_specs
, spec
,
14352 specs
= TREE_CHAIN (specs
);
14358 /* Take the tree structure T and replace template parameters used
14359 therein with the argument vector ARGS. IN_DECL is an associated
14360 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
14361 Issue error and warning messages under control of COMPLAIN. Note
14362 that we must be relatively non-tolerant of extensions here, in
14363 order to preserve conformance; if we allow substitutions that
14364 should not be allowed, we may allow argument deductions that should
14365 not succeed, and therefore report ambiguous overload situations
14366 where there are none. In theory, we could allow the substitution,
14367 but indicate that it should have failed, and allow our caller to
14368 make sure that the right thing happens, but we don't try to do this
14371 This function is used for dealing with types, decls and the like;
14372 for expressions, use tsubst_expr or tsubst_copy. */
14375 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14377 enum tree_code code
;
14378 tree type
, r
= NULL_TREE
;
14380 if (t
== NULL_TREE
|| t
== error_mark_node
14381 || t
== integer_type_node
14382 || t
== void_type_node
14383 || t
== char_type_node
14384 || t
== unknown_type_node
14385 || TREE_CODE (t
) == NAMESPACE_DECL
14386 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
14390 return tsubst_decl (t
, args
, complain
);
14392 if (args
== NULL_TREE
)
14395 code
= TREE_CODE (t
);
14397 if (code
== IDENTIFIER_NODE
)
14398 type
= IDENTIFIER_TYPE_VALUE (t
);
14400 type
= TREE_TYPE (t
);
14402 gcc_assert (type
!= unknown_type_node
);
14404 /* Reuse typedefs. We need to do this to handle dependent attributes,
14405 such as attribute aligned. */
14407 && typedef_variant_p (t
))
14409 tree decl
= TYPE_NAME (t
);
14411 if (alias_template_specialization_p (t
))
14413 /* DECL represents an alias template and we want to
14415 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
14416 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
14417 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
14419 else if (DECL_CLASS_SCOPE_P (decl
)
14420 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
14421 && uses_template_parms (DECL_CONTEXT (decl
)))
14423 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
14424 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
14425 r
= retrieve_specialization (tmpl
, gen_args
, 0);
14427 else if (DECL_FUNCTION_SCOPE_P (decl
)
14428 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
14429 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
14430 r
= retrieve_local_specialization (decl
);
14432 /* The typedef is from a non-template context. */
14438 r
= cp_build_qualified_type_real
14439 (r
, cp_type_quals (t
) | cp_type_quals (r
),
14440 complain
| tf_ignore_bad_quals
);
14445 /* We don't have an instantiation yet, so drop the typedef. */
14446 int quals
= cp_type_quals (t
);
14447 t
= DECL_ORIGINAL_TYPE (decl
);
14448 t
= cp_build_qualified_type_real (t
, quals
,
14449 complain
| tf_ignore_bad_quals
);
14453 bool fndecl_type
= (complain
& tf_fndecl_type
);
14454 complain
&= ~tf_fndecl_type
;
14457 && code
!= TYPENAME_TYPE
14458 && code
!= TEMPLATE_TYPE_PARM
14459 && code
!= TEMPLATE_PARM_INDEX
14460 && code
!= IDENTIFIER_NODE
14461 && code
!= FUNCTION_TYPE
14462 && code
!= METHOD_TYPE
)
14463 type
= tsubst (type
, args
, complain
, in_decl
);
14464 if (type
== error_mark_node
)
14465 return error_mark_node
;
14471 case ENUMERAL_TYPE
:
14472 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
14473 /*entering_scope=*/0);
14476 case IDENTIFIER_NODE
:
14487 if (t
== integer_type_node
)
14490 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
14491 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
14495 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
14497 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
14498 /*integral_constant_expression_p=*/false);
14500 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
14502 if (TREE_CODE (max
) == NOP_EXPR
14503 && TREE_SIDE_EFFECTS (omax
)
14504 && !TREE_TYPE (max
))
14505 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
14507 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
14508 with TREE_SIDE_EFFECTS that indicates this is not an integral
14509 constant expression. */
14510 if (processing_template_decl
14511 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
14513 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
14514 TREE_SIDE_EFFECTS (max
) = 1;
14517 return compute_array_index_type (NULL_TREE
, max
, complain
);
14520 case TEMPLATE_TYPE_PARM
:
14521 case TEMPLATE_TEMPLATE_PARM
:
14522 case BOUND_TEMPLATE_TEMPLATE_PARM
:
14523 case TEMPLATE_PARM_INDEX
:
14528 tree arg
= NULL_TREE
;
14530 /* Early in template argument deduction substitution, we don't
14531 want to reduce the level of 'auto', or it will be confused
14532 with a normal template parm in subsequent deduction. */
14533 if (is_auto (t
) && (complain
& tf_partial
))
14538 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
14539 template_parm_level_and_index (t
, &level
, &idx
);
14541 levels
= TMPL_ARGS_DEPTH (args
);
14542 if (level
<= levels
14543 && TREE_VEC_LENGTH (TMPL_ARGS_LEVEL (args
, level
)) > 0)
14545 arg
= TMPL_ARG (args
, level
, idx
);
14547 /* See through ARGUMENT_PACK_SELECT arguments. */
14548 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
14549 arg
= argument_pack_select_arg (arg
);
14552 if (arg
== error_mark_node
)
14553 return error_mark_node
;
14554 else if (arg
!= NULL_TREE
)
14556 if (ARGUMENT_PACK_P (arg
))
14557 /* If ARG is an argument pack, we don't actually want to
14558 perform a substitution here, because substitutions
14559 for argument packs are only done
14560 element-by-element. We can get to this point when
14561 substituting the type of a non-type template
14562 parameter pack, when that type actually contains
14563 template parameter packs from an outer template, e.g.,
14565 template<typename... Types> struct A {
14566 template<Types... Values> struct B { };
14570 if (code
== TEMPLATE_TYPE_PARM
)
14573 gcc_assert (TYPE_P (arg
));
14575 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
14577 return cp_build_qualified_type_real
14578 (arg
, quals
, complain
| tf_ignore_bad_quals
);
14580 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
14582 /* We are processing a type constructed from a
14583 template template parameter. */
14584 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
14585 args
, complain
, in_decl
);
14586 if (argvec
== error_mark_node
)
14587 return error_mark_node
;
14589 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
14590 || TREE_CODE (arg
) == TEMPLATE_DECL
14591 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
14593 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
14594 /* Consider this code:
14596 template <template <class> class Template>
14598 template <class Arg> using Bind = Template<Arg>;
14601 template <template <class> class Template, class Arg>
14602 using Instantiate = Template<Arg>; //#0
14604 template <template <class> class Template,
14607 Instantiate<Internal<Template>::template Bind,
14610 When #1 is parsed, the
14611 BOUND_TEMPLATE_TEMPLATE_PARM representing the
14612 parameter `Template' in #0 matches the
14613 UNBOUND_CLASS_TEMPLATE representing the argument
14614 `Internal<Template>::template Bind'; We then want
14615 to assemble the type `Bind<Argument>' that can't
14616 be fully created right now, because
14617 `Internal<Template>' not being complete, the Bind
14618 template cannot be looked up in that context. So
14619 we need to "store" `Bind<Argument>' for later
14620 when the context of Bind becomes complete. Let's
14621 store that in a TYPENAME_TYPE. */
14622 return make_typename_type (TYPE_CONTEXT (arg
),
14623 build_nt (TEMPLATE_ID_EXPR
,
14624 TYPE_IDENTIFIER (arg
),
14629 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
14630 are resolving nested-types in the signature of a
14631 member function templates. Otherwise ARG is a
14632 TEMPLATE_DECL and is the real template to be
14634 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
14635 arg
= TYPE_NAME (arg
);
14637 r
= lookup_template_class (arg
,
14639 DECL_CONTEXT (arg
),
14640 /*entering_scope=*/0,
14642 return cp_build_qualified_type_real
14643 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
14645 else if (code
== TEMPLATE_TEMPLATE_PARM
)
14648 /* TEMPLATE_PARM_INDEX. */
14649 return convert_from_reference (unshare_expr (arg
));
14653 /* This can happen during the attempted tsubst'ing in
14654 unify. This means that we don't yet have any information
14655 about the template parameter in question. */
14658 /* If we get here, we must have been looking at a parm for a
14659 more deeply nested template. Make a new version of this
14660 template parameter, but with a lower level. */
14663 case TEMPLATE_TYPE_PARM
:
14664 case TEMPLATE_TEMPLATE_PARM
:
14665 case BOUND_TEMPLATE_TEMPLATE_PARM
:
14666 if (cp_type_quals (t
))
14668 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
14669 r
= cp_build_qualified_type_real
14670 (r
, cp_type_quals (t
),
14671 complain
| (code
== TEMPLATE_TYPE_PARM
14672 ? tf_ignore_bad_quals
: 0));
14674 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
14675 && PLACEHOLDER_TYPE_CONSTRAINTS (t
)
14676 && (r
= (TEMPLATE_PARM_DESCENDANTS
14677 (TEMPLATE_TYPE_PARM_INDEX (t
))))
14678 && (r
= TREE_TYPE (r
))
14679 && !PLACEHOLDER_TYPE_CONSTRAINTS (r
))
14680 /* Break infinite recursion when substituting the constraints
14681 of a constrained placeholder. */;
14682 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
14683 && !PLACEHOLDER_TYPE_CONSTRAINTS (t
)
14684 && !CLASS_PLACEHOLDER_TEMPLATE (t
)
14685 && (arg
= TEMPLATE_TYPE_PARM_INDEX (t
),
14686 r
= TEMPLATE_PARM_DESCENDANTS (arg
))
14687 && (TEMPLATE_PARM_LEVEL (r
)
14688 == TEMPLATE_PARM_LEVEL (arg
) - levels
))
14689 /* Cache the simple case of lowering a type parameter. */
14694 TEMPLATE_TYPE_PARM_INDEX (r
)
14695 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
14696 r
, levels
, args
, complain
);
14697 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
14698 TYPE_MAIN_VARIANT (r
) = r
;
14699 TYPE_POINTER_TO (r
) = NULL_TREE
;
14700 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
14702 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
14704 /* Propagate constraints on placeholders. */
14705 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
14706 PLACEHOLDER_TYPE_CONSTRAINTS (r
)
14707 = tsubst_constraint (constr
, args
, complain
, in_decl
);
14708 else if (tree pl
= CLASS_PLACEHOLDER_TEMPLATE (t
))
14710 pl
= tsubst_copy (pl
, args
, complain
, in_decl
);
14711 CLASS_PLACEHOLDER_TEMPLATE (r
) = pl
;
14715 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
14716 /* We have reduced the level of the template
14717 template parameter, but not the levels of its
14718 template parameters, so canonical_type_parameter
14719 will not be able to find the canonical template
14720 template parameter for this level. Thus, we
14721 require structural equality checking to compare
14722 TEMPLATE_TEMPLATE_PARMs. */
14723 SET_TYPE_STRUCTURAL_EQUALITY (r
);
14724 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
14725 SET_TYPE_STRUCTURAL_EQUALITY (r
);
14727 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
14729 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
14731 tree tinfo
= TYPE_TEMPLATE_INFO (t
);
14732 /* We might need to substitute into the types of non-type
14733 template parameters. */
14734 tree tmpl
= tsubst (TI_TEMPLATE (tinfo
), args
,
14735 complain
, in_decl
);
14736 if (tmpl
== error_mark_node
)
14737 return error_mark_node
;
14738 tree argvec
= tsubst (TI_ARGS (tinfo
), args
,
14739 complain
, in_decl
);
14740 if (argvec
== error_mark_node
)
14741 return error_mark_node
;
14743 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
14744 = build_template_info (tmpl
, argvec
);
14749 case TEMPLATE_PARM_INDEX
:
14750 /* OK, now substitute the type of the non-type parameter. We
14751 couldn't do it earlier because it might be an auto parameter,
14752 and we wouldn't need to if we had an argument. */
14753 type
= tsubst (type
, args
, complain
, in_decl
);
14754 if (type
== error_mark_node
)
14755 return error_mark_node
;
14756 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
14760 gcc_unreachable ();
14768 tree purpose
, value
, chain
;
14770 if (t
== void_list_node
)
14773 purpose
= TREE_PURPOSE (t
);
14776 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
14777 if (purpose
== error_mark_node
)
14778 return error_mark_node
;
14780 value
= TREE_VALUE (t
);
14783 value
= tsubst (value
, args
, complain
, in_decl
);
14784 if (value
== error_mark_node
)
14785 return error_mark_node
;
14787 chain
= TREE_CHAIN (t
);
14788 if (chain
&& chain
!= void_type_node
)
14790 chain
= tsubst (chain
, args
, complain
, in_decl
);
14791 if (chain
== error_mark_node
)
14792 return error_mark_node
;
14794 if (purpose
== TREE_PURPOSE (t
)
14795 && value
== TREE_VALUE (t
)
14796 && chain
== TREE_CHAIN (t
))
14798 return hash_tree_cons (purpose
, value
, chain
);
14802 /* We should never be tsubsting a binfo. */
14803 gcc_unreachable ();
14806 /* A vector of template arguments. */
14807 gcc_assert (!type
);
14808 return tsubst_template_args (t
, args
, complain
, in_decl
);
14811 case REFERENCE_TYPE
:
14813 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
14818 Type deduction may fail for any of the following
14821 -- Attempting to create a pointer to reference type.
14822 -- Attempting to create a reference to a reference type or
14823 a reference to void.
14825 Core issue 106 says that creating a reference to a reference
14826 during instantiation is no longer a cause for failure. We
14827 only enforce this check in strict C++98 mode. */
14828 if ((TYPE_REF_P (type
)
14829 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
14830 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
14832 static location_t last_loc
;
14834 /* We keep track of the last time we issued this error
14835 message to avoid spewing a ton of messages during a
14836 single bad template instantiation. */
14837 if (complain
& tf_error
14838 && last_loc
!= input_location
)
14840 if (VOID_TYPE_P (type
))
14841 error ("forming reference to void");
14842 else if (code
== POINTER_TYPE
)
14843 error ("forming pointer to reference type %qT", type
);
14845 error ("forming reference to reference type %qT", type
);
14846 last_loc
= input_location
;
14849 return error_mark_node
;
14851 else if (TREE_CODE (type
) == FUNCTION_TYPE
14852 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
14853 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
14855 if (complain
& tf_error
)
14857 if (code
== POINTER_TYPE
)
14858 error ("forming pointer to qualified function type %qT",
14861 error ("forming reference to qualified function type %qT",
14864 return error_mark_node
;
14866 else if (code
== POINTER_TYPE
)
14868 r
= build_pointer_type (type
);
14869 if (TREE_CODE (type
) == METHOD_TYPE
)
14870 r
= build_ptrmemfunc_type (r
);
14872 else if (TYPE_REF_P (type
))
14873 /* In C++0x, during template argument substitution, when there is an
14874 attempt to create a reference to a reference type, reference
14875 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
14877 "If a template-argument for a template-parameter T names a type
14878 that is a reference to a type A, an attempt to create the type
14879 'lvalue reference to cv T' creates the type 'lvalue reference to
14880 A,' while an attempt to create the type type rvalue reference to
14881 cv T' creates the type T"
14883 r
= cp_build_reference_type
14885 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
14887 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
14888 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
14890 if (r
!= error_mark_node
)
14891 /* Will this ever be needed for TYPE_..._TO values? */
14898 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
14899 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
14903 Type deduction may fail for any of the following
14906 -- Attempting to create "pointer to member of T" when T
14907 is not a class type. */
14908 if (complain
& tf_error
)
14909 error ("creating pointer to member of non-class type %qT", r
);
14910 return error_mark_node
;
14912 if (TYPE_REF_P (type
))
14914 if (complain
& tf_error
)
14915 error ("creating pointer to member reference type %qT", type
);
14916 return error_mark_node
;
14918 if (VOID_TYPE_P (type
))
14920 if (complain
& tf_error
)
14921 error ("creating pointer to member of type void");
14922 return error_mark_node
;
14924 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
14925 if (TREE_CODE (type
) == FUNCTION_TYPE
)
14927 /* The type of the implicit object parameter gets its
14928 cv-qualifiers from the FUNCTION_TYPE. */
14931 = build_memfn_type (type
, r
, type_memfn_quals (type
),
14932 type_memfn_rqual (type
));
14933 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
14934 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
14938 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
14942 case FUNCTION_TYPE
:
14947 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
14948 if (fntype
== error_mark_node
)
14949 return error_mark_node
;
14951 /* Substitute the exception specification. */
14952 specs
= tsubst_exception_specification (t
, args
, complain
, in_decl
,
14953 /*defer_ok*/fndecl_type
);
14954 if (specs
== error_mark_node
)
14955 return error_mark_node
;
14957 fntype
= build_exception_variant (fntype
, specs
);
14962 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
14963 if (domain
== error_mark_node
)
14964 return error_mark_node
;
14966 /* As an optimization, we avoid regenerating the array type if
14967 it will obviously be the same as T. */
14968 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
14971 /* These checks should match the ones in create_array_type_for_decl.
14975 The deduction may fail for any of the following reasons:
14977 -- Attempting to create an array with an element type that
14978 is void, a function type, or a reference type, or [DR337]
14979 an abstract class type. */
14980 if (VOID_TYPE_P (type
)
14981 || TREE_CODE (type
) == FUNCTION_TYPE
14982 || (TREE_CODE (type
) == ARRAY_TYPE
14983 && TYPE_DOMAIN (type
) == NULL_TREE
)
14984 || TYPE_REF_P (type
))
14986 if (complain
& tf_error
)
14987 error ("creating array of %qT", type
);
14988 return error_mark_node
;
14991 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
14992 return error_mark_node
;
14994 r
= build_cplus_array_type (type
, domain
);
14996 if (!valid_array_size_p (input_location
, r
, in_decl
,
14997 (complain
& tf_error
)))
14998 return error_mark_node
;
15000 if (TYPE_USER_ALIGN (t
))
15002 SET_TYPE_ALIGN (r
, TYPE_ALIGN (t
));
15003 TYPE_USER_ALIGN (r
) = 1;
15009 case TYPENAME_TYPE
:
15011 tree ctx
= TYPE_CONTEXT (t
);
15012 if (TREE_CODE (ctx
) == TYPE_PACK_EXPANSION
)
15014 ctx
= tsubst_pack_expansion (ctx
, args
, complain
, in_decl
);
15015 if (ctx
== error_mark_node
15016 || TREE_VEC_LENGTH (ctx
) > 1)
15017 return error_mark_node
;
15018 if (TREE_VEC_LENGTH (ctx
) == 0)
15020 if (complain
& tf_error
)
15021 error ("%qD is instantiated for an empty pack",
15022 TYPENAME_TYPE_FULLNAME (t
));
15023 return error_mark_node
;
15025 ctx
= TREE_VEC_ELT (ctx
, 0);
15028 ctx
= tsubst_aggr_type (ctx
, args
, complain
, in_decl
,
15029 /*entering_scope=*/1);
15030 if (ctx
== error_mark_node
)
15031 return error_mark_node
;
15033 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
15034 complain
, in_decl
);
15035 if (f
== error_mark_node
)
15036 return error_mark_node
;
15038 if (!MAYBE_CLASS_TYPE_P (ctx
))
15040 if (complain
& tf_error
)
15041 error ("%qT is not a class, struct, or union type", ctx
);
15042 return error_mark_node
;
15044 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
15046 /* Normally, make_typename_type does not require that the CTX
15047 have complete type in order to allow things like:
15049 template <class T> struct S { typename S<T>::X Y; };
15051 But, such constructs have already been resolved by this
15052 point, so here CTX really should have complete type, unless
15053 it's a partial instantiation. */
15054 ctx
= complete_type (ctx
);
15055 if (!COMPLETE_TYPE_P (ctx
))
15057 if (complain
& tf_error
)
15058 cxx_incomplete_type_error (NULL_TREE
, ctx
);
15059 return error_mark_node
;
15063 f
= make_typename_type (ctx
, f
, typename_type
,
15064 complain
| tf_keep_type_decl
);
15065 if (f
== error_mark_node
)
15067 if (TREE_CODE (f
) == TYPE_DECL
)
15069 complain
|= tf_ignore_bad_quals
;
15073 if (TREE_CODE (f
) != TYPENAME_TYPE
)
15075 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
15077 if (complain
& tf_error
)
15078 error ("%qT resolves to %qT, which is not an enumeration type",
15081 return error_mark_node
;
15083 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
15085 if (complain
& tf_error
)
15086 error ("%qT resolves to %qT, which is is not a class type",
15089 return error_mark_node
;
15093 return cp_build_qualified_type_real
15094 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
15097 case UNBOUND_CLASS_TEMPLATE
:
15099 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
15100 in_decl
, /*entering_scope=*/1);
15101 tree name
= TYPE_IDENTIFIER (t
);
15102 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
15104 if (ctx
== error_mark_node
|| name
== error_mark_node
)
15105 return error_mark_node
;
15108 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
15109 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
15116 ++cp_unevaluated_operand
;
15117 ++c_inhibit_evaluation_warnings
;
15119 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
15121 /*integral_constant_expression_p=*/false);
15123 --cp_unevaluated_operand
;
15124 --c_inhibit_evaluation_warnings
;
15126 type
= finish_typeof (type
);
15127 return cp_build_qualified_type_real (type
,
15129 | cp_type_quals (type
),
15133 case DECLTYPE_TYPE
:
15137 ++cp_unevaluated_operand
;
15138 ++c_inhibit_evaluation_warnings
;
15140 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
15141 complain
|tf_decltype
, in_decl
,
15142 /*function_p*/false,
15143 /*integral_constant_expression*/false);
15145 if (DECLTYPE_FOR_INIT_CAPTURE (t
))
15147 if (type
== NULL_TREE
)
15149 if (complain
& tf_error
)
15150 error ("empty initializer in lambda init-capture");
15151 type
= error_mark_node
;
15153 else if (TREE_CODE (type
) == TREE_LIST
)
15154 type
= build_x_compound_expr_from_list (type
, ELK_INIT
, complain
);
15157 --cp_unevaluated_operand
;
15158 --c_inhibit_evaluation_warnings
;
15160 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
15161 type
= lambda_capture_field_type (type
,
15162 DECLTYPE_FOR_INIT_CAPTURE (t
),
15163 DECLTYPE_FOR_REF_CAPTURE (t
));
15164 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
15165 type
= lambda_proxy_type (type
);
15168 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
15169 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
15171 /* In a template ~id could be either a complement expression
15172 or an unqualified-id naming a destructor; if instantiating
15173 it produces an expression, it's not an id-expression or
15176 type
= finish_decltype_type (type
, id
, complain
);
15178 return cp_build_qualified_type_real (type
,
15180 | cp_type_quals (type
),
15181 complain
| tf_ignore_bad_quals
);
15184 case UNDERLYING_TYPE
:
15186 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
15187 complain
, in_decl
);
15188 return finish_underlying_type (type
);
15191 case TYPE_ARGUMENT_PACK
:
15192 case NONTYPE_ARGUMENT_PACK
:
15196 if (code
== NONTYPE_ARGUMENT_PACK
)
15197 r
= make_node (code
);
15199 r
= cxx_make_type (code
);
15201 tree pack_args
= ARGUMENT_PACK_ARGS (t
);
15202 pack_args
= tsubst_template_args (pack_args
, args
, complain
, in_decl
);
15203 SET_ARGUMENT_PACK_ARGS (r
, pack_args
);
15221 /* We should use one of the expression tsubsts for these codes. */
15222 gcc_unreachable ();
15225 sorry ("use of %qs in template", get_tree_code_name (code
));
15226 return error_mark_node
;
15230 /* tsubst a BASELINK. OBJECT_TYPE, if non-NULL, is the type of the
15231 expression on the left-hand side of the "." or "->" operator. We
15232 only do the lookup if we had a dependent BASELINK. Otherwise we
15233 adjust it onto the instantiated heirarchy. */
15236 tsubst_baselink (tree baselink
, tree object_type
,
15237 tree args
, tsubst_flags_t complain
, tree in_decl
)
15239 bool qualified_p
= BASELINK_QUALIFIED_P (baselink
);
15240 tree qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
15241 qualifying_scope
= tsubst (qualifying_scope
, args
, complain
, in_decl
);
15243 tree optype
= BASELINK_OPTYPE (baselink
);
15244 optype
= tsubst (optype
, args
, complain
, in_decl
);
15246 tree template_args
= NULL_TREE
;
15247 bool template_id_p
= false;
15248 tree fns
= BASELINK_FUNCTIONS (baselink
);
15249 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
15251 template_id_p
= true;
15252 template_args
= TREE_OPERAND (fns
, 1);
15253 fns
= TREE_OPERAND (fns
, 0);
15255 template_args
= tsubst_template_args (template_args
, args
,
15256 complain
, in_decl
);
15259 tree binfo_type
= BINFO_TYPE (BASELINK_BINFO (baselink
));
15260 binfo_type
= tsubst (binfo_type
, args
, complain
, in_decl
);
15261 bool dependent_p
= binfo_type
!= BINFO_TYPE (BASELINK_BINFO (baselink
));
15265 tree name
= OVL_NAME (fns
);
15266 if (IDENTIFIER_CONV_OP_P (name
))
15267 name
= make_conv_op_name (optype
);
15269 if (name
== complete_dtor_identifier
)
15270 /* Treat as-if non-dependent below. */
15271 dependent_p
= false;
15273 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
15276 if ((complain
& tf_error
)
15277 && constructor_name_p (name
, qualifying_scope
))
15278 error ("cannot call constructor %<%T::%D%> directly",
15279 qualifying_scope
, name
);
15280 return error_mark_node
;
15283 if (BASELINK_P (baselink
))
15284 fns
= BASELINK_FUNCTIONS (baselink
);
15287 /* We're going to overwrite pieces below, make a duplicate. */
15288 baselink
= copy_node (baselink
);
15290 /* If lookup found a single function, mark it as used at this point.
15291 (If lookup found multiple functions the one selected later by
15292 overload resolution will be marked as used at that point.) */
15293 if (!template_id_p
&& !really_overloaded_fn (fns
))
15295 tree fn
= OVL_FIRST (fns
);
15296 bool ok
= mark_used (fn
, complain
);
15297 if (!ok
&& !(complain
& tf_error
))
15298 return error_mark_node
;
15299 if (ok
&& BASELINK_P (baselink
))
15300 /* We might have instantiated an auto function. */
15301 TREE_TYPE (baselink
) = TREE_TYPE (fn
);
15304 if (BASELINK_P (baselink
))
15306 /* Add back the template arguments, if present. */
15308 BASELINK_FUNCTIONS (baselink
)
15309 = build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fns
, template_args
);
15311 /* Update the conversion operator type. */
15312 BASELINK_OPTYPE (baselink
) = optype
;
15316 object_type
= current_class_type
;
15318 if (qualified_p
|| !dependent_p
)
15320 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
15324 /* We need to call adjust_result_of_qualified_name_lookup in case the
15325 destructor names a base class, but we unset BASELINK_QUALIFIED_P
15326 so that we still get virtual function binding. */
15327 BASELINK_QUALIFIED_P (baselink
) = false;
15333 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
15334 true if the qualified-id will be a postfix-expression in-and-of
15335 itself; false if more of the postfix-expression follows the
15336 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
15340 tsubst_qualified_id (tree qualified_id
, tree args
,
15341 tsubst_flags_t complain
, tree in_decl
,
15342 bool done
, bool address_p
)
15348 tree template_args
;
15349 location_t loc
= UNKNOWN_LOCATION
;
15351 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
15353 /* Figure out what name to look up. */
15354 name
= TREE_OPERAND (qualified_id
, 1);
15355 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
15357 is_template
= true;
15358 loc
= EXPR_LOCATION (name
);
15359 template_args
= TREE_OPERAND (name
, 1);
15361 template_args
= tsubst_template_args (template_args
, args
,
15362 complain
, in_decl
);
15363 if (template_args
== error_mark_node
)
15364 return error_mark_node
;
15365 name
= TREE_OPERAND (name
, 0);
15369 is_template
= false;
15370 template_args
= NULL_TREE
;
15373 /* Substitute into the qualifying scope. When there are no ARGS, we
15374 are just trying to simplify a non-dependent expression. In that
15375 case the qualifying scope may be dependent, and, in any case,
15376 substituting will not help. */
15377 scope
= TREE_OPERAND (qualified_id
, 0);
15380 scope
= tsubst (scope
, args
, complain
, in_decl
);
15381 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
15386 if (dependent_scope_p (scope
))
15389 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
15390 tree r
= build_qualified_name (NULL_TREE
, scope
, expr
,
15391 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
15392 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (qualified_id
);
15396 if (!BASELINK_P (name
) && !DECL_P (expr
))
15398 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
15400 /* A BIT_NOT_EXPR is used to represent a destructor. */
15401 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
15403 error ("qualifying type %qT does not match destructor name ~%qT",
15404 scope
, TREE_OPERAND (expr
, 0));
15405 expr
= error_mark_node
;
15408 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
15409 /*is_type_p=*/0, false);
15412 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
15413 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
15414 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
15416 if (complain
& tf_error
)
15418 error ("dependent-name %qE is parsed as a non-type, but "
15419 "instantiation yields a type", qualified_id
);
15420 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
15422 return error_mark_node
;
15428 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
15430 /* Remember that there was a reference to this entity. */
15431 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
15432 return error_mark_node
;
15435 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
15437 if (complain
& tf_error
)
15438 qualified_name_lookup_error (scope
,
15439 TREE_OPERAND (qualified_id
, 1),
15440 expr
, input_location
);
15441 return error_mark_node
;
15446 /* We may be repeating a check already done during parsing, but
15447 if it was well-formed and passed then, it will pass again
15448 now, and if it didn't, we wouldn't have got here. The case
15449 we want to catch is when we couldn't tell then, and can now,
15450 namely when templ prior to substitution was an
15452 if (flag_concepts
&& check_auto_in_tmpl_args (expr
, template_args
))
15453 return error_mark_node
;
15455 if (variable_template_p (expr
))
15456 expr
= lookup_and_finish_template_variable (expr
, template_args
,
15459 expr
= lookup_template_function (expr
, template_args
);
15462 if (expr
== error_mark_node
&& complain
& tf_error
)
15463 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
15464 expr
, input_location
);
15465 else if (TYPE_P (scope
))
15467 expr
= (adjust_result_of_qualified_name_lookup
15468 (expr
, scope
, current_nonlambda_class_type ()));
15469 expr
= (finish_qualified_id_expr
15470 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
15471 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
15472 /*template_arg_p=*/false, complain
));
15475 /* Expressions do not generally have reference type. */
15476 if (TREE_CODE (expr
) != SCOPE_REF
15477 /* However, if we're about to form a pointer-to-member, we just
15478 want the referenced member referenced. */
15479 && TREE_CODE (expr
) != OFFSET_REF
)
15480 expr
= convert_from_reference (expr
);
15482 if (REF_PARENTHESIZED_P (qualified_id
))
15483 expr
= force_paren_expr (expr
);
15488 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
15489 initializer, DECL is the substituted VAR_DECL. Other arguments are as
15493 tsubst_init (tree init
, tree decl
, tree args
,
15494 tsubst_flags_t complain
, tree in_decl
)
15499 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
15501 tree type
= TREE_TYPE (decl
);
15503 if (!init
&& type
!= error_mark_node
)
15505 if (tree auto_node
= type_uses_auto (type
))
15507 if (!CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
15509 if (complain
& tf_error
)
15510 error ("initializer for %q#D expands to an empty list "
15511 "of expressions", decl
);
15512 return error_mark_node
;
15515 else if (!dependent_type_p (type
))
15517 /* If we had an initializer but it
15518 instantiated to nothing,
15519 value-initialize the object. This will
15520 only occur when the initializer was a
15521 pack expansion where the parameter packs
15522 used in that expansion were of length
15524 init
= build_value_init (type
, complain
);
15525 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
15526 init
= get_target_expr_sfinae (init
, complain
);
15527 if (TREE_CODE (init
) == TARGET_EXPR
)
15528 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
15535 /* Like tsubst, but deals with expressions. This function just replaces
15536 template parms; to finish processing the resultant expression, use
15537 tsubst_copy_and_build or tsubst_expr. */
15540 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
15542 enum tree_code code
;
15545 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
15548 code
= TREE_CODE (t
);
15553 r
= retrieve_local_specialization (t
);
15555 if (r
== NULL_TREE
)
15557 /* We get here for a use of 'this' in an NSDMI. */
15558 if (DECL_NAME (t
) == this_identifier
&& current_class_ptr
)
15559 return current_class_ptr
;
15561 /* This can happen for a parameter name used later in a function
15562 declaration (such as in a late-specified return type). Just
15563 make a dummy decl, since it's only used for its type. */
15564 gcc_assert (cp_unevaluated_operand
!= 0);
15565 r
= tsubst_decl (t
, args
, complain
);
15566 /* Give it the template pattern as its context; its true context
15567 hasn't been instantiated yet and this is good enough for
15569 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
15572 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
15573 r
= argument_pack_select_arg (r
);
15574 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
15575 return error_mark_node
;
15583 if (DECL_TEMPLATE_PARM_P (t
))
15584 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
15585 /* There is no need to substitute into namespace-scope
15587 if (DECL_NAMESPACE_SCOPE_P (t
))
15589 /* If ARGS is NULL, then T is known to be non-dependent. */
15590 if (args
== NULL_TREE
)
15591 return scalar_constant_value (t
);
15593 /* Unfortunately, we cannot just call lookup_name here.
15596 template <int I> int f() {
15598 struct S { void g() { E e = a; } };
15601 When we instantiate f<7>::S::g(), say, lookup_name is not
15602 clever enough to find f<7>::a. */
15604 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
15605 /*entering_scope=*/0);
15607 for (v
= TYPE_VALUES (enum_type
);
15609 v
= TREE_CHAIN (v
))
15610 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
15611 return TREE_VALUE (v
);
15613 /* We didn't find the name. That should never happen; if
15614 name-lookup found it during preliminary parsing, we
15615 should find it again here during instantiation. */
15616 gcc_unreachable ();
15621 if (DECL_CONTEXT (t
))
15625 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
15626 /*entering_scope=*/1);
15627 if (ctx
!= DECL_CONTEXT (t
))
15629 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
15632 if (complain
& tf_error
)
15633 error ("using invalid field %qD", t
);
15634 return error_mark_node
;
15643 case FUNCTION_DECL
:
15644 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
15645 r
= tsubst (t
, args
, complain
, in_decl
);
15646 else if (local_variable_p (t
)
15647 && uses_template_parms (DECL_CONTEXT (t
)))
15649 r
= retrieve_local_specialization (t
);
15650 if (r
== NULL_TREE
)
15652 /* First try name lookup to find the instantiation. */
15653 r
= lookup_name (DECL_NAME (t
));
15658 /* During error-recovery we may find a non-variable,
15659 even an OVERLOAD: just bail out and avoid ICEs and
15660 duplicate diagnostics (c++/62207). */
15661 gcc_assert (seen_error ());
15662 return error_mark_node
;
15664 if (!is_capture_proxy (r
))
15666 /* Make sure the one we found is the one we want. */
15667 tree ctx
= enclosing_instantiation_of (DECL_CONTEXT (t
));
15668 if (ctx
!= DECL_CONTEXT (r
))
15677 /* This can happen for a variable used in a
15678 late-specified return type of a local lambda, or for a
15679 local static or constant. Building a new VAR_DECL
15680 should be OK in all those cases. */
15681 r
= tsubst_decl (t
, args
, complain
);
15682 if (local_specializations
)
15683 /* Avoid infinite recursion (79640). */
15684 register_local_specialization (r
, t
);
15685 if (decl_maybe_constant_var_p (r
))
15687 /* We can't call cp_finish_decl, so handle the
15688 initializer by hand. */
15689 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
15690 complain
, in_decl
);
15691 if (!processing_template_decl
)
15692 init
= maybe_constant_init (init
);
15693 if (processing_template_decl
15694 ? potential_constant_expression (init
)
15695 : reduced_constant_expression_p (init
))
15696 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
15697 = TREE_CONSTANT (r
) = true;
15698 DECL_INITIAL (r
) = init
;
15699 if (tree auto_node
= type_uses_auto (TREE_TYPE (r
)))
15701 = do_auto_deduction (TREE_TYPE (r
), init
, auto_node
,
15702 complain
, adc_variable_type
);
15704 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
15705 || decl_constant_var_p (r
)
15707 if (!processing_template_decl
15708 && !TREE_STATIC (r
))
15709 r
= process_outer_var_ref (r
, complain
);
15711 /* Remember this for subsequent uses. */
15712 if (local_specializations
)
15713 register_local_specialization (r
, t
);
15715 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
15716 r
= argument_pack_select_arg (r
);
15720 if (!mark_used (r
, complain
))
15721 return error_mark_node
;
15724 case NAMESPACE_DECL
:
15731 return tsubst_baselink (t
, current_nonlambda_class_type (),
15732 args
, complain
, in_decl
);
15734 case TEMPLATE_DECL
:
15735 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
15736 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
15737 args
, complain
, in_decl
);
15738 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
15739 return tsubst (t
, args
, complain
, in_decl
);
15740 else if (DECL_CLASS_SCOPE_P (t
)
15741 && uses_template_parms (DECL_CONTEXT (t
)))
15743 /* Template template argument like the following example need
15746 template <template <class> class TT> struct C {};
15747 template <class T> struct D {
15748 template <class U> struct E {};
15753 We are processing the template argument `E' in #1 for
15754 the template instantiation #2. Originally, `E' is a
15755 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
15756 have to substitute this with one having context `D<int>'. */
15758 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
15759 if (dependent_scope_p (context
))
15761 /* When rewriting a constructor into a deduction guide, a
15762 non-dependent name can become dependent, so memtmpl<args>
15763 becomes context::template memtmpl<args>. */
15764 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15765 return build_qualified_name (type
, context
, DECL_NAME (t
),
15768 return lookup_field (context
, DECL_NAME(t
), 0, false);
15771 /* Ordinary template template argument. */
15774 case NON_LVALUE_EXPR
:
15775 case VIEW_CONVERT_EXPR
:
15777 /* Handle location wrappers by substituting the wrapped node
15778 first, *then* reusing the resulting type. Doing the type
15779 first ensures that we handle template parameters and
15780 parameter pack expansions. */
15781 if (location_wrapper_p (t
))
15783 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
,
15784 complain
, in_decl
);
15785 return maybe_wrap_with_location (op0
, EXPR_LOCATION (t
));
15787 tree op
= TREE_OPERAND (t
, 0);
15788 if (code
== VIEW_CONVERT_EXPR
15789 && TREE_CODE (op
) == TEMPLATE_PARM_INDEX
)
15791 /* Wrapper to make a C++20 template parameter object const. */
15792 op
= tsubst_copy (op
, args
, complain
, in_decl
);
15793 if (TREE_CODE (op
) == TEMPLATE_PARM_INDEX
)
15795 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15796 return build1 (code
, type
, op
);
15800 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (op
)));
15804 /* We shouldn't see any other uses of these in templates. */
15805 gcc_unreachable ();
15809 case REINTERPRET_CAST_EXPR
:
15810 case CONST_CAST_EXPR
:
15811 case STATIC_CAST_EXPR
:
15812 case DYNAMIC_CAST_EXPR
:
15813 case IMPLICIT_CONV_EXPR
:
15817 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15818 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15819 return build1 (code
, type
, op0
);
15823 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
15824 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
15826 tree expanded
, op
= TREE_OPERAND (t
, 0);
15829 if (SIZEOF_EXPR_TYPE_P (t
))
15830 op
= TREE_TYPE (op
);
15832 ++cp_unevaluated_operand
;
15833 ++c_inhibit_evaluation_warnings
;
15834 /* We only want to compute the number of arguments. */
15835 if (PACK_EXPANSION_P (op
))
15836 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
15838 expanded
= tsubst_template_args (ARGUMENT_PACK_ARGS (op
),
15839 args
, complain
, in_decl
);
15840 --cp_unevaluated_operand
;
15841 --c_inhibit_evaluation_warnings
;
15843 if (TREE_CODE (expanded
) == TREE_VEC
)
15845 len
= TREE_VEC_LENGTH (expanded
);
15846 /* Set TREE_USED for the benefit of -Wunused. */
15847 for (int i
= 0; i
< len
; i
++)
15848 if (DECL_P (TREE_VEC_ELT (expanded
, i
)))
15849 TREE_USED (TREE_VEC_ELT (expanded
, i
)) = true;
15852 if (expanded
== error_mark_node
)
15853 return error_mark_node
;
15854 else if (PACK_EXPANSION_P (expanded
)
15855 || (TREE_CODE (expanded
) == TREE_VEC
15856 && pack_expansion_args_count (expanded
)))
15859 if (PACK_EXPANSION_P (expanded
))
15861 else if (TREE_VEC_LENGTH (expanded
) == 1)
15862 expanded
= TREE_VEC_ELT (expanded
, 0);
15864 expanded
= make_argument_pack (expanded
);
15866 if (TYPE_P (expanded
))
15867 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
15869 complain
& tf_error
);
15871 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
15872 complain
& tf_error
);
15875 return build_int_cst (size_type_node
, len
);
15877 if (SIZEOF_EXPR_TYPE_P (t
))
15879 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
15880 args
, complain
, in_decl
);
15881 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
15882 r
= build1 (SIZEOF_EXPR
,
15883 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
15884 SIZEOF_EXPR_TYPE_P (r
) = 1;
15891 case TRUTH_NOT_EXPR
:
15894 case UNARY_PLUS_EXPR
: /* Unary + */
15896 case AT_ENCODE_EXPR
:
15900 case REALPART_EXPR
:
15901 case IMAGPART_EXPR
:
15904 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15905 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15906 r
= build1 (code
, type
, op0
);
15907 if (code
== ALIGNOF_EXPR
)
15908 ALIGNOF_EXPR_STD_P (r
) = ALIGNOF_EXPR_STD_P (t
);
15912 case COMPONENT_REF
:
15917 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15918 name
= TREE_OPERAND (t
, 1);
15919 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
15921 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15922 complain
, in_decl
);
15923 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
15925 else if (TREE_CODE (name
) == SCOPE_REF
15926 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
15928 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15929 complain
, in_decl
);
15930 name
= TREE_OPERAND (name
, 1);
15931 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15932 complain
, in_decl
);
15933 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
15934 name
= build_qualified_name (/*type=*/NULL_TREE
,
15936 /*template_p=*/false);
15938 else if (BASELINK_P (name
))
15939 name
= tsubst_baselink (name
,
15940 non_reference (TREE_TYPE (object
)),
15944 name
= tsubst_copy (name
, args
, complain
, in_decl
);
15945 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
15951 case TRUNC_DIV_EXPR
:
15952 case CEIL_DIV_EXPR
:
15953 case FLOOR_DIV_EXPR
:
15954 case ROUND_DIV_EXPR
:
15955 case EXACT_DIV_EXPR
:
15959 case TRUNC_MOD_EXPR
:
15960 case FLOOR_MOD_EXPR
:
15961 case TRUTH_ANDIF_EXPR
:
15962 case TRUTH_ORIF_EXPR
:
15963 case TRUTH_AND_EXPR
:
15964 case TRUTH_OR_EXPR
:
15977 case COMPOUND_EXPR
:
15980 case PREDECREMENT_EXPR
:
15981 case PREINCREMENT_EXPR
:
15982 case POSTDECREMENT_EXPR
:
15983 case POSTINCREMENT_EXPR
:
15985 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15986 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15987 return build_nt (code
, op0
, op1
);
15992 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15993 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15994 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
15995 QUALIFIED_NAME_IS_TEMPLATE (t
));
16000 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16001 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16002 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
16007 int n
= VL_EXP_OPERAND_LENGTH (t
);
16008 tree result
= build_vl_exp (CALL_EXPR
, n
);
16010 for (i
= 0; i
< n
; i
++)
16011 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
16012 complain
, in_decl
);
16018 case PSEUDO_DTOR_EXPR
:
16019 case VEC_PERM_EXPR
:
16021 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16022 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16023 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
16024 r
= build_nt (code
, op0
, op1
, op2
);
16025 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
16031 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16032 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16033 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
16034 r
= build_nt (code
, op0
, op1
, op2
);
16035 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
16041 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16042 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16043 r
= build_nt (code
, op0
, op1
);
16044 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
16045 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
16049 case TEMPLATE_ID_EXPR
:
16051 /* Substituted template arguments */
16052 tree fn
= TREE_OPERAND (t
, 0);
16053 tree targs
= TREE_OPERAND (t
, 1);
16055 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
16057 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
16059 return lookup_template_function (fn
, targs
);
16064 tree purpose
, value
, chain
;
16066 if (t
== void_list_node
)
16069 purpose
= TREE_PURPOSE (t
);
16071 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
16072 value
= TREE_VALUE (t
);
16074 value
= tsubst_copy (value
, args
, complain
, in_decl
);
16075 chain
= TREE_CHAIN (t
);
16076 if (chain
&& chain
!= void_type_node
)
16077 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
16078 if (purpose
== TREE_PURPOSE (t
)
16079 && value
== TREE_VALUE (t
)
16080 && chain
== TREE_CHAIN (t
))
16082 return tree_cons (purpose
, value
, chain
);
16087 case ENUMERAL_TYPE
:
16089 case TEMPLATE_TYPE_PARM
:
16090 case TEMPLATE_TEMPLATE_PARM
:
16091 case BOUND_TEMPLATE_TEMPLATE_PARM
:
16092 case TEMPLATE_PARM_INDEX
:
16094 case REFERENCE_TYPE
:
16096 case FUNCTION_TYPE
:
16099 case TYPENAME_TYPE
:
16100 case UNBOUND_CLASS_TEMPLATE
:
16102 case DECLTYPE_TYPE
:
16104 return tsubst (t
, args
, complain
, in_decl
);
16108 /* Fall through. */
16109 case IDENTIFIER_NODE
:
16110 if (IDENTIFIER_CONV_OP_P (t
))
16112 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16113 return make_conv_op_name (new_type
);
16119 /* This is handled by tsubst_copy_and_build. */
16120 gcc_unreachable ();
16124 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16125 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16126 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
16129 case CLEANUP_POINT_EXPR
:
16130 /* We shouldn't have built any of these during initial template
16131 generation. Instead, they should be built during instantiation
16132 in response to the saved STMT_IS_FULL_EXPR_P setting. */
16133 gcc_unreachable ();
16137 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16138 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16139 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16140 r
= build2 (code
, type
, op0
, op1
);
16141 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
16142 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
16143 && !(complain
& tf_error
))
16144 return error_mark_node
;
16148 case EXPR_PACK_EXPANSION
:
16149 error ("invalid use of pack expansion expression");
16150 return error_mark_node
;
16152 case NONTYPE_ARGUMENT_PACK
:
16153 error ("use %<...%> to expand argument pack");
16154 return error_mark_node
;
16157 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
16165 /* Instantiate any typedefs in the type. */
16166 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16167 r
= fold_convert (type
, t
);
16168 gcc_assert (TREE_CODE (r
) == code
);
16173 /* These can sometimes show up in a partial instantiation, but never
16174 involve template parms. */
16175 gcc_assert (!uses_template_parms (t
));
16178 case UNARY_LEFT_FOLD_EXPR
:
16179 return tsubst_unary_left_fold (t
, args
, complain
, in_decl
);
16180 case UNARY_RIGHT_FOLD_EXPR
:
16181 return tsubst_unary_right_fold (t
, args
, complain
, in_decl
);
16182 case BINARY_LEFT_FOLD_EXPR
:
16183 return tsubst_binary_left_fold (t
, args
, complain
, in_decl
);
16184 case BINARY_RIGHT_FOLD_EXPR
:
16185 return tsubst_binary_right_fold (t
, args
, complain
, in_decl
);
16189 case DEBUG_BEGIN_STMT
:
16190 /* ??? There's no point in copying it for now, but maybe some
16191 day it will contain more information, such as a pointer back
16192 to the containing function, inlined copy or so. */
16196 /* We shouldn't get here, but keep going if !flag_checking. */
16198 gcc_unreachable ();
16203 /* Helper function for tsubst_omp_clauses, used for instantiation of
16204 OMP_CLAUSE_DECL of clauses. */
16207 tsubst_omp_clause_decl (tree decl
, tree args
, tsubst_flags_t complain
,
16208 tree in_decl
, tree
*iterator_cache
)
16210 if (decl
== NULL_TREE
)
16213 /* Handle OpenMP iterators. */
16214 if (TREE_CODE (decl
) == TREE_LIST
16215 && TREE_PURPOSE (decl
)
16216 && TREE_CODE (TREE_PURPOSE (decl
)) == TREE_VEC
)
16219 if (iterator_cache
[0] == TREE_PURPOSE (decl
))
16220 ret
= iterator_cache
[1];
16224 begin_scope (sk_omp
, NULL
);
16225 for (tree it
= TREE_PURPOSE (decl
); it
; it
= TREE_CHAIN (it
))
16227 *tp
= copy_node (it
);
16228 TREE_VEC_ELT (*tp
, 0)
16229 = tsubst_decl (TREE_VEC_ELT (it
, 0), args
, complain
);
16230 TREE_VEC_ELT (*tp
, 1)
16231 = tsubst_expr (TREE_VEC_ELT (it
, 1), args
, complain
, in_decl
,
16232 /*integral_constant_expression_p=*/false);
16233 TREE_VEC_ELT (*tp
, 2)
16234 = tsubst_expr (TREE_VEC_ELT (it
, 2), args
, complain
, in_decl
,
16235 /*integral_constant_expression_p=*/false);
16236 TREE_VEC_ELT (*tp
, 3)
16237 = tsubst_expr (TREE_VEC_ELT (it
, 3), args
, complain
, in_decl
,
16238 /*integral_constant_expression_p=*/false);
16239 TREE_CHAIN (*tp
) = NULL_TREE
;
16240 tp
= &TREE_CHAIN (*tp
);
16242 TREE_VEC_ELT (ret
, 5) = poplevel (1, 1, 0);
16243 iterator_cache
[0] = TREE_PURPOSE (decl
);
16244 iterator_cache
[1] = ret
;
16246 return build_tree_list (ret
, tsubst_omp_clause_decl (TREE_VALUE (decl
),
16251 /* Handle an OpenMP array section represented as a TREE_LIST (or
16252 OMP_CLAUSE_DEPEND_KIND). An OMP_CLAUSE_DEPEND (with a depend
16253 kind of OMP_CLAUSE_DEPEND_SINK) can also be represented as a
16254 TREE_LIST. We can handle it exactly the same as an array section
16255 (purpose, value, and a chain), even though the nomenclature
16256 (low_bound, length, etc) is different. */
16257 if (TREE_CODE (decl
) == TREE_LIST
)
16260 = tsubst_expr (TREE_PURPOSE (decl
), args
, complain
, in_decl
,
16261 /*integral_constant_expression_p=*/false);
16262 tree length
= tsubst_expr (TREE_VALUE (decl
), args
, complain
, in_decl
,
16263 /*integral_constant_expression_p=*/false);
16264 tree chain
= tsubst_omp_clause_decl (TREE_CHAIN (decl
), args
, complain
,
16266 if (TREE_PURPOSE (decl
) == low_bound
16267 && TREE_VALUE (decl
) == length
16268 && TREE_CHAIN (decl
) == chain
)
16270 tree ret
= tree_cons (low_bound
, length
, chain
);
16271 OMP_CLAUSE_DEPEND_SINK_NEGATIVE (ret
)
16272 = OMP_CLAUSE_DEPEND_SINK_NEGATIVE (decl
);
16275 tree ret
= tsubst_expr (decl
, args
, complain
, in_decl
,
16276 /*integral_constant_expression_p=*/false);
16277 /* Undo convert_from_reference tsubst_expr could have called. */
16279 && REFERENCE_REF_P (ret
)
16280 && !REFERENCE_REF_P (decl
))
16281 ret
= TREE_OPERAND (ret
, 0);
16285 /* Like tsubst_copy, but specifically for OpenMP clauses. */
16288 tsubst_omp_clauses (tree clauses
, enum c_omp_region_type ort
,
16289 tree args
, tsubst_flags_t complain
, tree in_decl
)
16291 tree new_clauses
= NULL_TREE
, nc
, oc
;
16292 tree linear_no_step
= NULL_TREE
;
16293 tree iterator_cache
[2] = { NULL_TREE
, NULL_TREE
};
16295 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
16297 nc
= copy_node (oc
);
16298 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
16301 switch (OMP_CLAUSE_CODE (nc
))
16303 case OMP_CLAUSE_LASTPRIVATE
:
16304 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
16306 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
16307 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
16308 in_decl
, /*integral_constant_expression_p=*/false);
16309 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
16310 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
16313 case OMP_CLAUSE_PRIVATE
:
16314 case OMP_CLAUSE_SHARED
:
16315 case OMP_CLAUSE_FIRSTPRIVATE
:
16316 case OMP_CLAUSE_COPYIN
:
16317 case OMP_CLAUSE_COPYPRIVATE
:
16318 case OMP_CLAUSE_UNIFORM
:
16319 case OMP_CLAUSE_DEPEND
:
16320 case OMP_CLAUSE_FROM
:
16321 case OMP_CLAUSE_TO
:
16322 case OMP_CLAUSE_MAP
:
16323 case OMP_CLAUSE_NONTEMPORAL
:
16324 case OMP_CLAUSE_USE_DEVICE_PTR
:
16325 case OMP_CLAUSE_IS_DEVICE_PTR
:
16326 case OMP_CLAUSE_INCLUSIVE
:
16327 case OMP_CLAUSE_EXCLUSIVE
:
16328 OMP_CLAUSE_DECL (nc
)
16329 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16330 in_decl
, iterator_cache
);
16332 case OMP_CLAUSE_TILE
:
16333 case OMP_CLAUSE_IF
:
16334 case OMP_CLAUSE_NUM_THREADS
:
16335 case OMP_CLAUSE_SCHEDULE
:
16336 case OMP_CLAUSE_COLLAPSE
:
16337 case OMP_CLAUSE_FINAL
:
16338 case OMP_CLAUSE_DEVICE
:
16339 case OMP_CLAUSE_DIST_SCHEDULE
:
16340 case OMP_CLAUSE_NUM_TEAMS
:
16341 case OMP_CLAUSE_THREAD_LIMIT
:
16342 case OMP_CLAUSE_SAFELEN
:
16343 case OMP_CLAUSE_SIMDLEN
:
16344 case OMP_CLAUSE_NUM_TASKS
:
16345 case OMP_CLAUSE_GRAINSIZE
:
16346 case OMP_CLAUSE_PRIORITY
:
16347 case OMP_CLAUSE_ORDERED
:
16348 case OMP_CLAUSE_HINT
:
16349 case OMP_CLAUSE_NUM_GANGS
:
16350 case OMP_CLAUSE_NUM_WORKERS
:
16351 case OMP_CLAUSE_VECTOR_LENGTH
:
16352 case OMP_CLAUSE_WORKER
:
16353 case OMP_CLAUSE_VECTOR
:
16354 case OMP_CLAUSE_ASYNC
:
16355 case OMP_CLAUSE_WAIT
:
16356 OMP_CLAUSE_OPERAND (nc
, 0)
16357 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
16358 in_decl
, /*integral_constant_expression_p=*/false);
16360 case OMP_CLAUSE_REDUCTION
:
16361 case OMP_CLAUSE_IN_REDUCTION
:
16362 case OMP_CLAUSE_TASK_REDUCTION
:
16363 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
16365 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
16366 if (TREE_CODE (placeholder
) == SCOPE_REF
)
16368 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
16369 complain
, in_decl
);
16370 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
16371 = build_qualified_name (NULL_TREE
, scope
,
16372 TREE_OPERAND (placeholder
, 1),
16376 gcc_assert (identifier_p (placeholder
));
16378 OMP_CLAUSE_DECL (nc
)
16379 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16382 case OMP_CLAUSE_GANG
:
16383 case OMP_CLAUSE_ALIGNED
:
16384 OMP_CLAUSE_DECL (nc
)
16385 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16387 OMP_CLAUSE_OPERAND (nc
, 1)
16388 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
16389 in_decl
, /*integral_constant_expression_p=*/false);
16391 case OMP_CLAUSE_LINEAR
:
16392 OMP_CLAUSE_DECL (nc
)
16393 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16395 if (OMP_CLAUSE_LINEAR_STEP (oc
) == NULL_TREE
)
16397 gcc_assert (!linear_no_step
);
16398 linear_no_step
= nc
;
16400 else if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (oc
))
16401 OMP_CLAUSE_LINEAR_STEP (nc
)
16402 = tsubst_omp_clause_decl (OMP_CLAUSE_LINEAR_STEP (oc
), args
,
16403 complain
, in_decl
, NULL
);
16405 OMP_CLAUSE_LINEAR_STEP (nc
)
16406 = tsubst_expr (OMP_CLAUSE_LINEAR_STEP (oc
), args
, complain
,
16408 /*integral_constant_expression_p=*/false);
16410 case OMP_CLAUSE_NOWAIT
:
16411 case OMP_CLAUSE_DEFAULT
:
16412 case OMP_CLAUSE_UNTIED
:
16413 case OMP_CLAUSE_MERGEABLE
:
16414 case OMP_CLAUSE_INBRANCH
:
16415 case OMP_CLAUSE_NOTINBRANCH
:
16416 case OMP_CLAUSE_PROC_BIND
:
16417 case OMP_CLAUSE_FOR
:
16418 case OMP_CLAUSE_PARALLEL
:
16419 case OMP_CLAUSE_SECTIONS
:
16420 case OMP_CLAUSE_TASKGROUP
:
16421 case OMP_CLAUSE_NOGROUP
:
16422 case OMP_CLAUSE_THREADS
:
16423 case OMP_CLAUSE_SIMD
:
16424 case OMP_CLAUSE_DEFAULTMAP
:
16425 case OMP_CLAUSE_INDEPENDENT
:
16426 case OMP_CLAUSE_AUTO
:
16427 case OMP_CLAUSE_SEQ
:
16428 case OMP_CLAUSE_IF_PRESENT
:
16429 case OMP_CLAUSE_FINALIZE
:
16432 gcc_unreachable ();
16434 if ((ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
)
16435 switch (OMP_CLAUSE_CODE (nc
))
16437 case OMP_CLAUSE_SHARED
:
16438 case OMP_CLAUSE_PRIVATE
:
16439 case OMP_CLAUSE_FIRSTPRIVATE
:
16440 case OMP_CLAUSE_LASTPRIVATE
:
16441 case OMP_CLAUSE_COPYPRIVATE
:
16442 case OMP_CLAUSE_LINEAR
:
16443 case OMP_CLAUSE_REDUCTION
:
16444 case OMP_CLAUSE_IN_REDUCTION
:
16445 case OMP_CLAUSE_TASK_REDUCTION
:
16446 case OMP_CLAUSE_USE_DEVICE_PTR
:
16447 case OMP_CLAUSE_IS_DEVICE_PTR
:
16448 case OMP_CLAUSE_INCLUSIVE
:
16449 case OMP_CLAUSE_EXCLUSIVE
:
16450 /* tsubst_expr on SCOPE_REF results in returning
16451 finish_non_static_data_member result. Undo that here. */
16452 if (TREE_CODE (OMP_CLAUSE_DECL (oc
)) == SCOPE_REF
16453 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (oc
), 1))
16454 == IDENTIFIER_NODE
))
16456 tree t
= OMP_CLAUSE_DECL (nc
);
16459 switch (TREE_CODE (v
))
16461 case COMPONENT_REF
:
16465 case POINTER_PLUS_EXPR
:
16466 v
= TREE_OPERAND (v
, 0);
16469 if (DECL_CONTEXT (v
) == current_function_decl
16470 && DECL_ARTIFICIAL (v
)
16471 && DECL_NAME (v
) == this_identifier
)
16472 OMP_CLAUSE_DECL (nc
) = TREE_OPERAND (t
, 1);
16479 else if (VAR_P (OMP_CLAUSE_DECL (oc
))
16480 && DECL_HAS_VALUE_EXPR_P (OMP_CLAUSE_DECL (oc
))
16481 && DECL_ARTIFICIAL (OMP_CLAUSE_DECL (oc
))
16482 && DECL_LANG_SPECIFIC (OMP_CLAUSE_DECL (oc
))
16483 && DECL_OMP_PRIVATIZED_MEMBER (OMP_CLAUSE_DECL (oc
)))
16485 tree decl
= OMP_CLAUSE_DECL (nc
);
16488 retrofit_lang_decl (decl
);
16489 DECL_OMP_PRIVATIZED_MEMBER (decl
) = 1;
16498 new_clauses
= nreverse (new_clauses
);
16499 if (ort
!= C_ORT_OMP_DECLARE_SIMD
)
16501 new_clauses
= finish_omp_clauses (new_clauses
, ort
);
16502 if (linear_no_step
)
16503 for (nc
= new_clauses
; nc
; nc
= OMP_CLAUSE_CHAIN (nc
))
16504 if (nc
== linear_no_step
)
16506 OMP_CLAUSE_LINEAR_STEP (nc
) = NULL_TREE
;
16510 return new_clauses
;
16513 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
16516 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
16519 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
16521 tree purpose
, value
, chain
;
16526 if (TREE_CODE (t
) != TREE_LIST
)
16527 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
16528 /*function_p=*/false,
16529 /*integral_constant_expression_p=*/false);
16531 if (t
== void_list_node
)
16534 purpose
= TREE_PURPOSE (t
);
16536 purpose
= RECUR (purpose
);
16537 value
= TREE_VALUE (t
);
16540 if (TREE_CODE (value
) != LABEL_DECL
)
16541 value
= RECUR (value
);
16544 value
= lookup_label (DECL_NAME (value
));
16545 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
16546 TREE_USED (value
) = 1;
16549 chain
= TREE_CHAIN (t
);
16550 if (chain
&& chain
!= void_type_node
)
16551 chain
= RECUR (chain
);
16552 return tree_cons (purpose
, value
, chain
);
16556 /* Used to temporarily communicate the list of #pragma omp parallel
16557 clauses to #pragma omp for instantiation if they are combined
16560 static tree
*omp_parallel_combined_clauses
;
16562 static tree
tsubst_decomp_names (tree
, tree
, tree
, tsubst_flags_t
, tree
,
16563 tree
*, unsigned int *);
16565 /* Substitute one OMP_FOR iterator. */
16568 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree
&orig_declv
,
16569 tree initv
, tree condv
, tree incrv
, tree
*clauses
,
16570 tree args
, tsubst_flags_t complain
, tree in_decl
,
16571 bool integral_constant_expression_p
)
16573 #define RECUR(NODE) \
16574 tsubst_expr ((NODE), args, complain, in_decl, \
16575 integral_constant_expression_p)
16576 tree decl
, init
, cond
= NULL_TREE
, incr
= NULL_TREE
;
16579 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
16580 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
16582 decl
= TREE_OPERAND (init
, 0);
16583 init
= TREE_OPERAND (init
, 1);
16584 tree decl_expr
= NULL_TREE
;
16585 bool range_for
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
) == global_namespace
;
16588 bool decomp
= false;
16589 if (decl
!= error_mark_node
&& DECL_HAS_VALUE_EXPR_P (decl
))
16591 tree v
= DECL_VALUE_EXPR (decl
);
16592 if (TREE_CODE (v
) == ARRAY_REF
16593 && VAR_P (TREE_OPERAND (v
, 0))
16594 && DECL_DECOMPOSITION_P (TREE_OPERAND (v
, 0)))
16596 tree decomp_first
= NULL_TREE
;
16597 unsigned decomp_cnt
= 0;
16598 tree d
= tsubst_decl (TREE_OPERAND (v
, 0), args
, complain
);
16599 maybe_push_decl (d
);
16600 d
= tsubst_decomp_names (d
, TREE_OPERAND (v
, 0), args
, complain
,
16601 in_decl
, &decomp_first
, &decomp_cnt
);
16603 if (d
== error_mark_node
)
16604 decl
= error_mark_node
;
16606 for (unsigned int i
= 0; i
< decomp_cnt
; i
++)
16608 if (!DECL_HAS_VALUE_EXPR_P (decomp_first
))
16610 tree v
= build_nt (ARRAY_REF
, d
,
16611 size_int (decomp_cnt
- i
- 1),
16612 NULL_TREE
, NULL_TREE
);
16613 SET_DECL_VALUE_EXPR (decomp_first
, v
);
16614 DECL_HAS_VALUE_EXPR_P (decomp_first
) = 1;
16616 fit_decomposition_lang_decl (decomp_first
, d
);
16617 decomp_first
= DECL_CHAIN (decomp_first
);
16621 decl
= tsubst_decl (decl
, args
, complain
);
16623 maybe_push_decl (decl
);
16625 else if (init
&& TREE_CODE (init
) == DECL_EXPR
)
16627 /* We need to jump through some hoops to handle declarations in the
16628 init-statement, since we might need to handle auto deduction,
16629 but we need to keep control of initialization. */
16631 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
16632 decl
= tsubst_decl (decl
, args
, complain
);
16636 if (TREE_CODE (decl
) == SCOPE_REF
)
16638 decl
= RECUR (decl
);
16639 if (TREE_CODE (decl
) == COMPONENT_REF
)
16643 switch (TREE_CODE (v
))
16645 case COMPONENT_REF
:
16649 case POINTER_PLUS_EXPR
:
16650 v
= TREE_OPERAND (v
, 0);
16653 if (DECL_CONTEXT (v
) == current_function_decl
16654 && DECL_ARTIFICIAL (v
)
16655 && DECL_NAME (v
) == this_identifier
)
16657 decl
= TREE_OPERAND (decl
, 1);
16658 decl
= omp_privatize_field (decl
, false);
16668 decl
= RECUR (decl
);
16670 init
= RECUR (init
);
16672 if (orig_declv
&& OMP_FOR_ORIG_DECLS (t
))
16674 tree o
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t
), i
);
16675 if (TREE_CODE (o
) == TREE_LIST
)
16676 TREE_VEC_ELT (orig_declv
, i
)
16677 = tree_cons (RECUR (TREE_PURPOSE (o
)),
16678 RECUR (TREE_VALUE (o
)),
16681 TREE_VEC_ELT (orig_declv
, i
) = RECUR (o
);
16686 tree this_pre_body
= NULL_TREE
;
16687 tree orig_init
= NULL_TREE
;
16688 tree orig_decl
= NULL_TREE
;
16689 cp_convert_omp_range_for (this_pre_body
, NULL
, decl
, orig_decl
, init
,
16690 orig_init
, cond
, incr
);
16693 if (orig_declv
== NULL_TREE
)
16694 orig_declv
= copy_node (declv
);
16695 TREE_VEC_ELT (orig_declv
, i
) = orig_decl
;
16698 else if (orig_declv
)
16699 TREE_VEC_ELT (orig_declv
, i
) = decl
;
16702 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
16703 if (!range_for
&& auto_node
&& init
)
16705 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
, complain
);
16707 gcc_assert (!type_dependent_expression_p (decl
));
16709 if (!CLASS_TYPE_P (TREE_TYPE (decl
)) || range_for
)
16713 /* Declare the variable, but don't let that initialize it. */
16714 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
16715 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
16717 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
16722 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
16723 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
16724 if (TREE_CODE (incr
) == MODIFY_EXPR
)
16726 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16727 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
16728 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
16729 NOP_EXPR
, rhs
, complain
);
16732 incr
= RECUR (incr
);
16733 if (orig_declv
&& !OMP_FOR_ORIG_DECLS (t
))
16734 TREE_VEC_ELT (orig_declv
, i
) = decl
;
16736 TREE_VEC_ELT (declv
, i
) = decl
;
16737 TREE_VEC_ELT (initv
, i
) = init
;
16738 TREE_VEC_ELT (condv
, i
) = cond
;
16739 TREE_VEC_ELT (incrv
, i
) = incr
;
16745 /* Declare and initialize the variable. */
16753 for (j
= (omp_parallel_combined_clauses
== NULL
? 1 : 0); j
< 2; j
++)
16755 for (pc
= j
? clauses
: omp_parallel_combined_clauses
; *pc
; )
16757 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
16758 && OMP_CLAUSE_DECL (*pc
) == decl
)
16760 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_LASTPRIVATE
16761 && OMP_CLAUSE_DECL (*pc
) == decl
)
16765 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
16767 *pc
= OMP_CLAUSE_CHAIN (c
);
16768 OMP_CLAUSE_CHAIN (c
) = *clauses
;
16771 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_FIRSTPRIVATE
16772 && OMP_CLAUSE_DECL (*pc
) == decl
)
16774 error ("iteration variable %qD should not be firstprivate",
16776 *pc
= OMP_CLAUSE_CHAIN (*pc
);
16778 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_REDUCTION
16779 && OMP_CLAUSE_DECL (*pc
) == decl
)
16781 error ("iteration variable %qD should not be reduction",
16783 *pc
= OMP_CLAUSE_CHAIN (*pc
);
16786 pc
= &OMP_CLAUSE_CHAIN (*pc
);
16791 if (*pc
== NULL_TREE
)
16793 tree c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
16794 OMP_CLAUSE_DECL (c
) = decl
;
16795 c
= finish_omp_clauses (c
, C_ORT_OMP
);
16798 OMP_CLAUSE_CHAIN (c
) = *clauses
;
16803 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
16804 if (COMPARISON_CLASS_P (cond
))
16806 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
16807 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
16808 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
16811 cond
= RECUR (cond
);
16812 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
16813 switch (TREE_CODE (incr
))
16815 case PREINCREMENT_EXPR
:
16816 case PREDECREMENT_EXPR
:
16817 case POSTINCREMENT_EXPR
:
16818 case POSTDECREMENT_EXPR
:
16819 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
16820 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
16823 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
16824 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
16826 tree rhs
= TREE_OPERAND (incr
, 1);
16827 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16828 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
16829 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
16830 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
16831 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
16835 incr
= RECUR (incr
);
16838 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
16839 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
16841 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16842 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
16843 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
16844 TREE_TYPE (decl
), lhs
,
16845 RECUR (TREE_OPERAND (incr
, 2))));
16847 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
16848 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
16849 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
16851 tree rhs
= TREE_OPERAND (incr
, 2);
16852 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16853 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
16854 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
16855 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
16856 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
16860 incr
= RECUR (incr
);
16863 incr
= RECUR (incr
);
16867 if (orig_declv
&& !OMP_FOR_ORIG_DECLS (t
))
16868 TREE_VEC_ELT (orig_declv
, i
) = decl
;
16869 TREE_VEC_ELT (declv
, i
) = decl
;
16870 TREE_VEC_ELT (initv
, i
) = init
;
16871 TREE_VEC_ELT (condv
, i
) = cond
;
16872 TREE_VEC_ELT (incrv
, i
) = incr
;
16877 /* Helper function of tsubst_expr, find OMP_TEAMS inside
16878 of OMP_TARGET's body. */
16881 tsubst_find_omp_teams (tree
*tp
, int *walk_subtrees
, void *)
16883 *walk_subtrees
= 0;
16884 switch (TREE_CODE (*tp
))
16889 case STATEMENT_LIST
:
16890 *walk_subtrees
= 1;
16898 /* Helper function for tsubst_expr. For decomposition declaration
16899 artificial base DECL, which is tsubsted PATTERN_DECL, tsubst
16900 also the corresponding decls representing the identifiers
16901 of the decomposition declaration. Return DECL if successful
16902 or error_mark_node otherwise, set *FIRST to the first decl
16903 in the list chained through DECL_CHAIN and *CNT to the number
16907 tsubst_decomp_names (tree decl
, tree pattern_decl
, tree args
,
16908 tsubst_flags_t complain
, tree in_decl
, tree
*first
,
16911 tree decl2
, decl3
, prev
= decl
;
16913 gcc_assert (DECL_NAME (decl
) == NULL_TREE
);
16914 for (decl2
= DECL_CHAIN (pattern_decl
);
16917 && DECL_DECOMPOSITION_P (decl2
)
16918 && DECL_NAME (decl2
);
16919 decl2
= DECL_CHAIN (decl2
))
16921 if (TREE_TYPE (decl2
) == error_mark_node
&& *cnt
== 0)
16923 gcc_assert (errorcount
);
16924 return error_mark_node
;
16927 gcc_assert (DECL_DECOMP_BASE (decl2
) == pattern_decl
);
16928 gcc_assert (DECL_HAS_VALUE_EXPR_P (decl2
));
16929 tree v
= DECL_VALUE_EXPR (decl2
);
16930 DECL_HAS_VALUE_EXPR_P (decl2
) = 0;
16931 SET_DECL_VALUE_EXPR (decl2
, NULL_TREE
);
16932 decl3
= tsubst (decl2
, args
, complain
, in_decl
);
16933 SET_DECL_VALUE_EXPR (decl2
, v
);
16934 DECL_HAS_VALUE_EXPR_P (decl2
) = 1;
16936 DECL_TEMPLATE_INSTANTIATED (decl3
) = 1;
16939 gcc_assert (errorcount
);
16940 decl
= error_mark_node
;
16943 maybe_push_decl (decl3
);
16944 if (error_operand_p (decl3
))
16945 decl
= error_mark_node
;
16946 else if (decl
!= error_mark_node
16947 && DECL_CHAIN (decl3
) != prev
16950 gcc_assert (errorcount
);
16951 decl
= error_mark_node
;
16960 /* Return the proper local_specialization for init-capture pack DECL. */
16963 lookup_init_capture_pack (tree decl
)
16965 /* We handle normal pack captures by forwarding to the specialization of the
16966 captured parameter. We can't do that for pack init-captures; we need them
16967 to have their own local_specialization. We created the individual
16968 VAR_DECLs (if any) under build_capture_proxy, and we need to collect them
16969 when we process the DECL_EXPR for the pack init-capture in the template.
16970 So, how do we find them? We don't know the capture proxy pack when
16971 building the individual resulting proxies, and we don't know the
16972 individual proxies when instantiating the pack. What we have in common is
16975 So...when we instantiate the FIELD_DECL, we stick the result in
16976 local_specializations. Then at the DECL_EXPR we look up that result, see
16977 how many elements it has, synthesize the names, and look them up. */
16979 tree cname
= DECL_NAME (decl
);
16980 tree val
= DECL_VALUE_EXPR (decl
);
16981 tree field
= TREE_OPERAND (val
, 1);
16982 gcc_assert (TREE_CODE (field
) == FIELD_DECL
);
16983 tree fpack
= retrieve_local_specialization (field
);
16984 if (fpack
== error_mark_node
)
16985 return error_mark_node
;
16988 tree vec
= NULL_TREE
;
16989 tree r
= NULL_TREE
;
16990 if (TREE_CODE (fpack
) == TREE_VEC
)
16992 len
= TREE_VEC_LENGTH (fpack
);
16993 vec
= make_tree_vec (len
);
16994 r
= make_node (NONTYPE_ARGUMENT_PACK
);
16995 SET_ARGUMENT_PACK_ARGS (r
, vec
);
16997 for (int i
= 0; i
< len
; ++i
)
16999 tree ename
= vec
? make_ith_pack_parameter_name (cname
, i
) : cname
;
17000 tree elt
= lookup_name_real (ename
, 0, 0, true, 0, LOOKUP_NORMAL
);
17002 TREE_VEC_ELT (vec
, i
) = elt
;
17009 /* Like tsubst_copy for expressions, etc. but also does semantic
17013 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
17014 bool integral_constant_expression_p
)
17016 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
17017 #define RECUR(NODE) \
17018 tsubst_expr ((NODE), args, complain, in_decl, \
17019 integral_constant_expression_p)
17025 if (t
== NULL_TREE
|| t
== error_mark_node
)
17028 loc
= input_location
;
17029 if (location_t eloc
= cp_expr_location (t
))
17030 input_location
= eloc
;
17031 if (STATEMENT_CODE_P (TREE_CODE (t
)))
17032 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
17034 switch (TREE_CODE (t
))
17036 case STATEMENT_LIST
:
17038 tree_stmt_iterator i
;
17039 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
17040 RECUR (tsi_stmt (i
));
17044 case CTOR_INITIALIZER
:
17045 finish_mem_initializers (tsubst_initializer_list
17046 (TREE_OPERAND (t
, 0), args
));
17050 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
17054 tmp
= RECUR (EXPR_STMT_EXPR (t
));
17055 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
17056 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
17058 finish_expr_stmt (tmp
);
17062 finish_using_directive (USING_STMT_NAMESPACE (t
), /*attribs=*/NULL_TREE
);
17067 tree decl
, pattern_decl
;
17070 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
17071 if (TREE_CODE (decl
) == LABEL_DECL
)
17072 finish_label_decl (DECL_NAME (decl
));
17073 else if (TREE_CODE (decl
) == USING_DECL
)
17075 tree scope
= USING_DECL_SCOPE (decl
);
17076 tree name
= DECL_NAME (decl
);
17078 scope
= tsubst (scope
, args
, complain
, in_decl
);
17079 finish_nonmember_using_decl (scope
, name
);
17081 else if (is_capture_proxy (decl
)
17082 && !DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
17084 /* We're in tsubst_lambda_expr, we've already inserted a new
17085 capture proxy, so look it up and register it. */
17087 if (!DECL_PACK_P (decl
))
17089 inst
= lookup_name_real (DECL_NAME (decl
), /*prefer_type*/0,
17090 /*nonclass*/1, /*block_p=*/true,
17091 /*ns_only*/0, LOOKUP_HIDDEN
);
17092 gcc_assert (inst
!= decl
&& is_capture_proxy (inst
));
17094 else if (is_normal_capture_proxy (decl
))
17096 inst
= (retrieve_local_specialization
17097 (DECL_CAPTURED_VARIABLE (decl
)));
17098 gcc_assert (TREE_CODE (inst
) == NONTYPE_ARGUMENT_PACK
);
17101 inst
= lookup_init_capture_pack (decl
);
17103 register_local_specialization (inst
, decl
);
17106 else if (DECL_PRETTY_FUNCTION_P (decl
))
17107 decl
= make_fname_decl (DECL_SOURCE_LOCATION (decl
),
17109 true/*DECL_PRETTY_FUNCTION_P (decl)*/);
17110 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
17111 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
17112 /* Don't copy the old closure; we'll create a new one in
17113 tsubst_lambda_expr. */
17117 init
= DECL_INITIAL (decl
);
17118 decl
= tsubst (decl
, args
, complain
, in_decl
);
17119 if (decl
!= error_mark_node
)
17121 /* By marking the declaration as instantiated, we avoid
17122 trying to instantiate it. Since instantiate_decl can't
17123 handle local variables, and since we've already done
17124 all that needs to be done, that's the right thing to
17127 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
17128 if (VAR_P (decl
) && !DECL_NAME (decl
)
17129 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
17130 /* Anonymous aggregates are a special case. */
17131 finish_anon_union (decl
);
17132 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
17134 DECL_CONTEXT (decl
) = current_function_decl
;
17135 if (DECL_NAME (decl
) == this_identifier
)
17137 tree lam
= DECL_CONTEXT (current_function_decl
);
17138 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
17139 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
17141 insert_capture_proxy (decl
);
17143 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
17144 /* We already did a pushtag. */;
17145 else if (TREE_CODE (decl
) == FUNCTION_DECL
17146 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
17147 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
17149 DECL_CONTEXT (decl
) = NULL_TREE
;
17151 DECL_CONTEXT (decl
) = current_function_decl
;
17152 cp_check_omp_declare_reduction (decl
);
17156 int const_init
= false;
17157 unsigned int cnt
= 0;
17158 tree first
= NULL_TREE
, ndecl
= error_mark_node
;
17159 maybe_push_decl (decl
);
17162 && DECL_DECOMPOSITION_P (decl
)
17163 && TREE_TYPE (pattern_decl
) != error_mark_node
)
17164 ndecl
= tsubst_decomp_names (decl
, pattern_decl
, args
,
17165 complain
, in_decl
, &first
,
17168 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
17171 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
17174 if (ndecl
!= error_mark_node
)
17175 cp_maybe_mangle_decomp (ndecl
, first
, cnt
);
17177 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
17179 if (ndecl
!= error_mark_node
)
17180 cp_finish_decomp (ndecl
, first
, cnt
);
17189 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
17190 RECUR (FOR_INIT_STMT (t
));
17191 finish_init_stmt (stmt
);
17192 tmp
= RECUR (FOR_COND (t
));
17193 finish_for_cond (tmp
, stmt
, false, 0);
17194 tmp
= RECUR (FOR_EXPR (t
));
17195 finish_for_expr (tmp
, stmt
);
17197 bool prev
= note_iteration_stmt_body_start ();
17198 RECUR (FOR_BODY (t
));
17199 note_iteration_stmt_body_end (prev
);
17201 finish_for_stmt (stmt
);
17204 case RANGE_FOR_STMT
:
17206 /* Construct another range_for, if this is not a final
17207 substitution (for inside inside a generic lambda of a
17208 template). Otherwise convert to a regular for. */
17210 stmt
= (processing_template_decl
17211 ? begin_range_for_stmt (NULL_TREE
, NULL_TREE
)
17212 : begin_for_stmt (NULL_TREE
, NULL_TREE
));
17213 RECUR (RANGE_FOR_INIT_STMT (t
));
17214 decl
= RANGE_FOR_DECL (t
);
17215 decl
= tsubst (decl
, args
, complain
, in_decl
);
17216 maybe_push_decl (decl
);
17217 expr
= RECUR (RANGE_FOR_EXPR (t
));
17219 tree decomp_first
= NULL_TREE
;
17220 unsigned decomp_cnt
= 0;
17221 if (VAR_P (decl
) && DECL_DECOMPOSITION_P (decl
))
17222 decl
= tsubst_decomp_names (decl
, RANGE_FOR_DECL (t
), args
,
17224 &decomp_first
, &decomp_cnt
);
17226 if (processing_template_decl
)
17228 RANGE_FOR_IVDEP (stmt
) = RANGE_FOR_IVDEP (t
);
17229 RANGE_FOR_UNROLL (stmt
) = RANGE_FOR_UNROLL (t
);
17230 finish_range_for_decl (stmt
, decl
, expr
);
17231 if (decomp_first
&& decl
!= error_mark_node
)
17232 cp_finish_decomp (decl
, decomp_first
, decomp_cnt
);
17236 unsigned short unroll
= (RANGE_FOR_UNROLL (t
)
17237 ? tree_to_uhwi (RANGE_FOR_UNROLL (t
)) : 0);
17238 stmt
= cp_convert_range_for (stmt
, decl
, expr
,
17239 decomp_first
, decomp_cnt
,
17240 RANGE_FOR_IVDEP (t
), unroll
);
17243 bool prev
= note_iteration_stmt_body_start ();
17244 RECUR (RANGE_FOR_BODY (t
));
17245 note_iteration_stmt_body_end (prev
);
17246 finish_for_stmt (stmt
);
17251 stmt
= begin_while_stmt ();
17252 tmp
= RECUR (WHILE_COND (t
));
17253 finish_while_stmt_cond (tmp
, stmt
, false, 0);
17255 bool prev
= note_iteration_stmt_body_start ();
17256 RECUR (WHILE_BODY (t
));
17257 note_iteration_stmt_body_end (prev
);
17259 finish_while_stmt (stmt
);
17263 stmt
= begin_do_stmt ();
17265 bool prev
= note_iteration_stmt_body_start ();
17266 RECUR (DO_BODY (t
));
17267 note_iteration_stmt_body_end (prev
);
17269 finish_do_body (stmt
);
17270 tmp
= RECUR (DO_COND (t
));
17271 finish_do_stmt (tmp
, stmt
, false, 0);
17275 stmt
= begin_if_stmt ();
17276 IF_STMT_CONSTEXPR_P (stmt
) = IF_STMT_CONSTEXPR_P (t
);
17277 if (IF_STMT_CONSTEXPR_P (t
))
17278 args
= add_extra_args (IF_STMT_EXTRA_ARGS (t
), args
);
17279 tmp
= RECUR (IF_COND (t
));
17280 tmp
= finish_if_stmt_cond (tmp
, stmt
);
17281 if (IF_STMT_CONSTEXPR_P (t
)
17282 && instantiation_dependent_expression_p (tmp
))
17284 /* We're partially instantiating a generic lambda, but the condition
17285 of the constexpr if is still dependent. Don't substitute into the
17286 branches now, just remember the template arguments. */
17287 do_poplevel (IF_SCOPE (stmt
));
17288 IF_COND (stmt
) = IF_COND (t
);
17289 THEN_CLAUSE (stmt
) = THEN_CLAUSE (t
);
17290 ELSE_CLAUSE (stmt
) = ELSE_CLAUSE (t
);
17291 IF_STMT_EXTRA_ARGS (stmt
) = build_extra_args (t
, args
, complain
);
17295 if (IF_STMT_CONSTEXPR_P (t
) && integer_zerop (tmp
))
17296 /* Don't instantiate the THEN_CLAUSE. */;
17299 tree folded
= fold_non_dependent_expr (tmp
, complain
);
17300 bool inhibit
= integer_zerop (folded
);
17302 ++c_inhibit_evaluation_warnings
;
17303 RECUR (THEN_CLAUSE (t
));
17305 --c_inhibit_evaluation_warnings
;
17307 finish_then_clause (stmt
);
17309 if (IF_STMT_CONSTEXPR_P (t
) && integer_nonzerop (tmp
))
17310 /* Don't instantiate the ELSE_CLAUSE. */;
17311 else if (ELSE_CLAUSE (t
))
17313 tree folded
= fold_non_dependent_expr (tmp
, complain
);
17314 bool inhibit
= integer_nonzerop (folded
);
17315 begin_else_clause (stmt
);
17317 ++c_inhibit_evaluation_warnings
;
17318 RECUR (ELSE_CLAUSE (t
));
17320 --c_inhibit_evaluation_warnings
;
17321 finish_else_clause (stmt
);
17324 finish_if_stmt (stmt
);
17328 if (BIND_EXPR_BODY_BLOCK (t
))
17329 stmt
= begin_function_body ();
17331 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
17332 ? BCS_TRY_BLOCK
: 0);
17334 RECUR (BIND_EXPR_BODY (t
));
17336 if (BIND_EXPR_BODY_BLOCK (t
))
17337 finish_function_body (stmt
);
17339 finish_compound_stmt (stmt
);
17343 finish_break_stmt ();
17346 case CONTINUE_STMT
:
17347 finish_continue_stmt ();
17351 stmt
= begin_switch_stmt ();
17352 tmp
= RECUR (SWITCH_STMT_COND (t
));
17353 finish_switch_cond (tmp
, stmt
);
17354 RECUR (SWITCH_STMT_BODY (t
));
17355 finish_switch_stmt (stmt
);
17358 case CASE_LABEL_EXPR
:
17360 tree decl
= CASE_LABEL (t
);
17361 tree low
= RECUR (CASE_LOW (t
));
17362 tree high
= RECUR (CASE_HIGH (t
));
17363 tree l
= finish_case_label (EXPR_LOCATION (t
), low
, high
);
17364 if (l
&& TREE_CODE (l
) == CASE_LABEL_EXPR
)
17366 tree label
= CASE_LABEL (l
);
17367 FALLTHROUGH_LABEL_P (label
) = FALLTHROUGH_LABEL_P (decl
);
17368 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
17369 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
17376 tree decl
= LABEL_EXPR_LABEL (t
);
17379 label
= finish_label_stmt (DECL_NAME (decl
));
17380 if (TREE_CODE (label
) == LABEL_DECL
)
17381 FALLTHROUGH_LABEL_P (label
) = FALLTHROUGH_LABEL_P (decl
);
17382 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
17383 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
17388 tmp
= GOTO_DESTINATION (t
);
17389 if (TREE_CODE (tmp
) != LABEL_DECL
)
17390 /* Computed goto's must be tsubst'd into. On the other hand,
17391 non-computed gotos must not be; the identifier in question
17392 will have no binding. */
17395 tmp
= DECL_NAME (tmp
);
17396 finish_goto_stmt (tmp
);
17401 tree string
= RECUR (ASM_STRING (t
));
17402 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
17403 complain
, in_decl
);
17404 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
17405 complain
, in_decl
);
17406 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
17407 complain
, in_decl
);
17408 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
17409 complain
, in_decl
);
17410 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
17411 clobbers
, labels
, ASM_INLINE_P (t
));
17412 tree asm_expr
= tmp
;
17413 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
17414 asm_expr
= TREE_OPERAND (asm_expr
, 0);
17415 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
17422 stmt
= begin_try_block ();
17423 RECUR (TRY_STMTS (t
));
17424 finish_cleanup_try_block (stmt
);
17425 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
17429 tree compound_stmt
= NULL_TREE
;
17431 if (FN_TRY_BLOCK_P (t
))
17432 stmt
= begin_function_try_block (&compound_stmt
);
17434 stmt
= begin_try_block ();
17436 RECUR (TRY_STMTS (t
));
17438 if (FN_TRY_BLOCK_P (t
))
17439 finish_function_try_block (stmt
);
17441 finish_try_block (stmt
);
17443 RECUR (TRY_HANDLERS (t
));
17444 if (FN_TRY_BLOCK_P (t
))
17445 finish_function_handler_sequence (stmt
, compound_stmt
);
17447 finish_handler_sequence (stmt
);
17453 tree decl
= HANDLER_PARMS (t
);
17457 decl
= tsubst (decl
, args
, complain
, in_decl
);
17458 /* Prevent instantiate_decl from trying to instantiate
17459 this variable. We've already done all that needs to be
17461 if (decl
!= error_mark_node
)
17462 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
17464 stmt
= begin_handler ();
17465 finish_handler_parms (decl
, stmt
);
17466 RECUR (HANDLER_BODY (t
));
17467 finish_handler (stmt
);
17472 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
17473 if (CLASS_TYPE_P (tmp
))
17475 /* Local classes are not independent templates; they are
17476 instantiated along with their containing function. And this
17477 way we don't have to deal with pushing out of one local class
17478 to instantiate a member of another local class. */
17479 /* Closures are handled by the LAMBDA_EXPR. */
17480 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
17481 complete_type (tmp
);
17482 for (tree fld
= TYPE_FIELDS (tmp
); fld
; fld
= DECL_CHAIN (fld
))
17484 || (TREE_CODE (fld
) == FUNCTION_DECL
17485 && !DECL_ARTIFICIAL (fld
)))
17486 && DECL_TEMPLATE_INSTANTIATION (fld
))
17487 instantiate_decl (fld
, /*defer_ok=*/false,
17488 /*expl_inst_class=*/false);
17492 case STATIC_ASSERT
:
17496 ++c_inhibit_evaluation_warnings
;
17498 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
17501 /*integral_constant_expression_p=*/true);
17502 --c_inhibit_evaluation_warnings
;
17504 finish_static_assert (condition
,
17505 STATIC_ASSERT_MESSAGE (t
),
17506 STATIC_ASSERT_SOURCE_LOCATION (t
),
17507 /*member_p=*/false);
17512 case OACC_PARALLEL
:
17513 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_ACC
, args
, complain
,
17515 stmt
= begin_omp_parallel ();
17516 RECUR (OMP_BODY (t
));
17517 finish_omp_construct (TREE_CODE (t
), stmt
, tmp
);
17521 r
= push_omp_privatization_clauses (OMP_PARALLEL_COMBINED (t
));
17522 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), C_ORT_OMP
, args
,
17523 complain
, in_decl
);
17524 if (OMP_PARALLEL_COMBINED (t
))
17525 omp_parallel_combined_clauses
= &tmp
;
17526 stmt
= begin_omp_parallel ();
17527 RECUR (OMP_PARALLEL_BODY (t
));
17528 gcc_assert (omp_parallel_combined_clauses
== NULL
);
17529 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
17530 = OMP_PARALLEL_COMBINED (t
);
17531 pop_omp_privatization_clauses (r
);
17535 if (OMP_TASK_BODY (t
) == NULL_TREE
)
17537 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), C_ORT_OMP
, args
,
17538 complain
, in_decl
);
17540 OMP_TASK_CLAUSES (t
) = tmp
;
17544 r
= push_omp_privatization_clauses (false);
17545 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), C_ORT_OMP
, args
,
17546 complain
, in_decl
);
17547 stmt
= begin_omp_task ();
17548 RECUR (OMP_TASK_BODY (t
));
17549 finish_omp_task (tmp
, stmt
);
17550 pop_omp_privatization_clauses (r
);
17555 case OMP_DISTRIBUTE
:
17559 tree clauses
, body
, pre_body
;
17560 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
17561 tree orig_declv
= NULL_TREE
;
17562 tree incrv
= NULL_TREE
;
17563 enum c_omp_region_type ort
= C_ORT_OMP
;
17564 bool any_range_for
= false;
17567 if (TREE_CODE (t
) == OACC_LOOP
)
17570 r
= push_omp_privatization_clauses (OMP_FOR_INIT (t
) == NULL_TREE
);
17571 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), ort
, args
, complain
,
17573 if (OMP_FOR_INIT (t
) != NULL_TREE
)
17575 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17576 if (OMP_FOR_ORIG_DECLS (t
))
17577 orig_declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17578 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17579 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17580 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17583 keep_next_level (true);
17584 stmt
= begin_omp_structured_block ();
17586 pre_body
= push_stmt_list ();
17587 RECUR (OMP_FOR_PRE_BODY (t
));
17588 pre_body
= pop_stmt_list (pre_body
);
17590 if (OMP_FOR_INIT (t
) != NULL_TREE
)
17591 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
17593 |= tsubst_omp_for_iterator (t
, i
, declv
, orig_declv
, initv
,
17594 condv
, incrv
, &clauses
, args
,
17596 integral_constant_expression_p
);
17597 omp_parallel_combined_clauses
= NULL
;
17601 gcc_assert (orig_declv
);
17602 body
= begin_omp_structured_block ();
17603 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
17604 if (TREE_VEC_ELT (orig_declv
, i
) != TREE_VEC_ELT (declv
, i
)
17605 && TREE_CODE (TREE_VEC_ELT (orig_declv
, i
)) == TREE_LIST
17606 && TREE_CHAIN (TREE_VEC_ELT (orig_declv
, i
)))
17607 cp_finish_omp_range_for (TREE_VEC_ELT (orig_declv
, i
),
17608 TREE_VEC_ELT (declv
, i
));
17611 body
= push_stmt_list ();
17612 RECUR (OMP_FOR_BODY (t
));
17614 body
= finish_omp_structured_block (body
);
17616 body
= pop_stmt_list (body
);
17618 if (OMP_FOR_INIT (t
) != NULL_TREE
)
17619 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
,
17620 orig_declv
, initv
, condv
, incrv
, body
, pre_body
,
17624 t
= make_node (TREE_CODE (t
));
17625 TREE_TYPE (t
) = void_type_node
;
17626 OMP_FOR_BODY (t
) = body
;
17627 OMP_FOR_PRE_BODY (t
) = pre_body
;
17628 OMP_FOR_CLAUSES (t
) = clauses
;
17629 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
17633 add_stmt (finish_omp_for_block (finish_omp_structured_block (stmt
),
17635 pop_omp_privatization_clauses (r
);
17640 omp_parallel_combined_clauses
= NULL
;
17645 case OMP_TASKGROUP
:
17647 r
= push_omp_privatization_clauses (TREE_CODE (t
) == OMP_TEAMS
17648 && OMP_TEAMS_COMBINED (t
));
17649 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_OMP
, args
, complain
,
17651 if (TREE_CODE (t
) == OMP_TEAMS
)
17653 keep_next_level (true);
17654 stmt
= begin_omp_structured_block ();
17655 RECUR (OMP_BODY (t
));
17656 stmt
= finish_omp_structured_block (stmt
);
17660 stmt
= push_stmt_list ();
17661 RECUR (OMP_BODY (t
));
17662 stmt
= pop_stmt_list (stmt
);
17666 OMP_BODY (t
) = stmt
;
17667 OMP_CLAUSES (t
) = tmp
;
17669 pop_omp_privatization_clauses (r
);
17673 r
= RECUR (OMP_DEPOBJ_DEPOBJ (t
));
17674 if (OMP_DEPOBJ_CLAUSES (t
) && OMP_DEPOBJ_CLAUSES (t
) != error_mark_node
)
17676 enum omp_clause_depend_kind kind
= OMP_CLAUSE_DEPEND_SOURCE
;
17677 if (TREE_CODE (OMP_DEPOBJ_CLAUSES (t
)) == OMP_CLAUSE
)
17679 tmp
= tsubst_omp_clauses (OMP_DEPOBJ_CLAUSES (t
), C_ORT_OMP
,
17680 args
, complain
, in_decl
);
17681 if (tmp
== NULL_TREE
)
17682 tmp
= error_mark_node
;
17686 kind
= (enum omp_clause_depend_kind
)
17687 tree_to_uhwi (OMP_DEPOBJ_CLAUSES (t
));
17690 finish_omp_depobj (EXPR_LOCATION (t
), r
, kind
, tmp
);
17693 finish_omp_depobj (EXPR_LOCATION (t
), r
,
17694 OMP_CLAUSE_DEPEND_SOURCE
,
17695 OMP_DEPOBJ_CLAUSES (t
));
17699 case OMP_TARGET_DATA
:
17701 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), (TREE_CODE (t
) == OACC_DATA
)
17702 ? C_ORT_ACC
: C_ORT_OMP
, args
, complain
,
17704 keep_next_level (true);
17705 stmt
= begin_omp_structured_block ();
17707 RECUR (OMP_BODY (t
));
17708 stmt
= finish_omp_structured_block (stmt
);
17711 OMP_BODY (t
) = stmt
;
17712 OMP_CLAUSES (t
) = tmp
;
17713 if (TREE_CODE (t
) == OMP_TARGET
&& OMP_TARGET_COMBINED (t
))
17715 tree teams
= cp_walk_tree (&stmt
, tsubst_find_omp_teams
, NULL
, NULL
);
17718 /* For combined target teams, ensure the num_teams and
17719 thread_limit clause expressions are evaluated on the host,
17720 before entering the target construct. */
17722 for (c
= OMP_TEAMS_CLAUSES (teams
);
17723 c
; c
= OMP_CLAUSE_CHAIN (c
))
17724 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
17725 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
17726 && TREE_CODE (OMP_CLAUSE_OPERAND (c
, 0)) != INTEGER_CST
)
17728 tree expr
= OMP_CLAUSE_OPERAND (c
, 0);
17729 expr
= force_target_expr (TREE_TYPE (expr
), expr
, tf_none
);
17730 if (expr
== error_mark_node
)
17732 tmp
= TARGET_EXPR_SLOT (expr
);
17734 OMP_CLAUSE_OPERAND (c
, 0) = expr
;
17735 tree tc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
17736 OMP_CLAUSE_FIRSTPRIVATE
);
17737 OMP_CLAUSE_DECL (tc
) = tmp
;
17738 OMP_CLAUSE_CHAIN (tc
) = OMP_TARGET_CLAUSES (t
);
17739 OMP_TARGET_CLAUSES (t
) = tc
;
17748 tmp
= tsubst_omp_clauses (OACC_DECLARE_CLAUSES (t
), C_ORT_ACC
, args
,
17749 complain
, in_decl
);
17750 OACC_DECLARE_CLAUSES (t
) = tmp
;
17754 case OMP_TARGET_UPDATE
:
17755 case OMP_TARGET_ENTER_DATA
:
17756 case OMP_TARGET_EXIT_DATA
:
17757 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_OMP
, args
,
17758 complain
, in_decl
);
17760 OMP_STANDALONE_CLAUSES (t
) = tmp
;
17764 case OACC_ENTER_DATA
:
17765 case OACC_EXIT_DATA
:
17767 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_ACC
, args
,
17768 complain
, in_decl
);
17770 OMP_STANDALONE_CLAUSES (t
) = tmp
;
17775 tmp
= tsubst_omp_clauses (OMP_ORDERED_CLAUSES (t
), C_ORT_OMP
, args
,
17776 complain
, in_decl
);
17777 stmt
= push_stmt_list ();
17778 RECUR (OMP_BODY (t
));
17779 stmt
= pop_stmt_list (stmt
);
17782 OMP_BODY (t
) = stmt
;
17783 OMP_ORDERED_CLAUSES (t
) = tmp
;
17789 stmt
= push_stmt_list ();
17790 RECUR (OMP_BODY (t
));
17791 stmt
= pop_stmt_list (stmt
);
17794 OMP_BODY (t
) = stmt
;
17799 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
17801 if (TREE_CODE (TREE_OPERAND (t
, 0)) == OMP_CLAUSE
)
17802 tmp
= tsubst_omp_clauses (TREE_OPERAND (t
, 0), C_ORT_OMP
, args
,
17803 complain
, in_decl
);
17804 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
17806 tree op1
= TREE_OPERAND (t
, 1);
17807 tree rhs1
= NULL_TREE
;
17809 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
17811 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
17812 op1
= TREE_OPERAND (op1
, 1);
17814 lhs
= RECUR (TREE_OPERAND (op1
, 0));
17815 rhs
= RECUR (TREE_OPERAND (op1
, 1));
17816 finish_omp_atomic (EXPR_LOCATION (t
), OMP_ATOMIC
, TREE_CODE (op1
),
17817 lhs
, rhs
, NULL_TREE
, NULL_TREE
, rhs1
, tmp
,
17818 OMP_ATOMIC_MEMORY_ORDER (t
));
17822 tree op1
= TREE_OPERAND (t
, 1);
17823 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
17824 tree rhs1
= NULL_TREE
;
17825 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
17826 enum tree_code opcode
= NOP_EXPR
;
17827 if (code
== OMP_ATOMIC_READ
)
17829 v
= RECUR (TREE_OPERAND (op1
, 0));
17830 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
17832 else if (code
== OMP_ATOMIC_CAPTURE_OLD
17833 || code
== OMP_ATOMIC_CAPTURE_NEW
)
17835 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
17836 v
= RECUR (TREE_OPERAND (op1
, 0));
17837 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
17838 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
17840 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
17841 op11
= TREE_OPERAND (op11
, 1);
17843 lhs
= RECUR (TREE_OPERAND (op11
, 0));
17844 rhs
= RECUR (TREE_OPERAND (op11
, 1));
17845 opcode
= TREE_CODE (op11
);
17846 if (opcode
== MODIFY_EXPR
)
17852 lhs
= RECUR (TREE_OPERAND (op1
, 0));
17853 rhs
= RECUR (TREE_OPERAND (op1
, 1));
17855 finish_omp_atomic (EXPR_LOCATION (t
), code
, opcode
, lhs
, rhs
, v
,
17856 lhs1
, rhs1
, tmp
, OMP_ATOMIC_MEMORY_ORDER (t
));
17860 case TRANSACTION_EXPR
:
17863 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
17864 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
17866 if (TRANSACTION_EXPR_IS_STMT (t
))
17868 tree body
= TRANSACTION_EXPR_BODY (t
);
17869 tree noex
= NULL_TREE
;
17870 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
17872 noex
= MUST_NOT_THROW_COND (body
);
17873 if (noex
== NULL_TREE
)
17874 noex
= boolean_true_node
;
17875 body
= TREE_OPERAND (body
, 0);
17877 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
17879 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
17883 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
17884 RECUR (TRANSACTION_EXPR_BODY (t
)),
17891 case MUST_NOT_THROW_EXPR
:
17893 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17894 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
17895 RETURN (build_must_not_throw_expr (op0
, cond
));
17898 case EXPR_PACK_EXPANSION
:
17899 error ("invalid use of pack expansion expression");
17900 RETURN (error_mark_node
);
17902 case NONTYPE_ARGUMENT_PACK
:
17903 error ("use %<...%> to expand argument pack");
17904 RETURN (error_mark_node
);
17906 case COMPOUND_EXPR
:
17907 tmp
= RECUR (TREE_OPERAND (t
, 0));
17908 if (tmp
== NULL_TREE
)
17909 /* If the first operand was a statement, we're done with it. */
17910 RETURN (RECUR (TREE_OPERAND (t
, 1)));
17911 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
17912 RECUR (TREE_OPERAND (t
, 1)),
17915 case ANNOTATE_EXPR
:
17916 tmp
= RECUR (TREE_OPERAND (t
, 0));
17917 RETURN (build3_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
17918 TREE_TYPE (tmp
), tmp
,
17919 RECUR (TREE_OPERAND (t
, 1)),
17920 RECUR (TREE_OPERAND (t
, 2))));
17923 RETURN (add_stmt (copy_node (t
)));
17926 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
17928 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
17929 /*function_p=*/false,
17930 integral_constant_expression_p
));
17933 RETURN (NULL_TREE
);
17935 input_location
= loc
;
17941 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
17942 function. For description of the body see comment above
17943 cp_parser_omp_declare_reduction_exprs. */
17946 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
17948 if (t
== NULL_TREE
|| t
== error_mark_node
)
17951 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
17953 tree_stmt_iterator tsi
;
17956 memset (stmts
, 0, sizeof stmts
);
17957 for (i
= 0, tsi
= tsi_start (t
);
17958 i
< 7 && !tsi_end_p (tsi
);
17959 i
++, tsi_next (&tsi
))
17960 stmts
[i
] = tsi_stmt (tsi
);
17961 gcc_assert (tsi_end_p (tsi
));
17965 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
17966 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
17967 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
17968 args
, complain
, in_decl
);
17969 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
17970 args
, complain
, in_decl
);
17971 DECL_CONTEXT (omp_out
) = current_function_decl
;
17972 DECL_CONTEXT (omp_in
) = current_function_decl
;
17973 keep_next_level (true);
17974 tree block
= begin_omp_structured_block ();
17975 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
17976 block
= finish_omp_structured_block (block
);
17977 block
= maybe_cleanup_point_expr_void (block
);
17978 add_decl_expr (omp_out
);
17979 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
17980 TREE_NO_WARNING (omp_out
) = 1;
17981 add_decl_expr (omp_in
);
17982 finish_expr_stmt (block
);
17986 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
17987 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
17988 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
17989 args
, complain
, in_decl
);
17990 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
17991 args
, complain
, in_decl
);
17992 DECL_CONTEXT (omp_priv
) = current_function_decl
;
17993 DECL_CONTEXT (omp_orig
) = current_function_decl
;
17994 keep_next_level (true);
17995 tree block
= begin_omp_structured_block ();
17996 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
17997 block
= finish_omp_structured_block (block
);
17998 block
= maybe_cleanup_point_expr_void (block
);
17999 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
18000 add_decl_expr (omp_priv
);
18001 add_decl_expr (omp_orig
);
18002 finish_expr_stmt (block
);
18004 add_decl_expr (omp_orig
);
18008 /* T is a postfix-expression that is not being used in a function
18009 call. Return the substituted version of T. */
18012 tsubst_non_call_postfix_expression (tree t
, tree args
,
18013 tsubst_flags_t complain
,
18016 if (TREE_CODE (t
) == SCOPE_REF
)
18017 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
18018 /*done=*/false, /*address_p=*/false);
18020 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
18021 /*function_p=*/false,
18022 /*integral_constant_expression_p=*/false);
18027 /* T is a LAMBDA_EXPR. Generate a new LAMBDA_EXPR for the current
18028 instantiation context. Instantiating a pack expansion containing a lambda
18029 might result in multiple lambdas all based on the same lambda in the
18033 tsubst_lambda_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
18035 tree oldfn
= lambda_function (t
);
18038 /* If we have already specialized this lambda expr, reuse it. See
18040 if (local_specializations
)
18041 if (tree r
= retrieve_local_specialization (t
))
18044 tree r
= build_lambda_expr ();
18046 if (local_specializations
)
18047 register_local_specialization (r
, t
);
18049 LAMBDA_EXPR_LOCATION (r
)
18050 = LAMBDA_EXPR_LOCATION (t
);
18051 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
18052 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
18053 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
18054 LAMBDA_EXPR_INSTANTIATED (r
) = true;
18056 if (LAMBDA_EXPR_EXTRA_SCOPE (t
) == NULL_TREE
)
18057 /* A lambda in a default argument outside a class gets no
18058 LAMBDA_EXPR_EXTRA_SCOPE, as specified by the ABI. But
18059 tsubst_default_argument calls start_lambda_scope, so we need to
18060 specifically ignore it here, and use the global scope. */
18061 record_null_lambda_scope (r
);
18063 record_lambda_scope (r
);
18065 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
18066 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
18068 vec
<tree
,va_gc
>* field_packs
= NULL
;
18070 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
); cap
;
18071 cap
= TREE_CHAIN (cap
))
18073 tree ofield
= TREE_PURPOSE (cap
);
18074 if (PACK_EXPANSION_P (ofield
))
18075 ofield
= PACK_EXPANSION_PATTERN (ofield
);
18076 tree field
= tsubst_decl (ofield
, args
, complain
);
18078 if (DECL_PACK_P (ofield
) && !DECL_NORMAL_CAPTURE_P (ofield
))
18080 /* Remember these for when we've pushed local_specializations. */
18081 vec_safe_push (field_packs
, ofield
);
18082 vec_safe_push (field_packs
, field
);
18085 if (field
== error_mark_node
)
18086 return error_mark_node
;
18088 tree init
= TREE_VALUE (cap
);
18089 if (PACK_EXPANSION_P (init
))
18090 init
= tsubst_pack_expansion (init
, args
, complain
, in_decl
);
18092 init
= tsubst_copy_and_build (init
, args
, complain
, in_decl
,
18093 /*fn*/false, /*constexpr*/false);
18095 if (TREE_CODE (field
) == TREE_VEC
)
18097 int len
= TREE_VEC_LENGTH (field
);
18098 gcc_assert (TREE_CODE (init
) == TREE_VEC
18099 && TREE_VEC_LENGTH (init
) == len
);
18100 for (int i
= 0; i
< len
; ++i
)
18101 LAMBDA_EXPR_CAPTURE_LIST (r
)
18102 = tree_cons (TREE_VEC_ELT (field
, i
),
18103 TREE_VEC_ELT (init
, i
),
18104 LAMBDA_EXPR_CAPTURE_LIST (r
));
18108 LAMBDA_EXPR_CAPTURE_LIST (r
)
18109 = tree_cons (field
, init
, LAMBDA_EXPR_CAPTURE_LIST (r
));
18111 if (id_equal (DECL_NAME (field
), "__this"))
18112 LAMBDA_EXPR_THIS_CAPTURE (r
) = field
;
18116 tree type
= begin_lambda_type (r
);
18117 if (type
== error_mark_node
)
18118 return error_mark_node
;
18120 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
18121 determine_visibility (TYPE_NAME (type
));
18123 register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (r
));
18125 tree oldtmpl
= (generic_lambda_fn_p (oldfn
)
18126 ? DECL_TI_TEMPLATE (oldfn
)
18129 tree fntype
= static_fn_type (oldfn
);
18131 ++processing_template_decl
;
18132 fntype
= tsubst (fntype
, args
, complain
, in_decl
);
18134 --processing_template_decl
;
18136 if (fntype
== error_mark_node
)
18137 r
= error_mark_node
;
18140 /* The body of a lambda-expression is not a subexpression of the
18141 enclosing expression. Parms are to have DECL_CHAIN tsubsted,
18142 which would be skipped if cp_unevaluated_operand. */
18145 /* Fix the type of 'this'. */
18146 fntype
= build_memfn_type (fntype
, type
,
18147 type_memfn_quals (fntype
),
18148 type_memfn_rqual (fntype
));
18152 tmpl
= tsubst_template_decl (oldtmpl
, args
, complain
, fntype
);
18153 fn
= DECL_TEMPLATE_RESULT (tmpl
);
18154 finish_member_declaration (tmpl
);
18159 fn
= tsubst_function_decl (oldfn
, args
, complain
, fntype
);
18160 finish_member_declaration (fn
);
18163 /* Let finish_function set this. */
18164 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
18166 bool nested
= cfun
;
18168 push_function_context ();
18170 /* Still increment function_depth so that we don't GC in the
18171 middle of an expression. */
18174 local_specialization_stack
s (lss_copy
);
18176 tree body
= start_lambda_function (fn
, r
);
18178 /* Now record them for lookup_init_capture_pack. */
18179 int fplen
= vec_safe_length (field_packs
);
18180 for (int i
= 0; i
< fplen
; )
18182 tree pack
= (*field_packs
)[i
++];
18183 tree inst
= (*field_packs
)[i
++];
18184 register_local_specialization (inst
, pack
);
18186 release_tree_vector (field_packs
);
18188 register_parameter_specializations (oldfn
, fn
);
18192 /* We might not partially instantiate some parts of the function, so
18193 copy these flags from the original template. */
18194 language_function
*ol
= DECL_STRUCT_FUNCTION (oldfn
)->language
;
18195 current_function_returns_value
= ol
->returns_value
;
18196 current_function_returns_null
= ol
->returns_null
;
18197 current_function_returns_abnormally
= ol
->returns_abnormally
;
18198 current_function_infinite_loop
= ol
->infinite_loop
;
18201 /* [temp.deduct] A lambda-expression appearing in a function type or a
18202 template parameter is not considered part of the immediate context for
18203 the purposes of template argument deduction. */
18204 complain
= tf_warning_or_error
;
18206 tsubst_expr (DECL_SAVED_TREE (oldfn
), args
, complain
, r
,
18207 /*constexpr*/false);
18209 finish_lambda_function (body
);
18212 pop_function_context ();
18216 /* The capture list was built up in reverse order; fix that now. */
18217 LAMBDA_EXPR_CAPTURE_LIST (r
)
18218 = nreverse (LAMBDA_EXPR_CAPTURE_LIST (r
));
18220 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
18222 maybe_add_lambda_conv_op (type
);
18225 finish_struct (type
, /*attr*/NULL_TREE
);
18227 insert_pending_capture_proxies ();
18232 /* Like tsubst but deals with expressions and performs semantic
18233 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
18236 tsubst_copy_and_build (tree t
,
18238 tsubst_flags_t complain
,
18241 bool integral_constant_expression_p
)
18243 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
18244 #define RECUR(NODE) \
18245 tsubst_copy_and_build (NODE, args, complain, in_decl, \
18246 /*function_p=*/false, \
18247 integral_constant_expression_p)
18252 if (t
== NULL_TREE
|| t
== error_mark_node
)
18255 loc
= input_location
;
18256 if (location_t eloc
= cp_expr_location (t
))
18257 input_location
= eloc
;
18259 /* N3276 decltype magic only applies to calls at the top level or on the
18260 right side of a comma. */
18261 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
18262 complain
&= ~tf_decltype
;
18264 switch (TREE_CODE (t
))
18268 /* Fall through. */
18269 case IDENTIFIER_NODE
:
18273 bool non_integral_constant_expression_p
;
18274 const char *error_msg
;
18276 if (IDENTIFIER_CONV_OP_P (t
))
18278 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18279 t
= make_conv_op_name (new_type
);
18282 /* Look up the name. */
18283 decl
= lookup_name (t
);
18285 /* By convention, expressions use ERROR_MARK_NODE to indicate
18286 failure, not NULL_TREE. */
18287 if (decl
== NULL_TREE
)
18288 decl
= error_mark_node
;
18290 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
18292 integral_constant_expression_p
,
18293 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
18294 &non_integral_constant_expression_p
,
18295 /*template_p=*/false,
18297 /*address_p=*/false,
18298 /*template_arg_p=*/false,
18303 if (!function_p
&& identifier_p (decl
))
18305 if (complain
& tf_error
)
18306 unqualified_name_lookup_error (decl
);
18307 decl
= error_mark_node
;
18312 case TEMPLATE_ID_EXPR
:
18315 tree templ
= RECUR (TREE_OPERAND (t
, 0));
18316 tree targs
= TREE_OPERAND (t
, 1);
18319 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
18320 if (targs
== error_mark_node
)
18321 RETURN (error_mark_node
);
18323 if (TREE_CODE (templ
) == SCOPE_REF
)
18325 tree name
= TREE_OPERAND (templ
, 1);
18326 tree tid
= lookup_template_function (name
, targs
);
18327 TREE_OPERAND (templ
, 1) = tid
;
18331 if (variable_template_p (templ
))
18332 RETURN (lookup_and_finish_template_variable (templ
, targs
, complain
));
18334 if (TREE_CODE (templ
) == COMPONENT_REF
)
18336 object
= TREE_OPERAND (templ
, 0);
18337 templ
= TREE_OPERAND (templ
, 1);
18340 object
= NULL_TREE
;
18341 templ
= lookup_template_function (templ
, targs
);
18344 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
18345 object
, templ
, NULL_TREE
));
18347 RETURN (baselink_for_fns (templ
));
18352 tree r
= RECUR (TREE_OPERAND (t
, 0));
18354 if (REFERENCE_REF_P (t
))
18356 /* A type conversion to reference type will be enclosed in
18357 such an indirect ref, but the substitution of the cast
18358 will have also added such an indirect ref. */
18359 r
= convert_from_reference (r
);
18362 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
18363 complain
|decltype_flag
);
18365 if (REF_PARENTHESIZED_P (t
))
18366 r
= force_paren_expr (r
);
18373 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18374 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18375 RETURN (build_nop (type
, op0
));
18378 case IMPLICIT_CONV_EXPR
:
18380 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18381 tree expr
= RECUR (TREE_OPERAND (t
, 0));
18382 if (dependent_type_p (type
) || type_dependent_expression_p (expr
))
18384 retval
= copy_node (t
);
18385 TREE_TYPE (retval
) = type
;
18386 TREE_OPERAND (retval
, 0) = expr
;
18389 if (IMPLICIT_CONV_EXPR_NONTYPE_ARG (t
))
18390 /* We'll pass this to convert_nontype_argument again, we don't need
18391 to actually perform any conversion here. */
18393 int flags
= LOOKUP_IMPLICIT
;
18394 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
18395 flags
= LOOKUP_NORMAL
;
18396 if (IMPLICIT_CONV_EXPR_BRACED_INIT (t
))
18397 flags
|= LOOKUP_NO_NARROWING
;
18398 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
18404 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18405 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18406 if (op0
== error_mark_node
)
18407 RETURN (error_mark_node
);
18408 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
18412 case REINTERPRET_CAST_EXPR
:
18413 case CONST_CAST_EXPR
:
18414 case DYNAMIC_CAST_EXPR
:
18415 case STATIC_CAST_EXPR
:
18418 tree op
, r
= NULL_TREE
;
18420 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18421 if (integral_constant_expression_p
18422 && !cast_valid_in_integral_constant_expression_p (type
))
18424 if (complain
& tf_error
)
18425 error ("a cast to a type other than an integral or "
18426 "enumeration type cannot appear in a constant-expression");
18427 RETURN (error_mark_node
);
18430 op
= RECUR (TREE_OPERAND (t
, 0));
18432 warning_sentinel
s(warn_useless_cast
);
18433 warning_sentinel
s2(warn_ignored_qualifiers
);
18434 switch (TREE_CODE (t
))
18437 r
= build_functional_cast (type
, op
, complain
);
18439 case REINTERPRET_CAST_EXPR
:
18440 r
= build_reinterpret_cast (type
, op
, complain
);
18442 case CONST_CAST_EXPR
:
18443 r
= build_const_cast (type
, op
, complain
);
18445 case DYNAMIC_CAST_EXPR
:
18446 r
= build_dynamic_cast (type
, op
, complain
);
18448 case STATIC_CAST_EXPR
:
18449 r
= build_static_cast (type
, op
, complain
);
18452 gcc_unreachable ();
18458 case POSTDECREMENT_EXPR
:
18459 case POSTINCREMENT_EXPR
:
18460 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
18461 args
, complain
, in_decl
);
18462 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
18463 complain
|decltype_flag
));
18465 case PREDECREMENT_EXPR
:
18466 case PREINCREMENT_EXPR
:
18470 case TRUTH_NOT_EXPR
:
18471 case UNARY_PLUS_EXPR
: /* Unary + */
18472 case REALPART_EXPR
:
18473 case IMAGPART_EXPR
:
18474 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
18475 RECUR (TREE_OPERAND (t
, 0)),
18476 complain
|decltype_flag
));
18478 case FIX_TRUNC_EXPR
:
18479 gcc_unreachable ();
18482 op1
= TREE_OPERAND (t
, 0);
18483 if (TREE_CODE (op1
) == LABEL_DECL
)
18484 RETURN (finish_label_address_expr (DECL_NAME (op1
),
18485 EXPR_LOCATION (op1
)));
18486 if (TREE_CODE (op1
) == SCOPE_REF
)
18487 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
18488 /*done=*/true, /*address_p=*/true);
18490 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
18492 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
18493 complain
|decltype_flag
));
18498 case TRUNC_DIV_EXPR
:
18499 case CEIL_DIV_EXPR
:
18500 case FLOOR_DIV_EXPR
:
18501 case ROUND_DIV_EXPR
:
18502 case EXACT_DIV_EXPR
:
18506 case TRUNC_MOD_EXPR
:
18507 case FLOOR_MOD_EXPR
:
18508 case TRUTH_ANDIF_EXPR
:
18509 case TRUTH_ORIF_EXPR
:
18510 case TRUTH_AND_EXPR
:
18511 case TRUTH_OR_EXPR
:
18527 warning_sentinel
s1(warn_type_limits
);
18528 warning_sentinel
s2(warn_div_by_zero
);
18529 warning_sentinel
s3(warn_logical_op
);
18530 warning_sentinel
s4(warn_tautological_compare
);
18531 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18532 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18533 tree r
= build_x_binary_op
18534 (input_location
, TREE_CODE (t
),
18536 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
18538 : TREE_CODE (TREE_OPERAND (t
, 0))),
18540 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
18542 : TREE_CODE (TREE_OPERAND (t
, 1))),
18544 complain
|decltype_flag
);
18545 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
18546 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
18551 case POINTER_PLUS_EXPR
:
18553 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18554 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18555 RETURN (fold_build_pointer_plus (op0
, op1
));
18559 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
18560 /*address_p=*/false));
18562 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
18563 args
, complain
, in_decl
);
18564 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
18565 RECUR (TREE_OPERAND (t
, 1)),
18566 complain
|decltype_flag
));
18569 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
18570 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
18571 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
18578 op1
= TREE_OPERAND (t
, 0);
18579 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
18580 op1
= TREE_TYPE (op1
);
18581 bool std_alignof
= (TREE_CODE (t
) == ALIGNOF_EXPR
18582 && ALIGNOF_EXPR_STD_P (t
));
18585 /* When there are no ARGS, we are trying to evaluate a
18586 non-dependent expression from the parser. Trying to do
18587 the substitutions may not work. */
18589 op1
= TREE_TYPE (op1
);
18593 ++cp_unevaluated_operand
;
18594 ++c_inhibit_evaluation_warnings
;
18596 op1
= tsubst (op1
, args
, complain
, in_decl
);
18598 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
18599 /*function_p=*/false,
18600 /*integral_constant_expression_p=*/
18602 --cp_unevaluated_operand
;
18603 --c_inhibit_evaluation_warnings
;
18606 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
), std_alignof
,
18607 complain
& tf_error
);
18609 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
18610 complain
& tf_error
);
18611 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
18613 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
18615 if (!processing_template_decl
&& TYPE_P (op1
))
18617 r
= build_min (SIZEOF_EXPR
, size_type_node
,
18618 build1 (NOP_EXPR
, op1
, error_mark_node
));
18619 SIZEOF_EXPR_TYPE_P (r
) = 1;
18622 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
18623 TREE_SIDE_EFFECTS (r
) = 0;
18624 TREE_READONLY (r
) = 1;
18626 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
18631 case AT_ENCODE_EXPR
:
18633 op1
= TREE_OPERAND (t
, 0);
18634 ++cp_unevaluated_operand
;
18635 ++c_inhibit_evaluation_warnings
;
18636 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
18637 /*function_p=*/false,
18638 /*integral_constant_expression_p=*/false);
18639 --cp_unevaluated_operand
;
18640 --c_inhibit_evaluation_warnings
;
18641 RETURN (objc_build_encode_expr (op1
));
18644 case NOEXCEPT_EXPR
:
18645 op1
= TREE_OPERAND (t
, 0);
18646 ++cp_unevaluated_operand
;
18647 ++c_inhibit_evaluation_warnings
;
18648 ++cp_noexcept_operand
;
18649 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
18650 /*function_p=*/false,
18651 /*integral_constant_expression_p=*/false);
18652 --cp_unevaluated_operand
;
18653 --c_inhibit_evaluation_warnings
;
18654 --cp_noexcept_operand
;
18655 RETURN (finish_noexcept_expr (op1
, complain
));
18659 warning_sentinel
s(warn_div_by_zero
);
18660 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
18661 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
18662 tree r
= build_x_modify_expr
18663 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
18664 complain
|decltype_flag
);
18665 /* TREE_NO_WARNING must be set if either the expression was
18666 parenthesized or it uses an operator such as >>= rather
18667 than plain assignment. In the former case, it was already
18668 set and must be copied. In the latter case,
18669 build_x_modify_expr sets it and it must not be reset
18671 if (TREE_NO_WARNING (t
))
18672 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
18678 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
18679 args
, complain
, in_decl
);
18680 /* Remember that there was a reference to this entity. */
18682 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
18683 RETURN (error_mark_node
);
18684 RETURN (build_x_arrow (input_location
, op1
, complain
));
18688 tree placement
= RECUR (TREE_OPERAND (t
, 0));
18689 tree init
= RECUR (TREE_OPERAND (t
, 3));
18690 vec
<tree
, va_gc
> *placement_vec
;
18691 vec
<tree
, va_gc
> *init_vec
;
18694 if (placement
== NULL_TREE
)
18695 placement_vec
= NULL
;
18698 placement_vec
= make_tree_vector ();
18699 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
18700 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
18703 /* If there was an initializer in the original tree, but it
18704 instantiated to an empty list, then we should pass a
18705 non-NULL empty vector to tell build_new that it was an
18706 empty initializer() rather than no initializer. This can
18707 only happen when the initializer is a pack expansion whose
18708 parameter packs are of length zero. */
18709 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
18713 init_vec
= make_tree_vector ();
18714 if (init
== void_node
)
18715 gcc_assert (init_vec
!= NULL
);
18718 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
18719 vec_safe_push (init_vec
, TREE_VALUE (init
));
18723 /* Avoid passing an enclosing decl to valid_array_size_p. */
18724 in_decl
= NULL_TREE
;
18726 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
18727 tree op2
= RECUR (TREE_OPERAND (t
, 2));
18728 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
18729 NEW_EXPR_USE_GLOBAL (t
),
18732 if (placement_vec
!= NULL
)
18733 release_tree_vector (placement_vec
);
18734 if (init_vec
!= NULL
)
18735 release_tree_vector (init_vec
);
18742 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18743 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18744 RETURN (delete_sanity (op0
, op1
,
18745 DELETE_EXPR_USE_VEC (t
),
18746 DELETE_EXPR_USE_GLOBAL (t
),
18750 case COMPOUND_EXPR
:
18752 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
18753 complain
& ~tf_decltype
, in_decl
,
18754 /*function_p=*/false,
18755 integral_constant_expression_p
);
18756 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
18758 RECUR (TREE_OPERAND (t
, 1)),
18759 complain
|decltype_flag
));
18765 unsigned int nargs
, i
;
18770 function
= CALL_EXPR_FN (t
);
18771 /* Internal function with no arguments. */
18772 if (function
== NULL_TREE
&& call_expr_nargs (t
) == 0)
18775 /* When we parsed the expression, we determined whether or
18776 not Koenig lookup should be performed. */
18777 koenig_p
= KOENIG_LOOKUP_P (t
);
18778 if (function
== NULL_TREE
)
18781 qualified_p
= false;
18783 else if (TREE_CODE (function
) == SCOPE_REF
)
18785 qualified_p
= true;
18786 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
18788 /*address_p=*/false);
18790 else if (koenig_p
&& identifier_p (function
))
18792 /* Do nothing; calling tsubst_copy_and_build on an identifier
18793 would incorrectly perform unqualified lookup again.
18795 Note that we can also have an IDENTIFIER_NODE if the earlier
18796 unqualified lookup found a member function; in that case
18797 koenig_p will be false and we do want to do the lookup
18798 again to find the instantiated member function.
18800 FIXME but doing that causes c++/15272, so we need to stop
18801 using IDENTIFIER_NODE in that situation. */
18802 qualified_p
= false;
18806 if (TREE_CODE (function
) == COMPONENT_REF
)
18808 tree op
= TREE_OPERAND (function
, 1);
18810 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
18811 || (BASELINK_P (op
)
18812 && BASELINK_QUALIFIED_P (op
)));
18815 qualified_p
= false;
18817 if (TREE_CODE (function
) == ADDR_EXPR
18818 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
18819 /* Avoid error about taking the address of a constructor. */
18820 function
= TREE_OPERAND (function
, 0);
18822 function
= tsubst_copy_and_build (function
, args
, complain
,
18825 integral_constant_expression_p
);
18827 if (BASELINK_P (function
))
18828 qualified_p
= true;
18831 nargs
= call_expr_nargs (t
);
18832 releasing_vec call_args
;
18833 for (i
= 0; i
< nargs
; ++i
)
18835 tree arg
= CALL_EXPR_ARG (t
, i
);
18837 if (!PACK_EXPANSION_P (arg
))
18838 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
18841 /* Expand the pack expansion and push each entry onto
18843 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
18844 if (TREE_CODE (arg
) == TREE_VEC
)
18846 unsigned int len
, j
;
18848 len
= TREE_VEC_LENGTH (arg
);
18849 for (j
= 0; j
< len
; ++j
)
18851 tree value
= TREE_VEC_ELT (arg
, j
);
18852 if (value
!= NULL_TREE
)
18853 value
= convert_from_reference (value
);
18854 vec_safe_push (call_args
, value
);
18859 /* A partial substitution. Add one entry. */
18860 vec_safe_push (call_args
, arg
);
18865 /* Stripped-down processing for a call in a thunk. Specifically, in
18866 the thunk template for a generic lambda. */
18867 if (CALL_FROM_THUNK_P (t
))
18869 /* Now that we've expanded any packs, the number of call args
18870 might be different. */
18871 unsigned int cargs
= call_args
->length ();
18872 tree thisarg
= NULL_TREE
;
18873 if (TREE_CODE (function
) == COMPONENT_REF
)
18875 thisarg
= TREE_OPERAND (function
, 0);
18876 if (TREE_CODE (thisarg
) == INDIRECT_REF
)
18877 thisarg
= TREE_OPERAND (thisarg
, 0);
18878 function
= TREE_OPERAND (function
, 1);
18879 if (TREE_CODE (function
) == BASELINK
)
18880 function
= BASELINK_FUNCTIONS (function
);
18882 /* We aren't going to do normal overload resolution, so force the
18883 template-id to resolve. */
18884 function
= resolve_nondeduced_context (function
, complain
);
18885 for (unsigned i
= 0; i
< cargs
; ++i
)
18887 /* In a thunk, pass through args directly, without any
18889 tree arg
= (*call_args
)[i
];
18890 while (TREE_CODE (arg
) != PARM_DECL
)
18891 arg
= TREE_OPERAND (arg
, 0);
18892 (*call_args
)[i
] = arg
;
18896 /* If there are no other args, just push 'this'. */
18898 vec_safe_push (call_args
, thisarg
);
18901 /* Otherwise, shift the other args over to make room. */
18902 tree last
= (*call_args
)[cargs
- 1];
18903 vec_safe_push (call_args
, last
);
18904 for (int i
= cargs
- 1; i
> 0; --i
)
18905 (*call_args
)[i
] = (*call_args
)[i
- 1];
18906 (*call_args
)[0] = thisarg
;
18909 ret
= build_call_a (function
, call_args
->length (),
18910 call_args
->address ());
18911 /* The thunk location is not interesting. */
18912 SET_EXPR_LOCATION (ret
, UNKNOWN_LOCATION
);
18913 CALL_FROM_THUNK_P (ret
) = true;
18914 if (CLASS_TYPE_P (TREE_TYPE (ret
)))
18915 CALL_EXPR_RETURN_SLOT_OPT (ret
) = true;
18920 /* We do not perform argument-dependent lookup if normal
18921 lookup finds a non-function, in accordance with the
18922 expected resolution of DR 218. */
18924 && ((is_overloaded_fn (function
)
18925 /* If lookup found a member function, the Koenig lookup is
18926 not appropriate, even if an unqualified-name was used
18927 to denote the function. */
18928 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
18929 || identifier_p (function
))
18930 /* Only do this when substitution turns a dependent call
18931 into a non-dependent call. */
18932 && type_dependent_expression_p_push (t
)
18933 && !any_type_dependent_arguments_p (call_args
))
18934 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
18936 if (function
!= NULL_TREE
18937 && identifier_p (function
)
18938 && !any_type_dependent_arguments_p (call_args
))
18940 if (koenig_p
&& (complain
& tf_warning_or_error
))
18942 /* For backwards compatibility and good diagnostics, try
18943 the unqualified lookup again if we aren't in SFINAE
18945 tree unq
= (tsubst_copy_and_build
18946 (function
, args
, complain
, in_decl
, true,
18947 integral_constant_expression_p
));
18948 if (unq
== error_mark_node
)
18949 RETURN (error_mark_node
);
18951 if (unq
!= function
)
18953 /* In a lambda fn, we have to be careful to not
18954 introduce new this captures. Legacy code can't
18955 be using lambdas anyway, so it's ok to be
18957 bool in_lambda
= (current_class_type
18958 && LAMBDA_TYPE_P (current_class_type
));
18959 char const *const msg
18960 = G_("%qD was not declared in this scope, "
18961 "and no declarations were found by "
18962 "argument-dependent lookup at the point "
18963 "of instantiation");
18967 error_at (cp_expr_loc_or_loc (t
, input_location
),
18970 diag
= permerror (cp_expr_loc_or_loc (t
, input_location
),
18976 if (INDIRECT_REF_P (fn
))
18977 fn
= TREE_OPERAND (fn
, 0);
18978 if (is_overloaded_fn (fn
))
18979 fn
= get_first_fn (fn
);
18982 /* Can't say anything more. */;
18983 else if (DECL_CLASS_SCOPE_P (fn
))
18985 location_t loc
= cp_expr_loc_or_loc (t
,
18988 "declarations in dependent base %qT are "
18989 "not found by unqualified lookup",
18990 DECL_CLASS_CONTEXT (fn
));
18991 if (current_class_ptr
)
18993 "use %<this->%D%> instead", function
);
18996 "use %<%T::%D%> instead",
18997 current_class_name
, function
);
19000 inform (DECL_SOURCE_LOCATION (fn
),
19001 "%qD declared here, later in the "
19002 "translation unit", fn
);
19004 RETURN (error_mark_node
);
19010 if (identifier_p (function
))
19012 if (complain
& tf_error
)
19013 unqualified_name_lookup_error (function
);
19014 RETURN (error_mark_node
);
19018 /* Remember that there was a reference to this entity. */
19019 if (function
!= NULL_TREE
19020 && DECL_P (function
)
19021 && !mark_used (function
, complain
) && !(complain
& tf_error
))
19022 RETURN (error_mark_node
);
19024 /* Put back tf_decltype for the actual call. */
19025 complain
|= decltype_flag
;
19027 if (function
== NULL_TREE
)
19028 switch (CALL_EXPR_IFN (t
))
19031 gcc_assert (nargs
== 1);
19032 if (vec_safe_length (call_args
) != 1)
19034 error_at (cp_expr_loc_or_loc (t
, input_location
),
19035 "wrong number of arguments to "
19036 "%<__builtin_launder%>");
19037 ret
= error_mark_node
;
19040 ret
= finish_builtin_launder (cp_expr_loc_or_loc (t
,
19042 (*call_args
)[0], complain
);
19045 case IFN_VEC_CONVERT
:
19046 gcc_assert (nargs
== 1);
19047 if (vec_safe_length (call_args
) != 1)
19049 error_at (cp_expr_loc_or_loc (t
, input_location
),
19050 "wrong number of arguments to "
19051 "%<__builtin_convertvector%>");
19052 ret
= error_mark_node
;
19055 ret
= cp_build_vec_convert ((*call_args
)[0], input_location
,
19056 tsubst (TREE_TYPE (t
), args
,
19057 complain
, in_decl
),
19059 if (TREE_CODE (ret
) == VIEW_CONVERT_EXPR
)
19064 /* Unsupported internal function with arguments. */
19065 gcc_unreachable ();
19067 else if (TREE_CODE (function
) == OFFSET_REF
19068 || TREE_CODE (function
) == DOTSTAR_EXPR
19069 || TREE_CODE (function
) == MEMBER_REF
)
19070 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
19072 else if (TREE_CODE (function
) == COMPONENT_REF
)
19074 tree instance
= TREE_OPERAND (function
, 0);
19075 tree fn
= TREE_OPERAND (function
, 1);
19077 if (processing_template_decl
19078 && (type_dependent_expression_p (instance
)
19079 || (!BASELINK_P (fn
)
19080 && TREE_CODE (fn
) != FIELD_DECL
)
19081 || type_dependent_expression_p (fn
)
19082 || any_type_dependent_arguments_p (call_args
)))
19083 ret
= build_min_nt_call_vec (function
, call_args
);
19084 else if (!BASELINK_P (fn
))
19085 ret
= finish_call_expr (function
, &call_args
,
19086 /*disallow_virtual=*/false,
19087 /*koenig_p=*/false,
19090 ret
= (build_new_method_call
19092 &call_args
, NULL_TREE
,
19093 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
19098 ret
= finish_call_expr (function
, &call_args
,
19099 /*disallow_virtual=*/qualified_p
,
19103 if (ret
!= error_mark_node
)
19105 bool op
= CALL_EXPR_OPERATOR_SYNTAX (t
);
19106 bool ord
= CALL_EXPR_ORDERED_ARGS (t
);
19107 bool rev
= CALL_EXPR_REVERSE_ARGS (t
);
19108 if (op
|| ord
|| rev
)
19110 function
= extract_call_expr (ret
);
19111 CALL_EXPR_OPERATOR_SYNTAX (function
) = op
;
19112 CALL_EXPR_ORDERED_ARGS (function
) = ord
;
19113 CALL_EXPR_REVERSE_ARGS (function
) = rev
;
19122 tree cond
= RECUR (TREE_OPERAND (t
, 0));
19123 cond
= mark_rvalue_use (cond
);
19124 tree folded_cond
= fold_non_dependent_expr (cond
, complain
);
19127 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
19129 if (integer_zerop (folded_cond
))
19131 ++c_inhibit_evaluation_warnings
;
19132 exp1
= RECUR (TREE_OPERAND (t
, 1));
19133 --c_inhibit_evaluation_warnings
;
19134 exp2
= RECUR (TREE_OPERAND (t
, 2));
19138 exp1
= RECUR (TREE_OPERAND (t
, 1));
19139 ++c_inhibit_evaluation_warnings
;
19140 exp2
= RECUR (TREE_OPERAND (t
, 2));
19141 --c_inhibit_evaluation_warnings
;
19143 cond
= folded_cond
;
19147 exp1
= RECUR (TREE_OPERAND (t
, 1));
19148 exp2
= RECUR (TREE_OPERAND (t
, 2));
19151 warning_sentinel
s(warn_duplicated_branches
);
19152 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
19153 cond
, exp1
, exp2
, complain
));
19156 case PSEUDO_DTOR_EXPR
:
19158 tree op0
= RECUR (TREE_OPERAND (t
, 0));
19159 tree op1
= RECUR (TREE_OPERAND (t
, 1));
19160 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
19161 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
19167 tree purpose
, value
, chain
;
19169 if (t
== void_list_node
)
19172 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
19173 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
19175 /* We have pack expansions, so expand those and
19176 create a new list out of it. */
19177 tree purposevec
= NULL_TREE
;
19178 tree valuevec
= NULL_TREE
;
19182 /* Expand the argument expressions. */
19183 if (TREE_PURPOSE (t
))
19184 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
19185 complain
, in_decl
);
19186 if (TREE_VALUE (t
))
19187 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
19188 complain
, in_decl
);
19190 /* Build the rest of the list. */
19191 chain
= TREE_CHAIN (t
);
19192 if (chain
&& chain
!= void_type_node
)
19193 chain
= RECUR (chain
);
19195 /* Determine the number of arguments. */
19196 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
19198 len
= TREE_VEC_LENGTH (purposevec
);
19199 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
19201 else if (TREE_CODE (valuevec
) == TREE_VEC
)
19202 len
= TREE_VEC_LENGTH (valuevec
);
19205 /* Since we only performed a partial substitution into
19206 the argument pack, we only RETURN (a single list
19208 if (purposevec
== TREE_PURPOSE (t
)
19209 && valuevec
== TREE_VALUE (t
)
19210 && chain
== TREE_CHAIN (t
))
19213 RETURN (tree_cons (purposevec
, valuevec
, chain
));
19216 /* Convert the argument vectors into a TREE_LIST */
19220 /* Grab the Ith values. */
19222 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
19225 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
19228 /* Build the list (backwards). */
19229 chain
= tree_cons (purpose
, value
, chain
);
19235 purpose
= TREE_PURPOSE (t
);
19237 purpose
= RECUR (purpose
);
19238 value
= TREE_VALUE (t
);
19240 value
= RECUR (value
);
19241 chain
= TREE_CHAIN (t
);
19242 if (chain
&& chain
!= void_type_node
)
19243 chain
= RECUR (chain
);
19244 if (purpose
== TREE_PURPOSE (t
)
19245 && value
== TREE_VALUE (t
)
19246 && chain
== TREE_CHAIN (t
))
19248 RETURN (tree_cons (purpose
, value
, chain
));
19251 case COMPONENT_REF
:
19258 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
19259 args
, complain
, in_decl
);
19260 /* Remember that there was a reference to this entity. */
19261 if (DECL_P (object
)
19262 && !mark_used (object
, complain
) && !(complain
& tf_error
))
19263 RETURN (error_mark_node
);
19264 object_type
= TREE_TYPE (object
);
19266 member
= TREE_OPERAND (t
, 1);
19267 if (BASELINK_P (member
))
19268 member
= tsubst_baselink (member
,
19269 non_reference (TREE_TYPE (object
)),
19270 args
, complain
, in_decl
);
19272 member
= tsubst_copy (member
, args
, complain
, in_decl
);
19273 if (member
== error_mark_node
)
19274 RETURN (error_mark_node
);
19276 if (TREE_CODE (member
) == FIELD_DECL
)
19278 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
19279 if (TREE_CODE (r
) == COMPONENT_REF
)
19280 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
19283 else if (type_dependent_expression_p (object
))
19284 /* We can't do much here. */;
19285 else if (!CLASS_TYPE_P (object_type
))
19287 if (scalarish_type_p (object_type
))
19289 tree s
= NULL_TREE
;
19290 tree dtor
= member
;
19292 if (TREE_CODE (dtor
) == SCOPE_REF
)
19294 s
= TREE_OPERAND (dtor
, 0);
19295 dtor
= TREE_OPERAND (dtor
, 1);
19297 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
19299 dtor
= TREE_OPERAND (dtor
, 0);
19301 RETURN (finish_pseudo_destructor_expr
19302 (object
, s
, dtor
, input_location
));
19306 else if (TREE_CODE (member
) == SCOPE_REF
19307 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
19309 /* Lookup the template functions now that we know what the
19311 tree scope
= TREE_OPERAND (member
, 0);
19312 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
19313 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
19314 member
= lookup_qualified_name (scope
, tmpl
,
19315 /*is_type_p=*/false,
19316 /*complain=*/false);
19317 if (BASELINK_P (member
))
19319 BASELINK_FUNCTIONS (member
)
19320 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
19322 member
= (adjust_result_of_qualified_name_lookup
19323 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
19328 qualified_name_lookup_error (scope
, tmpl
, member
,
19330 RETURN (error_mark_node
);
19333 else if (TREE_CODE (member
) == SCOPE_REF
19334 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
19335 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
19337 if (complain
& tf_error
)
19339 if (TYPE_P (TREE_OPERAND (member
, 0)))
19340 error ("%qT is not a class or namespace",
19341 TREE_OPERAND (member
, 0));
19343 error ("%qD is not a class or namespace",
19344 TREE_OPERAND (member
, 0));
19346 RETURN (error_mark_node
);
19349 r
= finish_class_member_access_expr (object
, member
,
19350 /*template_p=*/false,
19352 if (TREE_CODE (r
) == COMPONENT_REF
)
19353 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
19358 RETURN (build_throw
19359 (RECUR (TREE_OPERAND (t
, 0))));
19363 vec
<constructor_elt
, va_gc
> *n
;
19364 constructor_elt
*ce
;
19365 unsigned HOST_WIDE_INT idx
;
19366 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
19367 bool process_index_p
;
19369 bool need_copy_p
= false;
19372 if (type
== error_mark_node
)
19373 RETURN (error_mark_node
);
19375 /* We do not want to process the index of aggregate
19376 initializers as they are identifier nodes which will be
19377 looked up by digest_init. */
19378 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
19380 if (null_member_pointer_value_p (t
))
19382 gcc_assert (same_type_p (type
, TREE_TYPE (t
)));
19386 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
19387 newlen
= vec_safe_length (n
);
19388 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
19390 if (ce
->index
&& process_index_p
19391 /* An identifier index is looked up in the type
19392 being initialized, not the current scope. */
19393 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
19394 ce
->index
= RECUR (ce
->index
);
19396 if (PACK_EXPANSION_P (ce
->value
))
19398 /* Substitute into the pack expansion. */
19399 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
19402 if (ce
->value
== error_mark_node
19403 || PACK_EXPANSION_P (ce
->value
))
19405 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
19406 /* Just move the argument into place. */
19407 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
19410 /* Update the length of the final CONSTRUCTOR
19411 arguments vector, and note that we will need to
19413 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
19414 need_copy_p
= true;
19418 ce
->value
= RECUR (ce
->value
);
19423 vec
<constructor_elt
, va_gc
> *old_n
= n
;
19425 vec_alloc (n
, newlen
);
19426 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
19428 if (TREE_CODE (ce
->value
) == TREE_VEC
)
19430 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
19431 for (i
= 0; i
< len
; ++i
)
19432 CONSTRUCTOR_APPEND_ELT (n
, 0,
19433 TREE_VEC_ELT (ce
->value
, i
));
19436 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
19440 r
= build_constructor (init_list_type_node
, n
);
19441 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
19442 CONSTRUCTOR_IS_DESIGNATED_INIT (r
)
19443 = CONSTRUCTOR_IS_DESIGNATED_INIT (t
);
19445 if (TREE_HAS_CONSTRUCTOR (t
))
19447 fcl_t cl
= fcl_functional
;
19448 if (CONSTRUCTOR_C99_COMPOUND_LITERAL (t
))
19450 RETURN (finish_compound_literal (type
, r
, complain
, cl
));
19453 TREE_TYPE (r
) = type
;
19459 tree operand_0
= TREE_OPERAND (t
, 0);
19460 if (TYPE_P (operand_0
))
19462 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
19463 RETURN (get_typeid (operand_0
, complain
));
19467 operand_0
= RECUR (operand_0
);
19468 RETURN (build_typeid (operand_0
, complain
));
19479 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
19480 /* ??? We're doing a subset of finish_id_expression here. */
19481 if (tree wrap
= maybe_get_tls_wrapper_call (r
))
19482 /* Replace an evaluated use of the thread_local variable with
19483 a call to its wrapper. */
19485 else if (outer_automatic_var_p (r
))
19486 r
= process_outer_var_ref (r
, complain
);
19488 if (!TYPE_REF_P (TREE_TYPE (t
)))
19489 /* If the original type was a reference, we'll be wrapped in
19490 the appropriate INDIRECT_REF. */
19491 r
= convert_from_reference (r
);
19497 tree op0
= RECUR (TREE_OPERAND (t
, 0));
19498 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
19499 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
19502 case OFFSETOF_EXPR
:
19505 = tsubst_copy_and_build (TREE_OPERAND (t
, 1), args
, complain
,
19506 in_decl
, /*function_p=*/false,
19507 /*integral_constant_expression_p=*/false);
19508 RETURN (finish_offsetof (object_ptr
,
19509 RECUR (TREE_OPERAND (t
, 0)),
19510 EXPR_LOCATION (t
)));
19513 case ADDRESSOF_EXPR
:
19514 RETURN (cp_build_addressof (EXPR_LOCATION (t
),
19515 RECUR (TREE_OPERAND (t
, 0)), complain
));
19519 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
19520 complain
, in_decl
);
19522 tree type2
= TRAIT_EXPR_TYPE2 (t
);
19523 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
19524 type2
= RECUR (type2
);
19526 type2
= tsubst (type2
, args
, complain
, in_decl
);
19528 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
19533 tree old_stmt_expr
= cur_stmt_expr
;
19534 tree stmt_expr
= begin_stmt_expr ();
19536 cur_stmt_expr
= stmt_expr
;
19537 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
19538 integral_constant_expression_p
);
19539 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
19540 cur_stmt_expr
= old_stmt_expr
;
19542 /* If the resulting list of expression statement is empty,
19543 fold it further into void_node. */
19544 if (empty_expr_stmt_p (stmt_expr
))
19545 stmt_expr
= void_node
;
19547 RETURN (stmt_expr
);
19552 if (complain
& tf_partial
)
19554 /* We don't have a full set of template arguments yet; don't touch
19555 the lambda at all. */
19556 gcc_assert (processing_template_decl
);
19559 tree r
= tsubst_lambda_expr (t
, args
, complain
, in_decl
);
19561 RETURN (build_lambda_object (r
));
19565 /* We can get here for a constant initializer of non-dependent type.
19566 FIXME stop folding in cp_parser_initializer_clause. */
19568 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
19573 case TRANSACTION_EXPR
:
19574 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
19575 integral_constant_expression_p
));
19578 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
19580 case VEC_PERM_EXPR
:
19582 tree op0
= RECUR (TREE_OPERAND (t
, 0));
19583 tree op1
= RECUR (TREE_OPERAND (t
, 1));
19584 tree op2
= RECUR (TREE_OPERAND (t
, 2));
19585 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
19589 case REQUIRES_EXPR
:
19590 RETURN (tsubst_requires_expr (t
, args
, complain
, in_decl
));
19593 /* No need to substitute further, a RANGE_EXPR will always be built
19594 with constant operands. */
19597 case NON_LVALUE_EXPR
:
19598 case VIEW_CONVERT_EXPR
:
19599 if (location_wrapper_p (t
))
19600 /* We need to do this here as well as in tsubst_copy so we get the
19601 other tsubst_copy_and_build semantics for a PARM_DECL operand. */
19602 RETURN (maybe_wrap_with_location (RECUR (TREE_OPERAND (t
, 0)),
19603 EXPR_LOCATION (t
)));
19607 /* Handle Objective-C++ constructs, if appropriate. */
19610 = objcp_tsubst_copy_and_build (t
, args
, complain
,
19611 in_decl
, /*function_p=*/false);
19615 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
19621 input_location
= loc
;
19625 /* Verify that the instantiated ARGS are valid. For type arguments,
19626 make sure that the type's linkage is ok. For non-type arguments,
19627 make sure they are constants if they are integral or enumerations.
19628 Emit an error under control of COMPLAIN, and return TRUE on error. */
19631 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
19633 if (dependent_template_arg_p (t
))
19635 if (ARGUMENT_PACK_P (t
))
19637 tree vec
= ARGUMENT_PACK_ARGS (t
);
19638 int len
= TREE_VEC_LENGTH (vec
);
19639 bool result
= false;
19642 for (i
= 0; i
< len
; ++i
)
19643 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
19647 else if (TYPE_P (t
))
19649 /* [basic.link]: A name with no linkage (notably, the name
19650 of a class or enumeration declared in a local scope)
19651 shall not be used to declare an entity with linkage.
19652 This implies that names with no linkage cannot be used as
19655 DR 757 relaxes this restriction for C++0x. */
19656 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
19657 : no_linkage_check (t
, /*relaxed_p=*/false));
19661 /* DR 488 makes use of a type with no linkage cause
19662 type deduction to fail. */
19663 if (complain
& tf_error
)
19665 if (TYPE_UNNAMED_P (nt
))
19666 error ("%qT is/uses unnamed type", t
);
19668 error ("template argument for %qD uses local type %qT",
19673 /* In order to avoid all sorts of complications, we do not
19674 allow variably-modified types as template arguments. */
19675 else if (variably_modified_type_p (t
, NULL_TREE
))
19677 if (complain
& tf_error
)
19678 error ("%qT is a variably modified type", t
);
19682 /* Class template and alias template arguments should be OK. */
19683 else if (DECL_TYPE_TEMPLATE_P (t
))
19685 /* A non-type argument of integral or enumerated type must be a
19687 else if (TREE_TYPE (t
)
19688 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
19689 && !REFERENCE_REF_P (t
)
19690 && !TREE_CONSTANT (t
))
19692 if (complain
& tf_error
)
19693 error ("integral expression %qE is not constant", t
);
19700 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
19702 int ix
, len
= DECL_NTPARMS (tmpl
);
19703 bool result
= false;
19705 for (ix
= 0; ix
!= len
; ix
++)
19707 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
19710 if (result
&& (complain
& tf_error
))
19711 error (" trying to instantiate %qD", tmpl
);
19715 /* We're out of SFINAE context now, so generate diagnostics for the access
19716 errors we saw earlier when instantiating D from TMPL and ARGS. */
19719 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
19721 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19722 tree type
= TREE_TYPE (pattern
);
19723 location_t loc
= input_location
;
19725 push_access_scope (d
);
19726 push_deferring_access_checks (dk_no_deferred
);
19727 input_location
= DECL_SOURCE_LOCATION (pattern
);
19728 tsubst (type
, args
, tf_warning_or_error
, d
);
19729 input_location
= loc
;
19730 pop_deferring_access_checks ();
19731 pop_access_scope (d
);
19734 /* Instantiate the indicated variable, function, or alias template TMPL with
19735 the template arguments in TARG_PTR. */
19738 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
19740 tree targ_ptr
= orig_args
;
19744 bool access_ok
= true;
19746 if (tmpl
== error_mark_node
)
19747 return error_mark_node
;
19749 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
19751 /* If this function is a clone, handle it specially. */
19752 if (DECL_CLONED_FUNCTION_P (tmpl
))
19757 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
19758 DECL_CLONED_FUNCTION. */
19759 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
19760 targ_ptr
, complain
);
19761 if (spec
== error_mark_node
)
19762 return error_mark_node
;
19764 /* Look for the clone. */
19765 FOR_EACH_CLONE (clone
, spec
)
19766 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
19768 /* We should always have found the clone by now. */
19769 gcc_unreachable ();
19773 if (targ_ptr
== error_mark_node
)
19774 return error_mark_node
;
19776 /* Check to see if we already have this specialization. */
19777 gen_tmpl
= most_general_template (tmpl
);
19778 if (TMPL_ARGS_DEPTH (targ_ptr
)
19779 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
)))
19780 /* targ_ptr only has the innermost template args, so add the outer ones
19781 from tmpl, which could be either a partial instantiation or gen_tmpl (in
19782 the case of a non-dependent call within a template definition). */
19783 targ_ptr
= (add_outermost_template_args
19784 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (tmpl
)),
19787 /* It would be nice to avoid hashing here and then again in tsubst_decl,
19788 but it doesn't seem to be on the hot path. */
19789 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
19791 gcc_assert (tmpl
== gen_tmpl
19792 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
19794 || fndecl
== NULL_TREE
);
19796 if (spec
!= NULL_TREE
)
19798 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
19800 if (complain
& tf_error
)
19801 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
19802 return error_mark_node
;
19807 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
19809 return error_mark_node
;
19811 /* We are building a FUNCTION_DECL, during which the access of its
19812 parameters and return types have to be checked. However this
19813 FUNCTION_DECL which is the desired context for access checking
19814 is not built yet. We solve this chicken-and-egg problem by
19815 deferring all checks until we have the FUNCTION_DECL. */
19816 push_deferring_access_checks (dk_deferred
);
19818 /* Instantiation of the function happens in the context of the function
19819 template, not the context of the overload resolution we're doing. */
19820 push_to_top_level ();
19821 /* If there are dependent arguments, e.g. because we're doing partial
19822 ordering, make sure processing_template_decl stays set. */
19823 if (uses_template_parms (targ_ptr
))
19824 ++processing_template_decl
;
19825 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
19827 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
19828 complain
, gen_tmpl
, true);
19829 push_nested_class (ctx
);
19832 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
19834 fndecl
= NULL_TREE
;
19835 if (VAR_P (pattern
))
19837 /* We need to determine if we're using a partial or explicit
19838 specialization now, because the type of the variable could be
19840 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
19841 tree elt
= most_specialized_partial_spec (tid
, complain
);
19842 if (elt
== error_mark_node
)
19843 pattern
= error_mark_node
;
19846 tree partial_tmpl
= TREE_VALUE (elt
);
19847 tree partial_args
= TREE_PURPOSE (elt
);
19848 tree partial_pat
= DECL_TEMPLATE_RESULT (partial_tmpl
);
19849 fndecl
= tsubst (partial_pat
, partial_args
, complain
, gen_tmpl
);
19853 /* Substitute template parameters to obtain the specialization. */
19854 if (fndecl
== NULL_TREE
)
19855 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
19856 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
19857 pop_nested_class ();
19858 pop_from_top_level ();
19860 if (fndecl
== error_mark_node
)
19862 pop_deferring_access_checks ();
19863 return error_mark_node
;
19866 /* The DECL_TI_TEMPLATE should always be the immediate parent
19867 template, not the most general template. */
19868 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
19869 DECL_TI_ARGS (fndecl
) = targ_ptr
;
19871 /* Now we know the specialization, compute access previously
19872 deferred. Do no access control for inheriting constructors,
19873 as we already checked access for the inherited constructor. */
19874 if (!(flag_new_inheriting_ctors
19875 && DECL_INHERITED_CTOR (fndecl
)))
19877 push_access_scope (fndecl
);
19878 if (!perform_deferred_access_checks (complain
))
19880 pop_access_scope (fndecl
);
19882 pop_deferring_access_checks ();
19884 /* If we've just instantiated the main entry point for a function,
19885 instantiate all the alternate entry points as well. We do this
19886 by cloning the instantiation of the main entry point, not by
19887 instantiating the template clones. */
19888 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
19889 clone_function_decl (fndecl
, /*update_methods=*/false);
19893 if (!(complain
& tf_error
))
19895 /* Remember to reinstantiate when we're out of SFINAE so the user
19896 can see the errors. */
19897 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
19899 return error_mark_node
;
19904 /* Wrapper for instantiate_template_1. */
19907 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
19910 timevar_push (TV_TEMPLATE_INST
);
19911 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
19912 timevar_pop (TV_TEMPLATE_INST
);
19916 /* Instantiate the alias template TMPL with ARGS. Also push a template
19917 instantiation level, which instantiate_template doesn't do because
19918 functions and variables have sufficient context established by the
19922 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
19924 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
19925 return error_mark_node
;
19926 if (!push_tinst_level (tmpl
, args
))
19927 return error_mark_node
;
19930 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
19931 args
, tmpl
, complain
,
19932 /*require_all_args=*/true,
19933 /*use_default_args=*/true);
19935 tree r
= instantiate_template (tmpl
, args
, complain
);
19936 pop_tinst_level ();
19941 /* PARM is a template parameter pack for FN. Returns true iff
19942 PARM is used in a deducible way in the argument list of FN. */
19945 pack_deducible_p (tree parm
, tree fn
)
19947 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
19948 for (; t
; t
= TREE_CHAIN (t
))
19950 tree type
= TREE_VALUE (t
);
19952 if (!PACK_EXPANSION_P (type
))
19954 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
19955 packs
; packs
= TREE_CHAIN (packs
))
19956 if (template_args_equal (TREE_VALUE (packs
), parm
))
19958 /* The template parameter pack is used in a function parameter
19959 pack. If this is the end of the parameter list, the
19960 template parameter pack is deducible. */
19961 if (TREE_CHAIN (t
) == void_list_node
)
19964 /* Otherwise, not. Well, it could be deduced from
19965 a non-pack parameter, but doing so would end up with
19966 a deduction mismatch, so don't bother. */
19970 /* The template parameter pack isn't used in any function parameter
19971 packs, but it might be used deeper, e.g. tuple<Args...>. */
19975 /* Subroutine of fn_type_unification: check non-dependent parms for
19979 check_non_deducible_conversions (tree parms
, const tree
*args
, unsigned nargs
,
19980 tree fn
, unification_kind_t strict
, int flags
,
19981 struct conversion
**convs
, bool explain_p
)
19983 /* Non-constructor methods need to leave a conversion for 'this', which
19984 isn't included in nargs here. */
19985 unsigned offset
= (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
19986 && !DECL_CONSTRUCTOR_P (fn
));
19988 for (unsigned ia
= 0;
19989 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
19991 tree parm
= TREE_VALUE (parms
);
19993 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
19994 && (!TREE_CHAIN (parms
)
19995 || TREE_CHAIN (parms
) == void_list_node
))
19996 /* For a function parameter pack that occurs at the end of the
19997 parameter-declaration-list, the type A of each remaining
19998 argument of the call is compared with the type P of the
19999 declarator-id of the function parameter pack. */
20002 parms
= TREE_CHAIN (parms
);
20004 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
20005 /* For a function parameter pack that does not occur at the
20006 end of the parameter-declaration-list, the type of the
20007 parameter pack is a non-deduced context. */
20010 if (!uses_template_parms (parm
))
20012 tree arg
= args
[ia
];
20013 conversion
**conv_p
= convs
? &convs
[ia
+offset
] : NULL
;
20014 int lflags
= conv_flags (ia
, nargs
, fn
, arg
, flags
);
20016 if (check_non_deducible_conversion (parm
, arg
, strict
, lflags
,
20017 conv_p
, explain_p
))
20027 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
20028 NARGS elements of the arguments that are being used when calling
20029 it. TARGS is a vector into which the deduced template arguments
20032 Returns either a FUNCTION_DECL for the matching specialization of FN or
20033 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
20034 true, diagnostics will be printed to explain why it failed.
20036 If FN is a conversion operator, or we are trying to produce a specific
20037 specialization, RETURN_TYPE is the return type desired.
20039 The EXPLICIT_TARGS are explicit template arguments provided via a
20042 The parameter STRICT is one of:
20045 We are deducing arguments for a function call, as in
20046 [temp.deduct.call]. If RETURN_TYPE is non-null, we are
20047 deducing arguments for a call to the result of a conversion
20048 function template, as in [over.call.object].
20051 We are deducing arguments for a conversion function, as in
20052 [temp.deduct.conv].
20055 We are deducing arguments when doing an explicit instantiation
20056 as in [temp.explicit], when determining an explicit specialization
20057 as in [temp.expl.spec], or when taking the address of a function
20058 template, as in [temp.deduct.funcaddr]. */
20061 fn_type_unification (tree fn
,
20062 tree explicit_targs
,
20065 unsigned int nargs
,
20067 unification_kind_t strict
,
20069 struct conversion
**convs
,
20075 tree decl
= NULL_TREE
;
20076 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
20078 static int deduction_depth
;
20079 /* type_unification_real will pass back any access checks from default
20080 template argument substitution. */
20081 vec
<deferred_access_check
, va_gc
> *checks
= NULL
;
20082 /* We don't have all the template args yet. */
20083 bool incomplete
= true;
20086 if (flag_new_inheriting_ctors
)
20087 fn
= strip_inheriting_ctors (fn
);
20089 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
20090 tree r
= error_mark_node
;
20092 tree full_targs
= targs
;
20093 if (TMPL_ARGS_DEPTH (targs
)
20094 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (fn
)))
20095 full_targs
= (add_outermost_template_args
20096 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (fn
)),
20100 complain
|= tf_decltype
;
20102 /* In C++0x, it's possible to have a function template whose type depends
20103 on itself recursively. This is most obvious with decltype, but can also
20104 occur with enumeration scope (c++/48969). So we need to catch infinite
20105 recursion and reject the substitution at deduction time; this function
20106 will return error_mark_node for any repeated substitution.
20108 This also catches excessive recursion such as when f<N> depends on
20109 f<N-1> across all integers, and returns error_mark_node for all the
20110 substitutions back up to the initial one.
20112 This is, of course, not reentrant. */
20113 if (excessive_deduction_depth
)
20114 return error_mark_node
;
20117 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
20119 fntype
= TREE_TYPE (fn
);
20120 if (explicit_targs
)
20124 The specified template arguments must match the template
20125 parameters in kind (i.e., type, nontype, template), and there
20126 must not be more arguments than there are parameters;
20127 otherwise type deduction fails.
20129 Nontype arguments must match the types of the corresponding
20130 nontype template parameters, or must be convertible to the
20131 types of the corresponding nontype parameters as specified in
20132 _temp.arg.nontype_, otherwise type deduction fails.
20134 All references in the function type of the function template
20135 to the corresponding template parameters are replaced by the
20136 specified template argument values. If a substitution in a
20137 template parameter or in the function type of the function
20138 template results in an invalid type, type deduction fails. */
20139 int i
, len
= TREE_VEC_LENGTH (tparms
);
20140 location_t loc
= input_location
;
20141 incomplete
= false;
20143 if (explicit_targs
== error_mark_node
)
20146 if (TMPL_ARGS_DEPTH (explicit_targs
)
20147 < TMPL_ARGS_DEPTH (full_targs
))
20148 explicit_targs
= add_outermost_template_args (full_targs
,
20151 /* Adjust any explicit template arguments before entering the
20152 substitution context. */
20154 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
20155 complain
|tf_partial
,
20156 /*require_all_args=*/false,
20157 /*use_default_args=*/false));
20158 if (explicit_targs
== error_mark_node
)
20161 /* Substitute the explicit args into the function type. This is
20162 necessary so that, for instance, explicitly declared function
20163 arguments can match null pointed constants. If we were given
20164 an incomplete set of explicit args, we must not do semantic
20165 processing during substitution as we could create partial
20167 for (i
= 0; i
< len
; i
++)
20169 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
20170 bool parameter_pack
= false;
20171 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
20173 /* Dig out the actual parm. */
20174 if (TREE_CODE (parm
) == TYPE_DECL
20175 || TREE_CODE (parm
) == TEMPLATE_DECL
)
20177 parm
= TREE_TYPE (parm
);
20178 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
20180 else if (TREE_CODE (parm
) == PARM_DECL
)
20182 parm
= DECL_INITIAL (parm
);
20183 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
20186 if (targ
== NULL_TREE
)
20187 /* No explicit argument for this template parameter. */
20189 else if (parameter_pack
&& pack_deducible_p (parm
, fn
))
20191 /* Mark the argument pack as "incomplete". We could
20192 still deduce more arguments during unification.
20193 We remove this mark in type_unification_real. */
20194 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
20195 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
20196 = ARGUMENT_PACK_ARGS (targ
);
20198 /* We have some incomplete argument packs. */
20205 if (!push_tinst_level (fn
, explicit_targs
))
20207 excessive_deduction_depth
= true;
20210 ++processing_template_decl
;
20211 input_location
= DECL_SOURCE_LOCATION (fn
);
20212 /* Ignore any access checks; we'll see them again in
20213 instantiate_template and they might have the wrong
20214 access path at this point. */
20215 push_deferring_access_checks (dk_deferred
);
20216 tsubst_flags_t ecomplain
= complain
| tf_partial
| tf_fndecl_type
;
20217 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
, ecomplain
, NULL_TREE
);
20218 pop_deferring_access_checks ();
20219 input_location
= loc
;
20220 --processing_template_decl
;
20221 pop_tinst_level ();
20223 if (fntype
== error_mark_node
)
20227 /* Place the explicitly specified arguments in TARGS. */
20228 explicit_targs
= INNERMOST_TEMPLATE_ARGS (explicit_targs
);
20229 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
20230 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
20231 if (!incomplete
&& CHECKING_P
20232 && !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
20233 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
20234 (targs
, NUM_TMPL_ARGS (explicit_targs
));
20237 if (return_type
&& strict
!= DEDUCE_CALL
)
20239 tree
*new_args
= XALLOCAVEC (tree
, nargs
+ 1);
20240 new_args
[0] = return_type
;
20241 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
20249 /* Never do unification on the 'this' parameter. */
20250 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
20252 if (return_type
&& strict
== DEDUCE_CALL
)
20254 /* We're deducing for a call to the result of a template conversion
20255 function. The parms we really want are in return_type. */
20256 if (INDIRECT_TYPE_P (return_type
))
20257 return_type
= TREE_TYPE (return_type
);
20258 parms
= TYPE_ARG_TYPES (return_type
);
20260 else if (return_type
)
20262 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
20265 /* We allow incomplete unification without an error message here
20266 because the standard doesn't seem to explicitly prohibit it. Our
20267 callers must be ready to deal with unification failures in any
20270 /* If we aren't explaining yet, push tinst context so we can see where
20271 any errors (e.g. from class instantiations triggered by instantiation
20272 of default template arguments) come from. If we are explaining, this
20273 context is redundant. */
20274 if (!explain_p
&& !push_tinst_level (fn
, targs
))
20276 excessive_deduction_depth
= true;
20280 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
20281 full_targs
, parms
, args
, nargs
, /*subr=*/0,
20282 strict
, &checks
, explain_p
);
20284 pop_tinst_level ();
20288 /* Now that we have bindings for all of the template arguments,
20289 ensure that the arguments deduced for the template template
20290 parameters have compatible template parameter lists. We cannot
20291 check this property before we have deduced all template
20292 arguments, because the template parameter types of a template
20293 template parameter might depend on prior template parameters
20294 deduced after the template template parameter. The following
20295 ill-formed example illustrates this issue:
20297 template<typename T, template<T> class C> void f(C<5>, T);
20299 template<int N> struct X {};
20302 f(X<5>(), 5l); // error: template argument deduction fails
20305 The template parameter list of 'C' depends on the template type
20306 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
20307 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
20308 time that we deduce 'C'. */
20309 if (!template_template_parm_bindings_ok_p
20310 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
20312 unify_inconsistent_template_template_parameters (explain_p
);
20316 /* DR 1391: All parameters have args, now check non-dependent parms for
20318 if (check_non_deducible_conversions (parms
, args
, nargs
, fn
, strict
, flags
,
20323 /* All is well so far. Now, check:
20327 When all template arguments have been deduced, all uses of
20328 template parameters in nondeduced contexts are replaced with
20329 the corresponding deduced argument values. If the
20330 substitution results in an invalid type, as described above,
20331 type deduction fails. */
20332 if (!push_tinst_level (fn
, targs
))
20334 excessive_deduction_depth
= true;
20338 /* Also collect access checks from the instantiation. */
20339 reopen_deferring_access_checks (checks
);
20341 decl
= instantiate_template (fn
, targs
, complain
);
20343 checks
= get_deferred_access_checks ();
20344 pop_deferring_access_checks ();
20346 pop_tinst_level ();
20348 if (decl
== error_mark_node
)
20351 /* Now perform any access checks encountered during substitution. */
20352 push_access_scope (decl
);
20353 ok
= perform_access_checks (checks
, complain
);
20354 pop_access_scope (decl
);
20358 /* If we're looking for an exact match, check that what we got
20359 is indeed an exact match. It might not be if some template
20360 parameters are used in non-deduced contexts. But don't check
20361 for an exact match if we have dependent template arguments;
20362 in that case we're doing partial ordering, and we already know
20363 that we have two candidates that will provide the actual type. */
20364 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
20366 tree substed
= TREE_TYPE (decl
);
20370 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
20372 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
20373 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
20374 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
20376 unify_type_mismatch (explain_p
, args
[i
],
20377 TREE_VALUE (sarg
));
20382 /* After doing deduction with the inherited constructor, actually return an
20383 instantiation of the inheriting constructor. */
20385 decl
= instantiate_template (orig_fn
, targs
, complain
);
20391 if (excessive_deduction_depth
)
20393 if (deduction_depth
== 0)
20394 /* Reset once we're all the way out. */
20395 excessive_deduction_depth
= false;
20401 /* Adjust types before performing type deduction, as described in
20402 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
20403 sections are symmetric. PARM is the type of a function parameter
20404 or the return type of the conversion function. ARG is the type of
20405 the argument passed to the call, or the type of the value
20406 initialized with the result of the conversion function.
20407 ARG_EXPR is the original argument expression, which may be null. */
20410 maybe_adjust_types_for_deduction (unification_kind_t strict
,
20423 /* Swap PARM and ARG throughout the remainder of this
20424 function; the handling is precisely symmetric since PARM
20425 will initialize ARG rather than vice versa. */
20426 std::swap (parm
, arg
);
20430 /* Core issue #873: Do the DR606 thing (see below) for these cases,
20431 too, but here handle it by stripping the reference from PARM
20432 rather than by adding it to ARG. */
20433 if (TYPE_REF_P (*parm
)
20434 && TYPE_REF_IS_RVALUE (*parm
)
20435 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
20436 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
20437 && TYPE_REF_P (*arg
)
20438 && !TYPE_REF_IS_RVALUE (*arg
))
20439 *parm
= TREE_TYPE (*parm
);
20440 /* Nothing else to do in this case. */
20444 gcc_unreachable ();
20447 if (!TYPE_REF_P (*parm
))
20449 /* [temp.deduct.call]
20451 If P is not a reference type:
20453 --If A is an array type, the pointer type produced by the
20454 array-to-pointer standard conversion (_conv.array_) is
20455 used in place of A for type deduction; otherwise,
20457 --If A is a function type, the pointer type produced by
20458 the function-to-pointer standard conversion
20459 (_conv.func_) is used in place of A for type deduction;
20462 --If A is a cv-qualified type, the top level
20463 cv-qualifiers of A's type are ignored for type
20465 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
20466 *arg
= build_pointer_type (TREE_TYPE (*arg
));
20467 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
20468 *arg
= build_pointer_type (*arg
);
20470 *arg
= TYPE_MAIN_VARIANT (*arg
);
20473 /* [14.8.2.1/3 temp.deduct.call], "A forwarding reference is an rvalue
20474 reference to a cv-unqualified template parameter that does not represent a
20475 template parameter of a class template (during class template argument
20476 deduction (13.3.1.8)). If P is a forwarding reference and the argument is
20477 an lvalue, the type "lvalue reference to A" is used in place of A for type
20479 if (TYPE_REF_P (*parm
)
20480 && TYPE_REF_IS_RVALUE (*parm
)
20481 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
20482 && !TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (*parm
))
20483 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
20484 && (arg_expr
? lvalue_p (arg_expr
)
20485 /* try_one_overload doesn't provide an arg_expr, but
20486 functions are always lvalues. */
20487 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
20488 *arg
= build_reference_type (*arg
);
20490 /* [temp.deduct.call]
20492 If P is a cv-qualified type, the top level cv-qualifiers
20493 of P's type are ignored for type deduction. If P is a
20494 reference type, the type referred to by P is used for
20496 *parm
= TYPE_MAIN_VARIANT (*parm
);
20497 if (TYPE_REF_P (*parm
))
20499 *parm
= TREE_TYPE (*parm
);
20500 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
20503 /* DR 322. For conversion deduction, remove a reference type on parm
20504 too (which has been swapped into ARG). */
20505 if (strict
== DEDUCE_CONV
&& TYPE_REF_P (*arg
))
20506 *arg
= TREE_TYPE (*arg
);
20511 /* Subroutine of fn_type_unification. PARM is a function parameter of a
20512 template which doesn't contain any deducible template parameters; check if
20513 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
20514 unify_one_argument. */
20517 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
20518 int flags
, struct conversion
**conv_p
,
20524 type
= TREE_TYPE (arg
);
20528 if (same_type_p (parm
, type
))
20529 return unify_success (explain_p
);
20531 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
20532 if (strict
== DEDUCE_CONV
)
20534 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
, complain
))
20535 return unify_success (explain_p
);
20537 else if (strict
!= DEDUCE_EXACT
)
20540 tree conv_arg
= TYPE_P (arg
) ? NULL_TREE
: arg
;
20542 /* Avoid recalculating this in add_function_candidate. */
20544 = good_conversion (parm
, type
, conv_arg
, flags
, complain
));
20546 ok
= can_convert_arg (parm
, type
, conv_arg
, flags
, complain
);
20548 return unify_success (explain_p
);
20551 if (strict
== DEDUCE_EXACT
)
20552 return unify_type_mismatch (explain_p
, parm
, arg
);
20554 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
20557 static bool uses_deducible_template_parms (tree type
);
20559 /* Returns true iff the expression EXPR is one from which a template
20560 argument can be deduced. In other words, if it's an undecorated
20561 use of a template non-type parameter. */
20564 deducible_expression (tree expr
)
20566 /* Strip implicit conversions. */
20567 while (CONVERT_EXPR_P (expr
))
20568 expr
= TREE_OPERAND (expr
, 0);
20569 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
20572 /* Returns true iff the array domain DOMAIN uses a template parameter in a
20573 deducible way; that is, if it has a max value of <PARM> - 1. */
20576 deducible_array_bound (tree domain
)
20578 if (domain
== NULL_TREE
)
20581 tree max
= TYPE_MAX_VALUE (domain
);
20582 if (TREE_CODE (max
) != MINUS_EXPR
)
20585 return deducible_expression (TREE_OPERAND (max
, 0));
20588 /* Returns true iff the template arguments ARGS use a template parameter
20589 in a deducible way. */
20592 deducible_template_args (tree args
)
20594 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
20597 tree elt
= TREE_VEC_ELT (args
, i
);
20598 if (ARGUMENT_PACK_P (elt
))
20599 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
20602 if (PACK_EXPANSION_P (elt
))
20603 elt
= PACK_EXPANSION_PATTERN (elt
);
20604 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
20606 else if (TYPE_P (elt
))
20607 deducible
= uses_deducible_template_parms (elt
);
20609 deducible
= deducible_expression (elt
);
20617 /* Returns true iff TYPE contains any deducible references to template
20618 parameters, as per 14.8.2.5. */
20621 uses_deducible_template_parms (tree type
)
20623 if (PACK_EXPANSION_P (type
))
20624 type
= PACK_EXPANSION_PATTERN (type
);
20631 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20632 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20638 if (INDIRECT_TYPE_P (type
))
20639 return uses_deducible_template_parms (TREE_TYPE (type
));
20641 /* T[integer-constant ]
20643 if (TREE_CODE (type
) == ARRAY_TYPE
)
20644 return (uses_deducible_template_parms (TREE_TYPE (type
))
20645 || deducible_array_bound (TYPE_DOMAIN (type
)));
20657 if (TYPE_PTRMEM_P (type
))
20658 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
20659 || (uses_deducible_template_parms
20660 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
20662 /* template-name <T> (where template-name refers to a class template)
20663 template-name <i> (where template-name refers to a class template) */
20664 if (CLASS_TYPE_P (type
)
20665 && CLASSTYPE_TEMPLATE_INFO (type
)
20666 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
20667 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
20668 (CLASSTYPE_TI_ARGS (type
)));
20673 if (FUNC_OR_METHOD_TYPE_P (type
))
20675 if (uses_deducible_template_parms (TREE_TYPE (type
)))
20677 tree parm
= TYPE_ARG_TYPES (type
);
20678 if (TREE_CODE (type
) == METHOD_TYPE
)
20679 parm
= TREE_CHAIN (parm
);
20680 for (; parm
; parm
= TREE_CHAIN (parm
))
20681 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
20688 /* Subroutine of type_unification_real and unify_pack_expansion to
20689 handle unification of a single P/A pair. Parameters are as
20690 for those functions. */
20693 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
20694 int subr
, unification_kind_t strict
,
20697 tree arg_expr
= NULL_TREE
;
20700 if (arg
== error_mark_node
|| parm
== error_mark_node
)
20701 return unify_invalid (explain_p
);
20702 if (arg
== unknown_type_node
)
20703 /* We can't deduce anything from this, but we might get all the
20704 template args from other function args. */
20705 return unify_success (explain_p
);
20707 /* Implicit conversions (Clause 4) will be performed on a function
20708 argument to convert it to the type of the corresponding function
20709 parameter if the parameter type contains no template-parameters that
20710 participate in template argument deduction. */
20711 if (strict
!= DEDUCE_EXACT
20712 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
20713 /* For function parameters with no deducible template parameters,
20714 just return. We'll check non-dependent conversions later. */
20715 return unify_success (explain_p
);
20720 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
20721 | UNIFY_ALLOW_MORE_CV_QUAL
20722 | UNIFY_ALLOW_DERIVED
);
20726 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
20730 arg_strict
= UNIFY_ALLOW_NONE
;
20734 gcc_unreachable ();
20737 /* We only do these transformations if this is the top-level
20738 parameter_type_list in a call or declaration matching; in other
20739 situations (nested function declarators, template argument lists) we
20740 won't be comparing a type to an expression, and we don't do any type
20746 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
20747 if (type_unknown_p (arg
))
20749 /* [temp.deduct.type] A template-argument can be
20750 deduced from a pointer to function or pointer
20751 to member function argument if the set of
20752 overloaded functions does not contain function
20753 templates and at most one of a set of
20754 overloaded functions provides a unique
20756 resolve_overloaded_unification (tparms
, targs
, parm
,
20758 arg_strict
, explain_p
);
20759 /* If a unique match was not found, this is a
20760 non-deduced context, so we still succeed. */
20761 return unify_success (explain_p
);
20765 arg
= unlowered_expr_type (arg
);
20766 if (arg
== error_mark_node
)
20767 return unify_invalid (explain_p
);
20771 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
20774 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
20775 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
20776 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
20778 /* For deduction from an init-list we need the actual list. */
20779 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
20781 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
20784 /* for_each_template_parm callback that always returns 0. */
20787 zero_r (tree
, void *)
20792 /* for_each_template_parm any_fn callback to handle deduction of a template
20793 type argument from the type of an array bound. */
20796 array_deduction_r (tree t
, void *data
)
20798 tree_pair_p d
= (tree_pair_p
)data
;
20799 tree
&tparms
= d
->purpose
;
20800 tree
&targs
= d
->value
;
20802 if (TREE_CODE (t
) == ARRAY_TYPE
)
20803 if (tree dom
= TYPE_DOMAIN (t
))
20804 if (tree max
= TYPE_MAX_VALUE (dom
))
20806 if (TREE_CODE (max
) == MINUS_EXPR
)
20807 max
= TREE_OPERAND (max
, 0);
20808 if (TREE_CODE (max
) == TEMPLATE_PARM_INDEX
)
20809 unify (tparms
, targs
, TREE_TYPE (max
), size_type_node
,
20810 UNIFY_ALLOW_NONE
, /*explain*/false);
20813 /* Keep walking. */
20817 /* Try to deduce any not-yet-deduced template type arguments from the type of
20818 an array bound. This is handled separately from unify because 14.8.2.5 says
20819 "The type of a type parameter is only deduced from an array bound if it is
20820 not otherwise deduced." */
20823 try_array_deduction (tree tparms
, tree targs
, tree parm
)
20825 tree_pair_s data
= { tparms
, targs
};
20826 hash_set
<tree
> visited
;
20827 for_each_template_parm (parm
, zero_r
, &data
, &visited
,
20828 /*nondeduced*/false, array_deduction_r
);
20831 /* Most parms like fn_type_unification.
20833 If SUBR is 1, we're being called recursively (to unify the
20834 arguments of a function or method parameter of a function
20837 CHECKS is a pointer to a vector of access checks encountered while
20838 substituting default template arguments. */
20841 type_unification_real (tree tparms
,
20845 unsigned int xnargs
,
20847 unification_kind_t strict
,
20848 vec
<deferred_access_check
, va_gc
> **checks
,
20853 int ntparms
= TREE_VEC_LENGTH (tparms
);
20854 int saw_undeduced
= 0;
20857 unsigned int nargs
;
20860 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
20861 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
20862 gcc_assert (ntparms
> 0);
20864 tree targs
= INNERMOST_TEMPLATE_ARGS (full_targs
);
20866 /* Reset the number of non-defaulted template arguments contained
20868 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
20876 while (parms
&& parms
!= void_list_node
20879 parm
= TREE_VALUE (parms
);
20881 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
20882 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
20883 /* For a function parameter pack that occurs at the end of the
20884 parameter-declaration-list, the type A of each remaining
20885 argument of the call is compared with the type P of the
20886 declarator-id of the function parameter pack. */
20889 parms
= TREE_CHAIN (parms
);
20891 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
20892 /* For a function parameter pack that does not occur at the
20893 end of the parameter-declaration-list, the type of the
20894 parameter pack is a non-deduced context. */
20900 if (unify_one_argument (tparms
, full_targs
, parm
, arg
, subr
, strict
,
20906 && parms
!= void_list_node
20907 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
20909 /* Unify the remaining arguments with the pack expansion type. */
20911 tree parmvec
= make_tree_vec (1);
20913 /* Allocate a TREE_VEC and copy in all of the arguments */
20914 argvec
= make_tree_vec (nargs
- ia
);
20915 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
20916 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
20918 /* Copy the parameter into parmvec. */
20919 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
20920 if (unify_pack_expansion (tparms
, full_targs
, parmvec
, argvec
, strict
,
20921 /*subr=*/subr
, explain_p
))
20924 /* Advance to the end of the list of parameters. */
20925 parms
= TREE_CHAIN (parms
);
20928 /* Fail if we've reached the end of the parm list, and more args
20929 are present, and the parm list isn't variadic. */
20930 if (ia
< nargs
&& parms
== void_list_node
)
20931 return unify_too_many_arguments (explain_p
, nargs
, ia
);
20932 /* Fail if parms are left and they don't have default values and
20933 they aren't all deduced as empty packs (c++/57397). This is
20934 consistent with sufficient_parms_p. */
20935 if (parms
&& parms
!= void_list_node
20936 && TREE_PURPOSE (parms
) == NULL_TREE
)
20938 unsigned int count
= nargs
;
20943 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
20946 p
= TREE_CHAIN (p
);
20948 while (p
&& p
!= void_list_node
);
20949 if (count
!= nargs
)
20950 return unify_too_few_arguments (explain_p
, ia
, count
,
20956 tsubst_flags_t complain
= (explain_p
20957 ? tf_warning_or_error
20959 bool tried_array_deduction
= (cxx_dialect
< cxx17
);
20961 for (i
= 0; i
< ntparms
; i
++)
20963 tree targ
= TREE_VEC_ELT (targs
, i
);
20964 tree tparm
= TREE_VEC_ELT (tparms
, i
);
20966 /* Clear the "incomplete" flags on all argument packs now so that
20967 substituting them into later default arguments works. */
20968 if (targ
&& ARGUMENT_PACK_P (targ
))
20970 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
20971 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
20974 if (targ
|| tparm
== error_mark_node
)
20976 tparm
= TREE_VALUE (tparm
);
20978 if (TREE_CODE (tparm
) == TYPE_DECL
20979 && !tried_array_deduction
)
20981 try_array_deduction (tparms
, targs
, xparms
);
20982 tried_array_deduction
= true;
20983 if (TREE_VEC_ELT (targs
, i
))
20987 /* If this is an undeduced nontype parameter that depends on
20988 a type parameter, try another pass; its type may have been
20989 deduced from a later argument than the one from which
20990 this parameter can be deduced. */
20991 if (TREE_CODE (tparm
) == PARM_DECL
20992 && uses_template_parms (TREE_TYPE (tparm
))
20993 && saw_undeduced
< 2)
20999 /* Core issue #226 (C++0x) [temp.deduct]:
21001 If a template argument has not been deduced, its
21002 default template argument, if any, is used.
21004 When we are in C++98 mode, TREE_PURPOSE will either
21005 be NULL_TREE or ERROR_MARK_NODE, so we do not need
21006 to explicitly check cxx_dialect here. */
21007 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
21008 /* OK, there is a default argument. Wait until after the
21009 conversion check to do substitution. */
21012 /* If the type parameter is a parameter pack, then it will
21013 be deduced to an empty parameter pack. */
21014 if (template_parameter_pack_p (tparm
))
21018 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
21020 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
21021 TREE_CONSTANT (arg
) = 1;
21024 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
21026 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
21028 TREE_VEC_ELT (targs
, i
) = arg
;
21032 return unify_parameter_deduction_failure (explain_p
, tparm
);
21035 /* Now substitute into the default template arguments. */
21036 for (i
= 0; i
< ntparms
; i
++)
21038 tree targ
= TREE_VEC_ELT (targs
, i
);
21039 tree tparm
= TREE_VEC_ELT (tparms
, i
);
21041 if (targ
|| tparm
== error_mark_node
)
21043 tree parm
= TREE_VALUE (tparm
);
21044 tree arg
= TREE_PURPOSE (tparm
);
21045 reopen_deferring_access_checks (*checks
);
21046 location_t save_loc
= input_location
;
21048 input_location
= DECL_SOURCE_LOCATION (parm
);
21050 if (saw_undeduced
== 1
21051 && TREE_CODE (parm
) == PARM_DECL
21052 && uses_template_parms (TREE_TYPE (parm
)))
21054 /* The type of this non-type parameter depends on undeduced
21055 parameters. Don't try to use its default argument yet,
21056 since we might deduce an argument for it on the next pass,
21057 but do check whether the arguments we already have cause
21058 substitution failure, so that that happens before we try
21059 later default arguments (78489). */
21060 ++processing_template_decl
;
21061 tree type
= tsubst (TREE_TYPE (parm
), full_targs
, complain
,
21063 --processing_template_decl
;
21064 if (type
== error_mark_node
)
21065 arg
= error_mark_node
;
21071 /* Even if the call is happening in template context, getting
21072 here means it's non-dependent, and a default argument is
21073 considered a separate definition under [temp.decls], so we can
21074 do this substitution without processing_template_decl. This
21075 is important if the default argument contains something that
21076 might be instantiation-dependent like access (87480). */
21077 processing_template_decl_sentinel s
;
21078 tree substed
= NULL_TREE
;
21079 if (saw_undeduced
== 1)
21081 /* First instatiate in template context, in case we still
21082 depend on undeduced template parameters. */
21083 ++processing_template_decl
;
21084 substed
= tsubst_template_arg (arg
, full_targs
, complain
,
21086 --processing_template_decl
;
21087 if (substed
!= error_mark_node
21088 && !uses_template_parms (substed
))
21089 /* We replaced all the tparms, substitute again out of
21090 template context. */
21091 substed
= NULL_TREE
;
21094 substed
= tsubst_template_arg (arg
, full_targs
, complain
,
21097 if (!uses_template_parms (substed
))
21098 arg
= convert_template_argument (parm
, substed
, full_targs
,
21099 complain
, i
, NULL_TREE
);
21100 else if (saw_undeduced
== 1)
21103 arg
= error_mark_node
;
21106 input_location
= save_loc
;
21107 *checks
= get_deferred_access_checks ();
21108 pop_deferring_access_checks ();
21110 if (arg
== error_mark_node
)
21114 TREE_VEC_ELT (targs
, i
) = arg
;
21115 /* The position of the first default template argument,
21116 is also the number of non-defaulted arguments in TARGS.
21118 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
21119 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
21123 if (saw_undeduced
++ == 1)
21127 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
21128 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
21130 return unify_success (explain_p
);
21133 /* Subroutine of type_unification_real. Args are like the variables
21134 at the call site. ARG is an overloaded function (or template-id);
21135 we try deducing template args from each of the overloads, and if
21136 only one succeeds, we go with that. Modifies TARGS and returns
21137 true on success. */
21140 resolve_overloaded_unification (tree tparms
,
21144 unification_kind_t strict
,
21148 tree tempargs
= copy_node (targs
);
21150 tree goodfn
= NULL_TREE
;
21153 if (TREE_CODE (arg
) == ADDR_EXPR
)
21155 arg
= TREE_OPERAND (arg
, 0);
21161 if (TREE_CODE (arg
) == COMPONENT_REF
)
21162 /* Handle `&x' where `x' is some static or non-static member
21164 arg
= TREE_OPERAND (arg
, 1);
21166 if (TREE_CODE (arg
) == OFFSET_REF
)
21167 arg
= TREE_OPERAND (arg
, 1);
21169 /* Strip baselink information. */
21170 if (BASELINK_P (arg
))
21171 arg
= BASELINK_FUNCTIONS (arg
);
21173 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
21175 /* If we got some explicit template args, we need to plug them into
21176 the affected templates before we try to unify, in case the
21177 explicit args will completely resolve the templates in question. */
21180 tree expl_subargs
= TREE_OPERAND (arg
, 1);
21181 arg
= TREE_OPERAND (arg
, 0);
21183 for (lkp_iterator
iter (arg
); iter
; ++iter
)
21186 tree subargs
, elem
;
21188 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
21191 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
21192 expl_subargs
, NULL_TREE
, tf_none
,
21193 /*require_all_args=*/true,
21194 /*use_default_args=*/true);
21195 if (subargs
!= error_mark_node
21196 && !any_dependent_template_arguments_p (subargs
))
21198 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
21199 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
21200 elem
, strict
, sub_strict
, addr_p
, explain_p
)
21201 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
21210 /* If no templates (or more than one) are fully resolved by the
21211 explicit arguments, this template-id is a non-deduced context; it
21212 could still be OK if we deduce all template arguments for the
21213 enclosing call through other arguments. */
21217 else if (!OVL_P (arg
))
21218 /* If ARG is, for example, "(0, &f)" then its type will be unknown
21219 -- but the deduction does not succeed because the expression is
21220 not just the function on its own. */
21223 for (lkp_iterator
iter (arg
); iter
; ++iter
)
21226 if (try_one_overload (tparms
, targs
, tempargs
, parm
, TREE_TYPE (fn
),
21227 strict
, sub_strict
, addr_p
, explain_p
)
21228 && (!goodfn
|| !decls_match (goodfn
, fn
)))
21235 /* [temp.deduct.type] A template-argument can be deduced from a pointer
21236 to function or pointer to member function argument if the set of
21237 overloaded functions does not contain function templates and at most
21238 one of a set of overloaded functions provides a unique match.
21240 So if we found multiple possibilities, we return success but don't
21241 deduce anything. */
21245 int i
= TREE_VEC_LENGTH (targs
);
21247 if (TREE_VEC_ELT (tempargs
, i
))
21249 tree old
= TREE_VEC_ELT (targs
, i
);
21250 tree new_
= TREE_VEC_ELT (tempargs
, i
);
21251 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
21252 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
21253 /* Don't forget explicit template arguments in a pack. */
21254 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
21255 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
21256 TREE_VEC_ELT (targs
, i
) = new_
;
21265 /* Core DR 115: In contexts where deduction is done and fails, or in
21266 contexts where deduction is not done, if a template argument list is
21267 specified and it, along with any default template arguments, identifies
21268 a single function template specialization, then the template-id is an
21269 lvalue for the function template specialization. */
21272 resolve_nondeduced_context (tree orig_expr
, tsubst_flags_t complain
)
21274 tree expr
, offset
, baselink
;
21277 if (!type_unknown_p (orig_expr
))
21282 offset
= NULL_TREE
;
21283 baselink
= NULL_TREE
;
21285 if (TREE_CODE (expr
) == ADDR_EXPR
)
21287 expr
= TREE_OPERAND (expr
, 0);
21290 if (TREE_CODE (expr
) == OFFSET_REF
)
21293 expr
= TREE_OPERAND (expr
, 1);
21295 if (BASELINK_P (expr
))
21298 expr
= BASELINK_FUNCTIONS (expr
);
21301 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
21304 tree goodfn
= NULL_TREE
;
21306 /* If we got some explicit template args, we need to plug them into
21307 the affected templates before we try to unify, in case the
21308 explicit args will completely resolve the templates in question. */
21310 tree expl_subargs
= TREE_OPERAND (expr
, 1);
21311 tree arg
= TREE_OPERAND (expr
, 0);
21312 tree badfn
= NULL_TREE
;
21313 tree badargs
= NULL_TREE
;
21315 for (lkp_iterator
iter (arg
); iter
; ++iter
)
21318 tree subargs
, elem
;
21320 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
21323 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
21324 expl_subargs
, NULL_TREE
, tf_none
,
21325 /*require_all_args=*/true,
21326 /*use_default_args=*/true);
21327 if (subargs
!= error_mark_node
21328 && !any_dependent_template_arguments_p (subargs
))
21330 elem
= instantiate_template (fn
, subargs
, tf_none
);
21331 if (elem
== error_mark_node
)
21336 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
21345 mark_used (goodfn
);
21348 expr
= build_baselink (BASELINK_BINFO (baselink
),
21349 BASELINK_ACCESS_BINFO (baselink
),
21350 expr
, BASELINK_OPTYPE (baselink
));
21354 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
21355 expr
= build_offset_ref (base
, expr
, addr
, complain
);
21358 expr
= cp_build_addr_expr (expr
, complain
);
21361 else if (good
== 0 && badargs
&& (complain
& tf_error
))
21362 /* There were no good options and at least one bad one, so let the
21363 user know what the problem is. */
21364 instantiate_template (badfn
, badargs
, complain
);
21369 /* As above, but error out if the expression remains overloaded. */
21372 resolve_nondeduced_context_or_error (tree exp
, tsubst_flags_t complain
)
21374 exp
= resolve_nondeduced_context (exp
, complain
);
21375 if (type_unknown_p (exp
))
21377 if (complain
& tf_error
)
21378 cxx_incomplete_type_error (exp
, TREE_TYPE (exp
));
21379 return error_mark_node
;
21384 /* Subroutine of resolve_overloaded_unification; does deduction for a single
21385 overload. Fills TARGS with any deduced arguments, or error_mark_node if
21386 different overloads deduce different arguments for a given parm.
21387 ADDR_P is true if the expression for which deduction is being
21388 performed was of the form "& fn" rather than simply "fn".
21390 Returns 1 on success. */
21393 try_one_overload (tree tparms
,
21398 unification_kind_t strict
,
21407 if (arg
== error_mark_node
)
21410 /* [temp.deduct.type] A template-argument can be deduced from a pointer
21411 to function or pointer to member function argument if the set of
21412 overloaded functions does not contain function templates and at most
21413 one of a set of overloaded functions provides a unique match.
21415 So if this is a template, just return success. */
21417 if (uses_template_parms (arg
))
21420 if (TREE_CODE (arg
) == METHOD_TYPE
)
21421 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
21423 arg
= build_pointer_type (arg
);
21425 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
21427 /* We don't copy orig_targs for this because if we have already deduced
21428 some template args from previous args, unify would complain when we
21429 try to deduce a template parameter for the same argument, even though
21430 there isn't really a conflict. */
21431 nargs
= TREE_VEC_LENGTH (targs
);
21432 tempargs
= make_tree_vec (nargs
);
21434 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
21437 /* First make sure we didn't deduce anything that conflicts with
21438 explicitly specified args. */
21439 for (i
= nargs
; i
--; )
21441 tree elt
= TREE_VEC_ELT (tempargs
, i
);
21442 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
21446 else if (uses_template_parms (elt
))
21447 /* Since we're unifying against ourselves, we will fill in
21448 template args used in the function parm list with our own
21449 template parms. Discard them. */
21450 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
21451 else if (oldelt
&& ARGUMENT_PACK_P (oldelt
))
21453 /* Check that the argument at each index of the deduced argument pack
21454 is equivalent to the corresponding explicitly specified argument.
21455 We may have deduced more arguments than were explicitly specified,
21458 /* We used to assert ARGUMENT_PACK_INCOMPLETE_P (oldelt) here, but
21459 that's wrong if we deduce the same argument pack from multiple
21460 function arguments: it's only incomplete the first time. */
21462 tree explicit_pack
= ARGUMENT_PACK_ARGS (oldelt
);
21463 tree deduced_pack
= ARGUMENT_PACK_ARGS (elt
);
21465 if (TREE_VEC_LENGTH (deduced_pack
)
21466 < TREE_VEC_LENGTH (explicit_pack
))
21469 for (int j
= 0; j
< TREE_VEC_LENGTH (explicit_pack
); j
++)
21470 if (!template_args_equal (TREE_VEC_ELT (explicit_pack
, j
),
21471 TREE_VEC_ELT (deduced_pack
, j
)))
21474 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
21478 for (i
= nargs
; i
--; )
21480 tree elt
= TREE_VEC_ELT (tempargs
, i
);
21483 TREE_VEC_ELT (targs
, i
) = elt
;
21489 /* PARM is a template class (perhaps with unbound template
21490 parameters). ARG is a fully instantiated type. If ARG can be
21491 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
21492 TARGS are as for unify. */
21495 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
21498 tree copy_of_targs
;
21500 if (!CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
21502 else if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21503 /* Matches anything. */;
21504 else if (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
21505 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
)))
21508 /* We need to make a new template argument vector for the call to
21509 unify. If we used TARGS, we'd clutter it up with the result of
21510 the attempted unification, even if this class didn't work out.
21511 We also don't want to commit ourselves to all the unifications
21512 we've already done, since unification is supposed to be done on
21513 an argument-by-argument basis. In other words, consider the
21514 following pathological case:
21516 template <int I, int J, int K>
21519 template <int I, int J>
21520 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
21522 template <int I, int J, int K>
21523 void f(S<I, J, K>, S<I, I, I>);
21532 Now, by the time we consider the unification involving `s2', we
21533 already know that we must have `f<0, 0, 0>'. But, even though
21534 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
21535 because there are two ways to unify base classes of S<0, 1, 2>
21536 with S<I, I, I>. If we kept the already deduced knowledge, we
21537 would reject the possibility I=1. */
21538 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
21540 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21542 if (unify_bound_ttp_args (tparms
, copy_of_targs
, parm
, arg
, explain_p
))
21547 /* If unification failed, we're done. */
21548 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
21549 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
21555 /* Given a template type PARM and a class type ARG, find the unique
21556 base type in ARG that is an instance of PARM. We do not examine
21557 ARG itself; only its base-classes. If there is not exactly one
21558 appropriate base class, return NULL_TREE. PARM may be the type of
21559 a partial specialization, as well as a plain template type. Used
21562 static enum template_base_result
21563 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
21564 bool explain_p
, tree
*result
)
21566 tree rval
= NULL_TREE
;
21569 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
21571 binfo
= TYPE_BINFO (complete_type (arg
));
21574 /* The type could not be completed. */
21575 *result
= NULL_TREE
;
21576 return tbr_incomplete_type
;
21579 /* Walk in inheritance graph order. The search order is not
21580 important, and this avoids multiple walks of virtual bases. */
21581 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
21583 tree r
= try_class_unification (tparms
, targs
, parm
,
21584 BINFO_TYPE (binfo
), explain_p
);
21588 /* If there is more than one satisfactory baseclass, then:
21592 If they yield more than one possible deduced A, the type
21596 if (rval
&& !same_type_p (r
, rval
))
21598 *result
= NULL_TREE
;
21599 return tbr_ambiguous_baseclass
;
21607 return tbr_success
;
21610 /* Returns the level of DECL, which declares a template parameter. */
21613 template_decl_level (tree decl
)
21615 switch (TREE_CODE (decl
))
21618 case TEMPLATE_DECL
:
21619 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
21622 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
21625 gcc_unreachable ();
21630 /* Decide whether ARG can be unified with PARM, considering only the
21631 cv-qualifiers of each type, given STRICT as documented for unify.
21632 Returns nonzero iff the unification is OK on that basis. */
21635 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
21637 int arg_quals
= cp_type_quals (arg
);
21638 int parm_quals
= cp_type_quals (parm
);
21640 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
21641 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
21643 /* Although a CVR qualifier is ignored when being applied to a
21644 substituted template parameter ([8.3.2]/1 for example), that
21645 does not allow us to unify "const T" with "int&" because both
21646 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
21647 It is ok when we're allowing additional CV qualifiers
21648 at the outer level [14.8.2.1]/3,1st bullet. */
21649 if ((TYPE_REF_P (arg
)
21650 || FUNC_OR_METHOD_TYPE_P (arg
))
21651 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
21654 if ((!INDIRECT_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
21655 && (parm_quals
& TYPE_QUAL_RESTRICT
))
21659 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
21660 && (arg_quals
& parm_quals
) != parm_quals
)
21663 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
21664 && (parm_quals
& arg_quals
) != arg_quals
)
21670 /* Determines the LEVEL and INDEX for the template parameter PARM. */
21672 template_parm_level_and_index (tree parm
, int* level
, int* index
)
21674 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
21675 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
21676 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21678 *index
= TEMPLATE_TYPE_IDX (parm
);
21679 *level
= TEMPLATE_TYPE_LEVEL (parm
);
21683 *index
= TEMPLATE_PARM_IDX (parm
);
21684 *level
= TEMPLATE_PARM_LEVEL (parm
);
21688 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
21690 if (unify (TP, TA, P, A, S, EP)) \
21694 /* Unifies the remaining arguments in PACKED_ARGS with the pack
21695 expansion at the end of PACKED_PARMS. Returns 0 if the type
21696 deduction succeeds, 1 otherwise. STRICT is the same as in
21697 fn_type_unification. CALL_ARGS_P is true iff PACKED_ARGS is actually a
21698 function call argument list. We'll need to adjust the arguments to make them
21699 types. SUBR tells us if this is from a recursive call to
21700 type_unification_real, or for comparing two template argument
21704 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
21705 tree packed_args
, unification_kind_t strict
,
21706 bool subr
, bool explain_p
)
21709 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
21710 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
21711 tree pack
, packs
= NULL_TREE
;
21712 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
21714 /* Add in any args remembered from an earlier partial instantiation. */
21715 targs
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (parm
), targs
);
21716 int levels
= TMPL_ARGS_DEPTH (targs
);
21718 packed_args
= expand_template_argument_pack (packed_args
);
21720 int len
= TREE_VEC_LENGTH (packed_args
);
21722 /* Determine the parameter packs we will be deducing from the
21723 pattern, and record their current deductions. */
21724 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
21725 pack
; pack
= TREE_CHAIN (pack
))
21727 tree parm_pack
= TREE_VALUE (pack
);
21730 /* Only template parameter packs can be deduced, not e.g. function
21731 parameter packs or __bases or __integer_pack. */
21732 if (!TEMPLATE_PARM_P (parm_pack
))
21735 /* Determine the index and level of this parameter pack. */
21736 template_parm_level_and_index (parm_pack
, &level
, &idx
);
21737 if (level
< levels
)
21740 /* Keep track of the parameter packs and their corresponding
21742 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
21743 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
21746 /* Loop through all of the arguments that have not yet been
21747 unified and unify each with the pattern. */
21748 for (i
= start
; i
< len
; i
++)
21751 bool any_explicit
= false;
21752 tree arg
= TREE_VEC_ELT (packed_args
, i
);
21754 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
21755 or the element of its argument pack at the current index if
21756 this argument was explicitly specified. */
21757 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
21761 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
21764 if (TREE_VALUE (pack
)
21765 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
21766 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
21768 any_explicit
= true;
21769 arg
= TREE_VEC_ELT (pargs
, i
- start
);
21771 TMPL_ARG (targs
, level
, idx
) = arg
;
21774 /* If we had explicit template arguments, substitute them into the
21775 pattern before deduction. */
21778 /* Some arguments might still be unspecified or dependent. */
21780 ++processing_template_decl
;
21781 dependent
= any_dependent_template_arguments_p (targs
);
21783 --processing_template_decl
;
21784 parm
= tsubst (pattern
, targs
,
21785 explain_p
? tf_warning_or_error
: tf_none
,
21788 --processing_template_decl
;
21789 if (parm
== error_mark_node
)
21795 /* Unify the pattern with the current argument. */
21796 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
21800 /* For each parameter pack, collect the deduced value. */
21801 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
21804 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
21806 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
21807 TMPL_ARG (targs
, level
, idx
);
21811 /* Verify that the results of unification with the parameter packs
21812 produce results consistent with what we've seen before, and make
21813 the deduced argument packs available. */
21814 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
21816 tree old_pack
= TREE_VALUE (pack
);
21817 tree new_args
= TREE_TYPE (pack
);
21818 int i
, len
= TREE_VEC_LENGTH (new_args
);
21820 bool nondeduced_p
= false;
21822 /* By default keep the original deduced argument pack.
21823 If necessary, more specific code is going to update the
21824 resulting deduced argument later down in this function. */
21825 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
21826 TMPL_ARG (targs
, level
, idx
) = old_pack
;
21828 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
21829 actually deduce anything. */
21830 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
21831 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
21832 nondeduced_p
= true;
21836 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
21838 /* If we had fewer function args than explicit template args,
21839 just use the explicits. */
21840 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
21841 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
21842 if (len
< explicit_len
)
21843 new_args
= explicit_args
;
21849 /* Build the deduced *_ARGUMENT_PACK. */
21850 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
21852 result
= make_node (NONTYPE_ARGUMENT_PACK
);
21853 TREE_CONSTANT (result
) = 1;
21856 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
21858 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
21860 /* Note the deduced argument packs for this parameter
21862 TMPL_ARG (targs
, level
, idx
) = result
;
21864 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
21865 && (ARGUMENT_PACK_ARGS (old_pack
)
21866 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
21868 /* We only had the explicitly-provided arguments before, but
21869 now we have a complete set of arguments. */
21870 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
21872 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
21873 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
21874 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
21878 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
21879 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
21881 if (!comp_template_args (old_args
, new_args
,
21882 &bad_old_arg
, &bad_new_arg
))
21883 /* Inconsistent unification of this parameter pack. */
21884 return unify_parameter_pack_inconsistent (explain_p
,
21890 return unify_success (explain_p
);
21893 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
21894 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
21895 parameters and return value are as for unify. */
21898 unify_array_domain (tree tparms
, tree targs
,
21899 tree parm_dom
, tree arg_dom
,
21907 /* Our representation of array types uses "N - 1" as the
21908 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
21909 not an integer constant. We cannot unify arbitrarily
21910 complex expressions, so we eliminate the MINUS_EXPRs
21912 parm_max
= TYPE_MAX_VALUE (parm_dom
);
21913 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
21916 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
21917 parm_max
= TREE_OPERAND (parm_max
, 0);
21919 arg_max
= TYPE_MAX_VALUE (arg_dom
);
21920 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
21923 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
21924 trying to unify the type of a variable with the type
21925 of a template parameter. For example:
21927 template <unsigned int N>
21928 void f (char (&) [N]);
21935 Here, the type of the ARG will be "int [g(i)]", and
21936 may be a SAVE_EXPR, etc. */
21937 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
21938 return unify_vla_arg (explain_p
, arg_dom
);
21939 arg_max
= TREE_OPERAND (arg_max
, 0);
21942 /* If only one of the bounds used a MINUS_EXPR, compensate
21943 by adding one to the other bound. */
21944 if (parm_cst
&& !arg_cst
)
21945 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
21949 else if (arg_cst
&& !parm_cst
)
21950 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
21955 return unify (tparms
, targs
, parm_max
, arg_max
,
21956 UNIFY_ALLOW_INTEGER
, explain_p
);
21959 /* Returns whether T, a P or A in unify, is a type, template or expression. */
21961 enum pa_kind_t
{ pa_type
, pa_tmpl
, pa_expr
};
21966 if (PACK_EXPANSION_P (t
))
21967 t
= PACK_EXPANSION_PATTERN (t
);
21968 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
21969 || TREE_CODE (t
) == UNBOUND_CLASS_TEMPLATE
21970 || DECL_TYPE_TEMPLATE_P (t
))
21972 else if (TYPE_P (t
))
21978 /* Deduce the value of template parameters. TPARMS is the (innermost)
21979 set of template parameters to a template. TARGS is the bindings
21980 for those template parameters, as determined thus far; TARGS may
21981 include template arguments for outer levels of template parameters
21982 as well. PARM is a parameter to a template function, or a
21983 subcomponent of that parameter; ARG is the corresponding argument.
21984 This function attempts to match PARM with ARG in a manner
21985 consistent with the existing assignments in TARGS. If more values
21986 are deduced, then TARGS is updated.
21988 Returns 0 if the type deduction succeeds, 1 otherwise. The
21989 parameter STRICT is a bitwise or of the following flags:
21992 Require an exact match between PARM and ARG.
21993 UNIFY_ALLOW_MORE_CV_QUAL:
21994 Allow the deduced ARG to be more cv-qualified (by qualification
21995 conversion) than ARG.
21996 UNIFY_ALLOW_LESS_CV_QUAL:
21997 Allow the deduced ARG to be less cv-qualified than ARG.
21998 UNIFY_ALLOW_DERIVED:
21999 Allow the deduced ARG to be a template base class of ARG,
22000 or a pointer to a template base class of the type pointed to by
22002 UNIFY_ALLOW_INTEGER:
22003 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
22004 case for more information.
22005 UNIFY_ALLOW_OUTER_LEVEL:
22006 This is the outermost level of a deduction. Used to determine validity
22007 of qualification conversions. A valid qualification conversion must
22008 have const qualified pointers leading up to the inner type which
22009 requires additional CV quals, except at the outer level, where const
22010 is not required [conv.qual]. It would be normal to set this flag in
22011 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
22012 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
22013 This is the outermost level of a deduction, and PARM can be more CV
22014 qualified at this point.
22015 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
22016 This is the outermost level of a deduction, and PARM can be less CV
22017 qualified at this point. */
22020 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
22026 int strict_in
= strict
;
22027 tsubst_flags_t complain
= (explain_p
22028 ? tf_warning_or_error
22031 /* I don't think this will do the right thing with respect to types.
22032 But the only case I've seen it in so far has been array bounds, where
22033 signedness is the only information lost, and I think that will be
22035 while (CONVERT_EXPR_P (parm
))
22036 parm
= TREE_OPERAND (parm
, 0);
22038 if (arg
== error_mark_node
)
22039 return unify_invalid (explain_p
);
22040 if (arg
== unknown_type_node
22041 || arg
== init_list_type_node
)
22042 /* We can't deduce anything from this, but we might get all the
22043 template args from other function args. */
22044 return unify_success (explain_p
);
22046 if (parm
== any_targ_node
|| arg
== any_targ_node
)
22047 return unify_success (explain_p
);
22049 /* If PARM uses template parameters, then we can't bail out here,
22050 even if ARG == PARM, since we won't record unifications for the
22051 template parameters. We might need them if we're trying to
22052 figure out which of two things is more specialized. */
22053 if (arg
== parm
&& !uses_template_parms (parm
))
22054 return unify_success (explain_p
);
22056 /* Handle init lists early, so the rest of the function can assume
22057 we're dealing with a type. */
22058 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
22062 tree orig_parm
= parm
;
22064 /* Replace T with std::initializer_list<T> for deduction. */
22065 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
22066 && flag_deduce_init_list
)
22067 parm
= listify (parm
);
22069 if (!is_std_init_list (parm
)
22070 && TREE_CODE (parm
) != ARRAY_TYPE
)
22071 /* We can only deduce from an initializer list argument if the
22072 parameter is std::initializer_list or an array; otherwise this
22073 is a non-deduced context. */
22074 return unify_success (explain_p
);
22076 if (TREE_CODE (parm
) == ARRAY_TYPE
)
22077 elttype
= TREE_TYPE (parm
);
22080 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
22081 /* Deduction is defined in terms of a single type, so just punt
22082 on the (bizarre) std::initializer_list<T...>. */
22083 if (PACK_EXPANSION_P (elttype
))
22084 return unify_success (explain_p
);
22087 if (strict
!= DEDUCE_EXACT
22088 && TYPE_P (elttype
)
22089 && !uses_deducible_template_parms (elttype
))
22090 /* If ELTTYPE has no deducible template parms, skip deduction from
22091 the list elements. */;
22093 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
22095 int elt_strict
= strict
;
22097 if (elt
== error_mark_node
)
22098 return unify_invalid (explain_p
);
22100 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
22102 tree type
= TREE_TYPE (elt
);
22103 if (type
== error_mark_node
)
22104 return unify_invalid (explain_p
);
22105 /* It should only be possible to get here for a call. */
22106 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
22107 elt_strict
|= maybe_adjust_types_for_deduction
22108 (DEDUCE_CALL
, &elttype
, &type
, elt
);
22112 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
22116 if (TREE_CODE (parm
) == ARRAY_TYPE
22117 && deducible_array_bound (TYPE_DOMAIN (parm
)))
22119 /* Also deduce from the length of the initializer list. */
22120 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
22121 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
22122 if (idx
== error_mark_node
)
22123 return unify_invalid (explain_p
);
22124 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
22128 /* If the std::initializer_list<T> deduction worked, replace the
22129 deduced A with std::initializer_list<A>. */
22130 if (orig_parm
!= parm
)
22132 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
22133 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
22134 targ
= listify (targ
);
22135 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
22137 return unify_success (explain_p
);
22140 /* If parm and arg aren't the same kind of thing (template, type, or
22141 expression), fail early. */
22142 if (pa_kind (parm
) != pa_kind (arg
))
22143 return unify_invalid (explain_p
);
22145 /* Immediately reject some pairs that won't unify because of
22146 cv-qualification mismatches. */
22147 if (TREE_CODE (arg
) == TREE_CODE (parm
)
22149 /* It is the elements of the array which hold the cv quals of an array
22150 type, and the elements might be template type parms. We'll check
22151 when we recurse. */
22152 && TREE_CODE (arg
) != ARRAY_TYPE
22153 /* We check the cv-qualifiers when unifying with template type
22154 parameters below. We want to allow ARG `const T' to unify with
22155 PARM `T' for example, when computing which of two templates
22156 is more specialized, for example. */
22157 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
22158 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
22159 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22161 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
22162 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
22163 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
22164 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
22165 strict
&= ~UNIFY_ALLOW_DERIVED
;
22166 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
22167 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
22169 switch (TREE_CODE (parm
))
22171 case TYPENAME_TYPE
:
22173 case UNBOUND_CLASS_TEMPLATE
:
22174 /* In a type which contains a nested-name-specifier, template
22175 argument values cannot be deduced for template parameters used
22176 within the nested-name-specifier. */
22177 return unify_success (explain_p
);
22179 case TEMPLATE_TYPE_PARM
:
22180 case TEMPLATE_TEMPLATE_PARM
:
22181 case BOUND_TEMPLATE_TEMPLATE_PARM
:
22182 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
22183 if (error_operand_p (tparm
))
22184 return unify_invalid (explain_p
);
22186 if (TEMPLATE_TYPE_LEVEL (parm
)
22187 != template_decl_level (tparm
))
22188 /* The PARM is not one we're trying to unify. Just check
22189 to see if it matches ARG. */
22191 if (TREE_CODE (arg
) == TREE_CODE (parm
)
22192 && (is_auto (parm
) ? is_auto (arg
)
22193 : same_type_p (parm
, arg
)))
22194 return unify_success (explain_p
);
22196 return unify_type_mismatch (explain_p
, parm
, arg
);
22198 idx
= TEMPLATE_TYPE_IDX (parm
);
22199 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
22200 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
22201 if (error_operand_p (tparm
))
22202 return unify_invalid (explain_p
);
22204 /* Check for mixed types and values. */
22205 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
22206 && TREE_CODE (tparm
) != TYPE_DECL
)
22207 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
22208 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
22209 gcc_unreachable ();
22211 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22213 if ((strict_in
& UNIFY_ALLOW_DERIVED
)
22214 && CLASS_TYPE_P (arg
))
22216 /* First try to match ARG directly. */
22217 tree t
= try_class_unification (tparms
, targs
, parm
, arg
,
22221 /* Otherwise, look for a suitable base of ARG, as below. */
22222 enum template_base_result r
;
22223 r
= get_template_base (tparms
, targs
, parm
, arg
,
22226 return unify_no_common_base (explain_p
, r
, parm
, arg
);
22230 /* ARG must be constructed from a template class or a template
22231 template parameter. */
22232 else if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
22233 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
22234 return unify_template_deduction_failure (explain_p
, parm
, arg
);
22236 /* Deduce arguments T, i from TT<T> or TT<i>. */
22237 if (unify_bound_ttp_args (tparms
, targs
, parm
, arg
, explain_p
))
22240 arg
= TYPE_TI_TEMPLATE (arg
);
22242 /* Fall through to deduce template name. */
22245 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
22246 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22248 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
22250 /* Simple cases: Value already set, does match or doesn't. */
22251 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
22252 return unify_success (explain_p
);
22254 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
22258 /* If PARM is `const T' and ARG is only `int', we don't have
22259 a match unless we are allowing additional qualification.
22260 If ARG is `const int' and PARM is just `T' that's OK;
22261 that binds `const int' to `T'. */
22262 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
22264 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22266 /* Consider the case where ARG is `const volatile int' and
22267 PARM is `const T'. Then, T should be `volatile int'. */
22268 arg
= cp_build_qualified_type_real
22269 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
22270 if (arg
== error_mark_node
)
22271 return unify_invalid (explain_p
);
22273 /* Simple cases: Value already set, does match or doesn't. */
22274 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
22275 return unify_success (explain_p
);
22277 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
22279 /* Make sure that ARG is not a variable-sized array. (Note
22280 that were talking about variable-sized arrays (like
22281 `int[n]'), rather than arrays of unknown size (like
22282 `int[]').) We'll get very confused by such a type since
22283 the bound of the array is not constant, and therefore
22284 not mangleable. Besides, such types are not allowed in
22285 ISO C++, so we can do as we please here. We do allow
22286 them for 'auto' deduction, since that isn't ABI-exposed. */
22287 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
22288 return unify_vla_arg (explain_p
, arg
);
22290 /* Strip typedefs as in convert_template_argument. */
22291 arg
= canonicalize_type_argument (arg
, tf_none
);
22294 /* If ARG is a parameter pack or an expansion, we cannot unify
22295 against it unless PARM is also a parameter pack. */
22296 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
22297 && !template_parameter_pack_p (parm
))
22298 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
22300 /* If the argument deduction results is a METHOD_TYPE,
22301 then there is a problem.
22302 METHOD_TYPE doesn't map to any real C++ type the result of
22303 the deduction cannot be of that type. */
22304 if (TREE_CODE (arg
) == METHOD_TYPE
)
22305 return unify_method_type_error (explain_p
, arg
);
22307 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
22308 return unify_success (explain_p
);
22310 case TEMPLATE_PARM_INDEX
:
22311 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
22312 if (error_operand_p (tparm
))
22313 return unify_invalid (explain_p
);
22315 if (TEMPLATE_PARM_LEVEL (parm
)
22316 != template_decl_level (tparm
))
22318 /* The PARM is not one we're trying to unify. Just check
22319 to see if it matches ARG. */
22320 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
22321 && cp_tree_equal (parm
, arg
));
22323 unify_expression_unequal (explain_p
, parm
, arg
);
22327 idx
= TEMPLATE_PARM_IDX (parm
);
22328 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
22332 if ((strict
& UNIFY_ALLOW_INTEGER
)
22333 && TREE_TYPE (targ
) && TREE_TYPE (arg
)
22334 && CP_INTEGRAL_TYPE_P (TREE_TYPE (targ
)))
22335 /* We're deducing from an array bound, the type doesn't matter. */
22336 arg
= fold_convert (TREE_TYPE (targ
), arg
);
22337 int x
= !cp_tree_equal (targ
, arg
);
22339 unify_inconsistency (explain_p
, parm
, targ
, arg
);
22343 /* [temp.deduct.type] If, in the declaration of a function template
22344 with a non-type template-parameter, the non-type
22345 template-parameter is used in an expression in the function
22346 parameter-list and, if the corresponding template-argument is
22347 deduced, the template-argument type shall match the type of the
22348 template-parameter exactly, except that a template-argument
22349 deduced from an array bound may be of any integral type.
22350 The non-type parameter might use already deduced type parameters. */
22351 tparm
= TREE_TYPE (parm
);
22352 if (TEMPLATE_PARM_LEVEL (parm
) > TMPL_ARGS_DEPTH (targs
))
22353 /* We don't have enough levels of args to do any substitution. This
22354 can happen in the context of -fnew-ttp-matching. */;
22357 ++processing_template_decl
;
22358 tparm
= tsubst (tparm
, targs
, tf_none
, NULL_TREE
);
22359 --processing_template_decl
;
22361 if (tree a
= type_uses_auto (tparm
))
22363 tparm
= do_auto_deduction (tparm
, arg
, a
, complain
, adc_unify
);
22364 if (tparm
== error_mark_node
)
22369 if (!TREE_TYPE (arg
))
22370 /* Template-parameter dependent expression. Just accept it for now.
22371 It will later be processed in convert_template_argument. */
22373 else if (same_type_p (non_reference (TREE_TYPE (arg
)),
22374 non_reference (tparm
)))
22376 else if ((strict
& UNIFY_ALLOW_INTEGER
)
22377 && CP_INTEGRAL_TYPE_P (tparm
))
22378 /* Convert the ARG to the type of PARM; the deduced non-type
22379 template argument must exactly match the types of the
22380 corresponding parameter. */
22381 arg
= fold (build_nop (tparm
, arg
));
22382 else if (uses_template_parms (tparm
))
22384 /* We haven't deduced the type of this parameter yet. */
22385 if (cxx_dialect
>= cxx17
22386 /* We deduce from array bounds in try_array_deduction. */
22387 && !(strict
& UNIFY_ALLOW_INTEGER
))
22389 /* Deduce it from the non-type argument. */
22390 tree atype
= TREE_TYPE (arg
);
22391 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
22393 UNIFY_ALLOW_NONE
, explain_p
);
22396 /* Try again later. */
22397 return unify_success (explain_p
);
22400 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
22402 /* If ARG is a parameter pack or an expansion, we cannot unify
22403 against it unless PARM is also a parameter pack. */
22404 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
22405 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
22406 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
22409 bool removed_attr
= false;
22410 arg
= strip_typedefs_expr (arg
, &removed_attr
);
22412 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
22413 return unify_success (explain_p
);
22417 /* A pointer-to-member constant can be unified only with
22418 another constant. */
22419 if (TREE_CODE (arg
) != PTRMEM_CST
)
22420 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
22422 /* Just unify the class member. It would be useless (and possibly
22423 wrong, depending on the strict flags) to unify also
22424 PTRMEM_CST_CLASS, because we want to be sure that both parm and
22425 arg refer to the same variable, even if through different
22426 classes. For instance:
22428 struct A { int x; };
22431 Unification of &A::x and &B::x must succeed. */
22432 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
22433 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
22438 if (!TYPE_PTR_P (arg
))
22439 return unify_type_mismatch (explain_p
, parm
, arg
);
22441 /* [temp.deduct.call]
22443 A can be another pointer or pointer to member type that can
22444 be converted to the deduced A via a qualification
22445 conversion (_conv.qual_).
22447 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
22448 This will allow for additional cv-qualification of the
22449 pointed-to types if appropriate. */
22451 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
22452 /* The derived-to-base conversion only persists through one
22453 level of pointers. */
22454 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
22456 return unify (tparms
, targs
, TREE_TYPE (parm
),
22457 TREE_TYPE (arg
), strict
, explain_p
);
22460 case REFERENCE_TYPE
:
22461 if (!TYPE_REF_P (arg
))
22462 return unify_type_mismatch (explain_p
, parm
, arg
);
22463 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
22464 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
22467 if (TREE_CODE (arg
) != ARRAY_TYPE
)
22468 return unify_type_mismatch (explain_p
, parm
, arg
);
22469 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
22470 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
22471 return unify_type_mismatch (explain_p
, parm
, arg
);
22472 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
22473 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
22474 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
22475 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
22476 TYPE_DOMAIN (arg
), explain_p
);
22477 return unify_success (explain_p
);
22484 case ENUMERAL_TYPE
:
22487 if (TREE_CODE (arg
) != TREE_CODE (parm
))
22488 return unify_type_mismatch (explain_p
, parm
, arg
);
22490 /* We have already checked cv-qualification at the top of the
22492 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
22493 return unify_type_mismatch (explain_p
, parm
, arg
);
22495 /* As far as unification is concerned, this wins. Later checks
22496 will invalidate it if necessary. */
22497 return unify_success (explain_p
);
22499 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
22500 /* Type INTEGER_CST can come from ordinary constant template args. */
22502 while (CONVERT_EXPR_P (arg
))
22503 arg
= TREE_OPERAND (arg
, 0);
22505 if (TREE_CODE (arg
) != INTEGER_CST
)
22506 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22507 return (tree_int_cst_equal (parm
, arg
)
22508 ? unify_success (explain_p
)
22509 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
22513 int i
, len
, argslen
;
22514 int parm_variadic_p
= 0;
22516 if (TREE_CODE (arg
) != TREE_VEC
)
22517 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22519 len
= TREE_VEC_LENGTH (parm
);
22520 argslen
= TREE_VEC_LENGTH (arg
);
22522 /* Check for pack expansions in the parameters. */
22523 for (i
= 0; i
< len
; ++i
)
22525 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
22528 /* We can unify against something with a trailing
22530 parm_variadic_p
= 1;
22532 /* [temp.deduct.type]/9: If the template argument list of
22533 P contains a pack expansion that is not the last
22534 template argument, the entire template argument list
22535 is a non-deduced context. */
22536 return unify_success (explain_p
);
22540 /* If we don't have enough arguments to satisfy the parameters
22541 (not counting the pack expression at the end), or we have
22542 too many arguments for a parameter list that doesn't end in
22543 a pack expression, we can't unify. */
22544 if (parm_variadic_p
22545 ? argslen
< len
- parm_variadic_p
22547 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
22549 /* Unify all of the parameters that precede the (optional)
22550 pack expression. */
22551 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
22553 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
22554 TREE_VEC_ELT (parm
, i
),
22555 TREE_VEC_ELT (arg
, i
),
22556 UNIFY_ALLOW_NONE
, explain_p
);
22558 if (parm_variadic_p
)
22559 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
22561 /*subr=*/true, explain_p
);
22562 return unify_success (explain_p
);
22567 if (TREE_CODE (arg
) != TREE_CODE (parm
))
22568 return unify_type_mismatch (explain_p
, parm
, arg
);
22570 if (TYPE_PTRMEMFUNC_P (parm
))
22572 if (!TYPE_PTRMEMFUNC_P (arg
))
22573 return unify_type_mismatch (explain_p
, parm
, arg
);
22575 return unify (tparms
, targs
,
22576 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
22577 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
22578 strict
, explain_p
);
22580 else if (TYPE_PTRMEMFUNC_P (arg
))
22581 return unify_type_mismatch (explain_p
, parm
, arg
);
22583 if (CLASSTYPE_TEMPLATE_INFO (parm
))
22585 tree t
= NULL_TREE
;
22587 if (strict_in
& UNIFY_ALLOW_DERIVED
)
22589 /* First, we try to unify the PARM and ARG directly. */
22590 t
= try_class_unification (tparms
, targs
,
22591 parm
, arg
, explain_p
);
22595 /* Fallback to the special case allowed in
22596 [temp.deduct.call]:
22598 If P is a class, and P has the form
22599 template-id, then A can be a derived class of
22600 the deduced A. Likewise, if P is a pointer to
22601 a class of the form template-id, A can be a
22602 pointer to a derived class pointed to by the
22604 enum template_base_result r
;
22605 r
= get_template_base (tparms
, targs
, parm
, arg
,
22610 /* Don't give the derived diagnostic if we're
22611 already dealing with the same template. */
22613 = (CLASSTYPE_TEMPLATE_INFO (arg
)
22614 && (CLASSTYPE_TI_TEMPLATE (parm
)
22615 == CLASSTYPE_TI_TEMPLATE (arg
)));
22616 return unify_no_common_base (explain_p
&& !same_template
,
22621 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
22622 && (CLASSTYPE_TI_TEMPLATE (parm
)
22623 == CLASSTYPE_TI_TEMPLATE (arg
)))
22624 /* Perhaps PARM is something like S<U> and ARG is S<int>.
22625 Then, we should unify `int' and `U'. */
22628 /* There's no chance of unification succeeding. */
22629 return unify_type_mismatch (explain_p
, parm
, arg
);
22631 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
22632 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
22634 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
22635 return unify_type_mismatch (explain_p
, parm
, arg
);
22636 return unify_success (explain_p
);
22639 case FUNCTION_TYPE
:
22641 unsigned int nargs
;
22646 if (TREE_CODE (arg
) != TREE_CODE (parm
))
22647 return unify_type_mismatch (explain_p
, parm
, arg
);
22649 /* CV qualifications for methods can never be deduced, they must
22650 match exactly. We need to check them explicitly here,
22651 because type_unification_real treats them as any other
22652 cv-qualified parameter. */
22653 if (TREE_CODE (parm
) == METHOD_TYPE
22654 && (!check_cv_quals_for_unify
22656 class_of_this_parm (arg
),
22657 class_of_this_parm (parm
))))
22658 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22659 if (TREE_CODE (arg
) == FUNCTION_TYPE
22660 && type_memfn_quals (parm
) != type_memfn_quals (arg
))
22661 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22662 if (type_memfn_rqual (parm
) != type_memfn_rqual (arg
))
22663 return unify_type_mismatch (explain_p
, parm
, arg
);
22665 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
22666 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
22668 nargs
= list_length (TYPE_ARG_TYPES (arg
));
22669 args
= XALLOCAVEC (tree
, nargs
);
22670 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
22671 a
!= NULL_TREE
&& a
!= void_list_node
;
22672 a
= TREE_CHAIN (a
), ++i
)
22673 args
[i
] = TREE_VALUE (a
);
22676 if (type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
22677 args
, nargs
, 1, DEDUCE_EXACT
,
22681 if (flag_noexcept_type
)
22683 tree pspec
= TYPE_RAISES_EXCEPTIONS (parm
);
22684 tree aspec
= canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (arg
));
22685 if (pspec
== NULL_TREE
) pspec
= noexcept_false_spec
;
22686 if (aspec
== NULL_TREE
) aspec
= noexcept_false_spec
;
22687 if (TREE_PURPOSE (pspec
) && TREE_PURPOSE (aspec
)
22688 && uses_template_parms (TREE_PURPOSE (pspec
)))
22689 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_PURPOSE (pspec
),
22690 TREE_PURPOSE (aspec
),
22691 UNIFY_ALLOW_NONE
, explain_p
);
22692 else if (nothrow_spec_p (pspec
) && !nothrow_spec_p (aspec
))
22693 return unify_type_mismatch (explain_p
, parm
, arg
);
22700 /* Unify a pointer to member with a pointer to member function, which
22701 deduces the type of the member as a function type. */
22702 if (TYPE_PTRMEMFUNC_P (arg
))
22704 /* Check top-level cv qualifiers */
22705 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
22706 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22708 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
22709 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
22710 UNIFY_ALLOW_NONE
, explain_p
);
22712 /* Determine the type of the function we are unifying against. */
22713 tree fntype
= static_fn_type (arg
);
22715 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
22718 if (TREE_CODE (arg
) != OFFSET_TYPE
)
22719 return unify_type_mismatch (explain_p
, parm
, arg
);
22720 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
22721 TYPE_OFFSET_BASETYPE (arg
),
22722 UNIFY_ALLOW_NONE
, explain_p
);
22723 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
22724 strict
, explain_p
);
22727 if (DECL_TEMPLATE_PARM_P (parm
))
22728 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
22729 if (arg
!= scalar_constant_value (parm
))
22730 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22731 return unify_success (explain_p
);
22734 case TEMPLATE_DECL
:
22735 /* Matched cases are handled by the ARG == PARM test above. */
22736 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22739 /* We might get a variable as a non-type template argument in parm if the
22740 corresponding parameter is type-dependent. Make any necessary
22741 adjustments based on whether arg is a reference. */
22742 if (CONSTANT_CLASS_P (arg
))
22743 parm
= fold_non_dependent_expr (parm
, complain
);
22744 else if (REFERENCE_REF_P (arg
))
22746 tree sub
= TREE_OPERAND (arg
, 0);
22748 if (TREE_CODE (sub
) == ADDR_EXPR
)
22749 arg
= TREE_OPERAND (sub
, 0);
22751 /* Now use the normal expression code to check whether they match. */
22754 case TYPE_ARGUMENT_PACK
:
22755 case NONTYPE_ARGUMENT_PACK
:
22756 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
22757 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
22760 case DECLTYPE_TYPE
:
22761 case UNDERLYING_TYPE
:
22762 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
22763 or UNDERLYING_TYPE nodes. */
22764 return unify_success (explain_p
);
22767 /* Unification fails if we hit an error node. */
22768 return unify_invalid (explain_p
);
22771 if (REFERENCE_REF_P (parm
))
22773 bool pexp
= PACK_EXPANSION_P (arg
);
22775 arg
= PACK_EXPANSION_PATTERN (arg
);
22776 if (REFERENCE_REF_P (arg
))
22777 arg
= TREE_OPERAND (arg
, 0);
22779 arg
= make_pack_expansion (arg
, complain
);
22780 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
22781 strict
, explain_p
);
22786 /* An unresolved overload is a nondeduced context. */
22787 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
22788 return unify_success (explain_p
);
22789 gcc_assert (EXPR_P (parm
)
22790 || COMPOUND_LITERAL_P (parm
)
22791 || TREE_CODE (parm
) == TRAIT_EXPR
);
22793 /* We must be looking at an expression. This can happen with
22797 void foo(S<I>, S<I + 2>);
22801 template<typename T>
22802 void foo(A<T, T{}>);
22804 This is a "non-deduced context":
22808 The non-deduced contexts are:
22810 --A non-type template argument or an array bound in which
22811 a subexpression references a template parameter.
22813 In these cases, we assume deduction succeeded, but don't
22814 actually infer any unifications. */
22816 if (!uses_template_parms (parm
)
22817 && !template_args_equal (parm
, arg
))
22818 return unify_expression_unequal (explain_p
, parm
, arg
);
22820 return unify_success (explain_p
);
22823 #undef RECUR_AND_CHECK_FAILURE
22825 /* Note that DECL can be defined in this translation unit, if
22829 mark_definable (tree decl
)
22832 DECL_NOT_REALLY_EXTERN (decl
) = 1;
22833 FOR_EACH_CLONE (clone
, decl
)
22834 DECL_NOT_REALLY_EXTERN (clone
) = 1;
22837 /* Called if RESULT is explicitly instantiated, or is a member of an
22838 explicitly instantiated class. */
22841 mark_decl_instantiated (tree result
, int extern_p
)
22843 SET_DECL_EXPLICIT_INSTANTIATION (result
);
22845 /* If this entity has already been written out, it's too late to
22846 make any modifications. */
22847 if (TREE_ASM_WRITTEN (result
))
22850 /* For anonymous namespace we don't need to do anything. */
22851 if (decl_anon_ns_mem_p (result
))
22853 gcc_assert (!TREE_PUBLIC (result
));
22857 if (TREE_CODE (result
) != FUNCTION_DECL
)
22858 /* The TREE_PUBLIC flag for function declarations will have been
22859 set correctly by tsubst. */
22860 TREE_PUBLIC (result
) = 1;
22862 /* This might have been set by an earlier implicit instantiation. */
22863 DECL_COMDAT (result
) = 0;
22866 DECL_NOT_REALLY_EXTERN (result
) = 0;
22869 mark_definable (result
);
22870 mark_needed (result
);
22871 /* Always make artificials weak. */
22872 if (DECL_ARTIFICIAL (result
) && flag_weak
)
22873 comdat_linkage (result
);
22874 /* For WIN32 we also want to put explicit instantiations in
22875 linkonce sections. */
22876 else if (TREE_PUBLIC (result
))
22877 maybe_make_one_only (result
);
22878 if (TREE_CODE (result
) == FUNCTION_DECL
22879 && DECL_TEMPLATE_INSTANTIATED (result
))
22880 /* If the function has already been instantiated, clear DECL_EXTERNAL,
22881 since start_preparsed_function wouldn't have if we had an earlier
22882 extern explicit instantiation. */
22883 DECL_EXTERNAL (result
) = 0;
22886 /* If EXTERN_P, then this function will not be emitted -- unless
22887 followed by an explicit instantiation, at which point its linkage
22888 will be adjusted. If !EXTERN_P, then this function will be
22889 emitted here. In neither circumstance do we want
22890 import_export_decl to adjust the linkage. */
22891 DECL_INTERFACE_KNOWN (result
) = 1;
22894 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
22895 important template arguments. If any are missing, we check whether
22896 they're important by using error_mark_node for substituting into any
22897 args that were used for partial ordering (the ones between ARGS and END)
22898 and seeing if it bubbles up. */
22901 check_undeduced_parms (tree targs
, tree args
, tree end
)
22903 bool found
= false;
22905 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
22906 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
22909 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
22913 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
22914 if (substed
== error_mark_node
)
22920 /* Given two function templates PAT1 and PAT2, return:
22922 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
22923 -1 if PAT2 is more specialized than PAT1.
22924 0 if neither is more specialized.
22926 LEN indicates the number of parameters we should consider
22927 (defaulted parameters should not be considered).
22929 The 1998 std underspecified function template partial ordering, and
22930 DR214 addresses the issue. We take pairs of arguments, one from
22931 each of the templates, and deduce them against each other. One of
22932 the templates will be more specialized if all the *other*
22933 template's arguments deduce against its arguments and at least one
22934 of its arguments *does* *not* deduce against the other template's
22935 corresponding argument. Deduction is done as for class templates.
22936 The arguments used in deduction have reference and top level cv
22937 qualifiers removed. Iff both arguments were originally reference
22938 types *and* deduction succeeds in both directions, an lvalue reference
22939 wins against an rvalue reference and otherwise the template
22940 with the more cv-qualified argument wins for that pairing (if
22941 neither is more cv-qualified, they both are equal). Unlike regular
22942 deduction, after all the arguments have been deduced in this way,
22943 we do *not* verify the deduced template argument values can be
22944 substituted into non-deduced contexts.
22946 The logic can be a bit confusing here, because we look at deduce1 and
22947 targs1 to see if pat2 is at least as specialized, and vice versa; if we
22948 can find template arguments for pat1 to make arg1 look like arg2, that
22949 means that arg2 is at least as specialized as arg1. */
22952 more_specialized_fn (tree pat1
, tree pat2
, int len
)
22954 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
22955 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
22956 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
22957 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
22958 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
22959 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
22960 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
22961 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
22962 tree origs1
, origs2
;
22963 bool lose1
= false;
22964 bool lose2
= false;
22966 /* Remove the this parameter from non-static member functions. If
22967 one is a non-static member function and the other is not a static
22968 member function, remove the first parameter from that function
22969 also. This situation occurs for operator functions where we
22970 locate both a member function (with this pointer) and non-member
22971 operator (with explicit first operand). */
22972 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
22974 len
--; /* LEN is the number of significant arguments for DECL1 */
22975 args1
= TREE_CHAIN (args1
);
22976 if (!DECL_STATIC_FUNCTION_P (decl2
))
22977 args2
= TREE_CHAIN (args2
);
22979 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
22981 args2
= TREE_CHAIN (args2
);
22982 if (!DECL_STATIC_FUNCTION_P (decl1
))
22985 args1
= TREE_CHAIN (args1
);
22989 /* If only one is a conversion operator, they are unordered. */
22990 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
22993 /* Consider the return type for a conversion function */
22994 if (DECL_CONV_FN_P (decl1
))
22996 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
22997 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
23001 processing_template_decl
++;
23007 /* Stop when an ellipsis is seen. */
23008 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
23010 tree arg1
= TREE_VALUE (args1
);
23011 tree arg2
= TREE_VALUE (args2
);
23012 int deduce1
, deduce2
;
23018 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
23019 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
23021 /* When both arguments are pack expansions, we need only
23022 unify the patterns themselves. */
23023 arg1
= PACK_EXPANSION_PATTERN (arg1
);
23024 arg2
= PACK_EXPANSION_PATTERN (arg2
);
23026 /* This is the last comparison we need to do. */
23030 /* DR 1847: If a particular P contains no template-parameters that
23031 participate in template argument deduction, that P is not used to
23032 determine the ordering. */
23033 if (!uses_deducible_template_parms (arg1
)
23034 && !uses_deducible_template_parms (arg2
))
23037 if (TYPE_REF_P (arg1
))
23039 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
23040 arg1
= TREE_TYPE (arg1
);
23041 quals1
= cp_type_quals (arg1
);
23044 if (TYPE_REF_P (arg2
))
23046 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
23047 arg2
= TREE_TYPE (arg2
);
23048 quals2
= cp_type_quals (arg2
);
23051 arg1
= TYPE_MAIN_VARIANT (arg1
);
23052 arg2
= TYPE_MAIN_VARIANT (arg2
);
23054 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
23056 int i
, len2
= remaining_arguments (args2
);
23057 tree parmvec
= make_tree_vec (1);
23058 tree argvec
= make_tree_vec (len2
);
23061 /* Setup the parameter vector, which contains only ARG1. */
23062 TREE_VEC_ELT (parmvec
, 0) = arg1
;
23064 /* Setup the argument vector, which contains the remaining
23066 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
23067 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
23069 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
23070 argvec
, DEDUCE_EXACT
,
23071 /*subr=*/true, /*explain_p=*/false)
23074 /* We cannot deduce in the other direction, because ARG1 is
23075 a pack expansion but ARG2 is not. */
23078 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
23080 int i
, len1
= remaining_arguments (args1
);
23081 tree parmvec
= make_tree_vec (1);
23082 tree argvec
= make_tree_vec (len1
);
23085 /* Setup the parameter vector, which contains only ARG1. */
23086 TREE_VEC_ELT (parmvec
, 0) = arg2
;
23088 /* Setup the argument vector, which contains the remaining
23090 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
23091 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
23093 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
23094 argvec
, DEDUCE_EXACT
,
23095 /*subr=*/true, /*explain_p=*/false)
23098 /* We cannot deduce in the other direction, because ARG2 is
23099 a pack expansion but ARG1 is not.*/
23105 /* The normal case, where neither argument is a pack
23107 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
23108 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
23110 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
23111 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
23115 /* If we couldn't deduce arguments for tparms1 to make arg1 match
23116 arg2, then arg2 is not as specialized as arg1. */
23122 /* "If, for a given type, deduction succeeds in both directions
23123 (i.e., the types are identical after the transformations above)
23124 and both P and A were reference types (before being replaced with
23125 the type referred to above):
23126 - if the type from the argument template was an lvalue reference and
23127 the type from the parameter template was not, the argument type is
23128 considered to be more specialized than the other; otherwise,
23129 - if the type from the argument template is more cv-qualified
23130 than the type from the parameter template (as described above),
23131 the argument type is considered to be more specialized than the other;
23133 - neither type is more specialized than the other." */
23135 if (deduce1
&& deduce2
)
23137 if (ref1
&& ref2
&& ref1
!= ref2
)
23144 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
23146 if ((quals1
& quals2
) == quals2
)
23148 if ((quals1
& quals2
) == quals1
)
23153 if (lose1
&& lose2
)
23154 /* We've failed to deduce something in either direction.
23155 These must be unordered. */
23160 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
23161 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
23162 /* We have already processed all of the arguments in our
23163 handing of the pack expansion type. */
23166 args1
= TREE_CHAIN (args1
);
23167 args2
= TREE_CHAIN (args2
);
23170 /* "In most cases, all template parameters must have values in order for
23171 deduction to succeed, but for partial ordering purposes a template
23172 parameter may remain without a value provided it is not used in the
23173 types being used for partial ordering."
23175 Thus, if we are missing any of the targs1 we need to substitute into
23176 origs1, then pat2 is not as specialized as pat1. This can happen when
23177 there is a nondeduced context. */
23178 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
23180 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
23183 processing_template_decl
--;
23185 /* If both deductions succeed, the partial ordering selects the more
23186 constrained template. */
23187 if (!lose1
&& !lose2
)
23189 tree c1
= get_constraints (DECL_TEMPLATE_RESULT (pat1
));
23190 tree c2
= get_constraints (DECL_TEMPLATE_RESULT (pat2
));
23191 lose1
= !subsumes_constraints (c1
, c2
);
23192 lose2
= !subsumes_constraints (c2
, c1
);
23195 /* All things being equal, if the next argument is a pack expansion
23196 for one function but not for the other, prefer the
23197 non-variadic function. FIXME this is bogus; see c++/41958. */
23199 && args1
&& TREE_VALUE (args1
)
23200 && args2
&& TREE_VALUE (args2
))
23202 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
23203 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
23206 if (lose1
== lose2
)
23214 /* Determine which of two partial specializations of TMPL is more
23217 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
23218 to the first partial specialization. The TREE_PURPOSE is the
23219 innermost set of template parameters for the partial
23220 specialization. PAT2 is similar, but for the second template.
23222 Return 1 if the first partial specialization is more specialized;
23223 -1 if the second is more specialized; 0 if neither is more
23226 See [temp.class.order] for information about determining which of
23227 two templates is more specialized. */
23230 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
23234 bool any_deductions
= false;
23236 tree tmpl1
= TREE_VALUE (pat1
);
23237 tree tmpl2
= TREE_VALUE (pat2
);
23238 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
23239 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
23241 /* Just like what happens for functions, if we are ordering between
23242 different template specializations, we may encounter dependent
23243 types in the arguments, and we need our dependency check functions
23244 to behave correctly. */
23245 ++processing_template_decl
;
23246 targs
= get_partial_spec_bindings (tmpl
, tmpl1
, specargs2
);
23250 any_deductions
= true;
23253 targs
= get_partial_spec_bindings (tmpl
, tmpl2
, specargs1
);
23257 any_deductions
= true;
23259 --processing_template_decl
;
23261 /* If both deductions succeed, the partial ordering selects the more
23262 constrained template. */
23263 if (!winner
&& any_deductions
)
23264 return more_constrained (tmpl1
, tmpl2
);
23266 /* In the case of a tie where at least one of the templates
23267 has a parameter pack at the end, the template with the most
23268 non-packed parameters wins. */
23271 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
23272 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
23274 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
23275 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
23276 int len1
= TREE_VEC_LENGTH (args1
);
23277 int len2
= TREE_VEC_LENGTH (args2
);
23279 /* We don't count the pack expansion at the end. */
23280 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
23282 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
23287 else if (len1
< len2
)
23294 /* Return the template arguments that will produce the function signature
23295 DECL from the function template FN, with the explicit template
23296 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
23297 also match. Return NULL_TREE if no satisfactory arguments could be
23301 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
23303 int ntparms
= DECL_NTPARMS (fn
);
23304 tree targs
= make_tree_vec (ntparms
);
23305 tree decl_type
= TREE_TYPE (decl
);
23306 tree decl_arg_types
;
23308 unsigned int nargs
, ix
;
23311 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
23313 /* Never do unification on the 'this' parameter. */
23314 decl_arg_types
= skip_artificial_parms_for (decl
,
23315 TYPE_ARG_TYPES (decl_type
));
23317 nargs
= list_length (decl_arg_types
);
23318 args
= XALLOCAVEC (tree
, nargs
);
23319 for (arg
= decl_arg_types
, ix
= 0;
23320 arg
!= NULL_TREE
&& arg
!= void_list_node
;
23321 arg
= TREE_CHAIN (arg
), ++ix
)
23322 args
[ix
] = TREE_VALUE (arg
);
23324 if (fn_type_unification (fn
, explicit_args
, targs
,
23326 (check_rettype
|| DECL_CONV_FN_P (fn
)
23327 ? TREE_TYPE (decl_type
) : NULL_TREE
),
23328 DEDUCE_EXACT
, LOOKUP_NORMAL
, NULL
,
23329 /*explain_p=*/false,
23331 == error_mark_node
)
23337 /* Return the innermost template arguments that, when applied to a partial
23338 specialization SPEC_TMPL of TMPL, yield the ARGS.
23340 For example, suppose we have:
23342 template <class T, class U> struct S {};
23343 template <class T> struct S<T*, int> {};
23345 Then, suppose we want to get `S<double*, int>'. SPEC_TMPL will be the
23346 partial specialization and the ARGS will be {double*, int}. The resulting
23347 vector will be {double}, indicating that `T' is bound to `double'. */
23350 get_partial_spec_bindings (tree tmpl
, tree spec_tmpl
, tree args
)
23352 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
23354 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (spec_tmpl
)));
23355 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
23357 tree innermost_deduced_args
;
23359 innermost_deduced_args
= make_tree_vec (ntparms
);
23360 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
23362 deduced_args
= copy_node (args
);
23363 SET_TMPL_ARGS_LEVEL (deduced_args
,
23364 TMPL_ARGS_DEPTH (deduced_args
),
23365 innermost_deduced_args
);
23368 deduced_args
= innermost_deduced_args
;
23370 bool tried_array_deduction
= (cxx_dialect
< cxx17
);
23372 if (unify (tparms
, deduced_args
,
23373 INNERMOST_TEMPLATE_ARGS (spec_args
),
23374 INNERMOST_TEMPLATE_ARGS (args
),
23375 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
23378 for (i
= 0; i
< ntparms
; ++i
)
23379 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
23381 if (!tried_array_deduction
)
23383 try_array_deduction (tparms
, innermost_deduced_args
,
23384 INNERMOST_TEMPLATE_ARGS (spec_args
));
23385 tried_array_deduction
= true;
23386 if (TREE_VEC_ELT (innermost_deduced_args
, i
))
23392 if (!push_tinst_level (spec_tmpl
, deduced_args
))
23394 excessive_deduction_depth
= true;
23398 /* Verify that nondeduced template arguments agree with the type
23399 obtained from argument deduction.
23403 struct A { typedef int X; };
23404 template <class T, class U> struct C {};
23405 template <class T> struct C<T, typename T::X> {};
23407 Then with the instantiation `C<A, int>', we can deduce that
23408 `T' is `A' but unify () does not check whether `typename T::X'
23410 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
23412 if (spec_args
!= error_mark_node
)
23413 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
23414 INNERMOST_TEMPLATE_ARGS (spec_args
),
23415 tmpl
, tf_none
, false, false);
23417 pop_tinst_level ();
23419 if (spec_args
== error_mark_node
23420 /* We only need to check the innermost arguments; the other
23421 arguments will always agree. */
23422 || !comp_template_args_porder (INNERMOST_TEMPLATE_ARGS (spec_args
),
23423 INNERMOST_TEMPLATE_ARGS (args
)))
23426 /* Now that we have bindings for all of the template arguments,
23427 ensure that the arguments deduced for the template template
23428 parameters have compatible template parameter lists. See the use
23429 of template_template_parm_bindings_ok_p in fn_type_unification
23430 for more information. */
23431 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
23434 return deduced_args
;
23437 // Compare two function templates T1 and T2 by deducing bindings
23438 // from one against the other. If both deductions succeed, compare
23439 // constraints to see which is more constrained.
23441 more_specialized_inst (tree t1
, tree t2
)
23446 if (get_bindings (t1
, DECL_TEMPLATE_RESULT (t2
), NULL_TREE
, true))
23452 if (get_bindings (t2
, DECL_TEMPLATE_RESULT (t1
), NULL_TREE
, true))
23458 // If both deductions succeed, then one may be more constrained.
23459 if (count
== 2 && fate
== 0)
23460 fate
= more_constrained (t1
, t2
);
23465 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
23466 Return the TREE_LIST node with the most specialized template, if
23467 any. If there is no most specialized template, the error_mark_node
23470 Note that this function does not look at, or modify, the
23471 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
23472 returned is one of the elements of INSTANTIATIONS, callers may
23473 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
23474 and retrieve it from the value returned. */
23477 most_specialized_instantiation (tree templates
)
23481 ++processing_template_decl
;
23484 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
23486 gcc_assert (TREE_VALUE (champ
) != TREE_VALUE (fn
));
23487 int fate
= more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
));
23492 /* Equally specialized, move to next function. If there
23493 is no next function, nothing's most specialized. */
23494 fn
= TREE_CHAIN (fn
);
23502 /* Now verify that champ is better than everything earlier in the
23503 instantiation list. */
23504 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
)) {
23505 if (more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
)) != 1)
23512 processing_template_decl
--;
23515 return error_mark_node
;
23520 /* If DECL is a specialization of some template, return the most
23521 general such template. Otherwise, returns NULL_TREE.
23523 For example, given:
23525 template <class T> struct S { template <class U> void f(U); };
23527 if TMPL is `template <class U> void S<int>::f(U)' this will return
23528 the full template. This function will not trace past partial
23529 specializations, however. For example, given in addition:
23531 template <class T> struct S<T*> { template <class U> void f(U); };
23533 if TMPL is `template <class U> void S<int*>::f(U)' this will return
23534 `template <class T> template <class U> S<T*>::f(U)'. */
23537 most_general_template (tree decl
)
23539 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
23541 if (tree tinfo
= get_template_info (decl
))
23542 decl
= TI_TEMPLATE (tinfo
);
23543 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
23544 template friend, or a FIELD_DECL for a capture pack. */
23545 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
23549 /* Look for more and more general templates. */
23550 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
23552 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
23553 (See cp-tree.h for details.) */
23554 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
23557 if (CLASS_TYPE_P (TREE_TYPE (decl
))
23558 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
23559 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
23562 /* Stop if we run into an explicitly specialized class template. */
23563 if (!DECL_NAMESPACE_SCOPE_P (decl
)
23564 && DECL_CONTEXT (decl
)
23565 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
23568 decl
= DECL_TI_TEMPLATE (decl
);
23574 /* Return the most specialized of the template partial specializations
23575 which can produce TARGET, a specialization of some class or variable
23576 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
23577 a TEMPLATE_DECL node corresponding to the partial specialization, while
23578 the TREE_PURPOSE is the set of template arguments that must be
23579 substituted into the template pattern in order to generate TARGET.
23581 If the choice of partial specialization is ambiguous, a diagnostic
23582 is issued, and the error_mark_node is returned. If there are no
23583 partial specializations matching TARGET, then NULL_TREE is
23584 returned, indicating that the primary template should be used. */
23587 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
23589 tree list
= NULL_TREE
;
23594 tree outer_args
= NULL_TREE
;
23597 if (TYPE_P (target
))
23599 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
23600 tmpl
= TI_TEMPLATE (tinfo
);
23601 args
= TI_ARGS (tinfo
);
23603 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
23605 tmpl
= TREE_OPERAND (target
, 0);
23606 args
= TREE_OPERAND (target
, 1);
23608 else if (VAR_P (target
))
23610 tree tinfo
= DECL_TEMPLATE_INFO (target
);
23611 tmpl
= TI_TEMPLATE (tinfo
);
23612 args
= TI_ARGS (tinfo
);
23615 gcc_unreachable ();
23617 tree main_tmpl
= most_general_template (tmpl
);
23619 /* For determining which partial specialization to use, only the
23620 innermost args are interesting. */
23621 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
23623 outer_args
= strip_innermost_template_args (args
, 1);
23624 args
= INNERMOST_TEMPLATE_ARGS (args
);
23627 /* The caller hasn't called push_to_top_level yet, but we need
23628 get_partial_spec_bindings to be done in non-template context so that we'll
23629 fully resolve everything. */
23630 processing_template_decl_sentinel ptds
;
23632 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
23635 tree spec_tmpl
= TREE_VALUE (t
);
23639 /* Substitute in the template args from the enclosing class. */
23640 ++processing_template_decl
;
23641 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
23642 --processing_template_decl
;
23645 if (spec_tmpl
== error_mark_node
)
23646 return error_mark_node
;
23648 spec_args
= get_partial_spec_bindings (tmpl
, spec_tmpl
, args
);
23652 spec_args
= add_to_template_args (outer_args
, spec_args
);
23654 /* Keep the candidate only if the constraints are satisfied,
23655 or if we're not compiling with concepts. */
23657 || constraints_satisfied_p (spec_tmpl
, spec_args
))
23659 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
23660 TREE_TYPE (list
) = TREE_TYPE (t
);
23668 ambiguous_p
= false;
23671 t
= TREE_CHAIN (t
);
23672 for (; t
; t
= TREE_CHAIN (t
))
23674 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
23681 t
= TREE_CHAIN (t
);
23684 ambiguous_p
= true;
23693 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
23695 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
23698 ambiguous_p
= true;
23706 char *spaces
= NULL
;
23707 if (!(complain
& tf_error
))
23708 return error_mark_node
;
23709 if (TYPE_P (target
))
23710 error ("ambiguous template instantiation for %q#T", target
);
23712 error ("ambiguous template instantiation for %q#D", target
);
23713 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
23714 for (t
= list
; t
; t
= TREE_CHAIN (t
))
23716 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
23717 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
23718 "%s %#qS", spaces
? spaces
: str
, subst
);
23719 spaces
= spaces
? spaces
: get_spaces (str
);
23722 return error_mark_node
;
23728 /* Explicitly instantiate DECL. */
23731 do_decl_instantiation (tree decl
, tree storage
)
23733 tree result
= NULL_TREE
;
23736 if (!decl
|| decl
== error_mark_node
)
23737 /* An error occurred, for which grokdeclarator has already issued
23738 an appropriate message. */
23740 else if (! DECL_LANG_SPECIFIC (decl
))
23742 error ("explicit instantiation of non-template %q#D", decl
);
23745 else if (DECL_DECLARED_CONCEPT_P (decl
))
23748 error ("explicit instantiation of variable concept %q#D", decl
);
23750 error ("explicit instantiation of function concept %q#D", decl
);
23754 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
23755 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
23757 if (VAR_P (decl
) && !var_templ
)
23759 /* There is an asymmetry here in the way VAR_DECLs and
23760 FUNCTION_DECLs are handled by grokdeclarator. In the case of
23761 the latter, the DECL we get back will be marked as a
23762 template instantiation, and the appropriate
23763 DECL_TEMPLATE_INFO will be set up. This does not happen for
23764 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
23765 should handle VAR_DECLs as it currently handles
23767 if (!DECL_CLASS_SCOPE_P (decl
))
23769 error ("%qD is not a static data member of a class template", decl
);
23772 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
23773 if (!result
|| !VAR_P (result
))
23775 error ("no matching template for %qD found", decl
);
23778 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
23780 error ("type %qT for explicit instantiation %qD does not match "
23781 "declared type %qT", TREE_TYPE (result
), decl
,
23786 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
23788 error ("explicit instantiation of %q#D", decl
);
23794 /* Check for various error cases. Note that if the explicit
23795 instantiation is valid the RESULT will currently be marked as an
23796 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
23797 until we get here. */
23799 if (DECL_TEMPLATE_SPECIALIZATION (result
))
23801 /* DR 259 [temp.spec].
23803 Both an explicit instantiation and a declaration of an explicit
23804 specialization shall not appear in a program unless the explicit
23805 instantiation follows a declaration of the explicit specialization.
23807 For a given set of template parameters, if an explicit
23808 instantiation of a template appears after a declaration of an
23809 explicit specialization for that template, the explicit
23810 instantiation has no effect. */
23813 else if (DECL_EXPLICIT_INSTANTIATION (result
))
23817 No program shall explicitly instantiate any template more
23820 We check DECL_NOT_REALLY_EXTERN so as not to complain when
23821 the first instantiation was `extern' and the second is not,
23822 and EXTERN_P for the opposite case. */
23823 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
23824 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
23825 /* If an "extern" explicit instantiation follows an ordinary
23826 explicit instantiation, the template is instantiated. */
23830 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
23832 error ("no matching template for %qD found", result
);
23835 else if (!DECL_TEMPLATE_INFO (result
))
23837 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
23841 if (storage
== NULL_TREE
)
23843 else if (storage
== ridpointers
[(int) RID_EXTERN
])
23845 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
23846 pedwarn (input_location
, OPT_Wpedantic
,
23847 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
23852 error ("storage class %qD applied to template instantiation", storage
);
23854 check_explicit_instantiation_namespace (result
);
23855 mark_decl_instantiated (result
, extern_p
);
23857 instantiate_decl (result
, /*defer_ok=*/true,
23858 /*expl_inst_class_mem_p=*/false);
23862 mark_class_instantiated (tree t
, int extern_p
)
23864 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
23865 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
23866 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
23867 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
23870 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
23871 rest_of_type_compilation (t
, 1);
23875 /* Called from do_type_instantiation through binding_table_foreach to
23876 do recursive instantiation for the type bound in ENTRY. */
23878 bt_instantiate_type_proc (binding_entry entry
, void *data
)
23880 tree storage
= *(tree
*) data
;
23882 if (MAYBE_CLASS_TYPE_P (entry
->type
)
23883 && CLASSTYPE_TEMPLATE_INFO (entry
->type
)
23884 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
23885 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
23888 /* Perform an explicit instantiation of template class T. STORAGE, if
23889 non-null, is the RID for extern, inline or static. COMPLAIN is
23890 nonzero if this is called from the parser, zero if called recursively,
23891 since the standard is unclear (as detailed below). */
23894 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
23899 int previous_instantiation_extern_p
= 0;
23901 if (TREE_CODE (t
) == TYPE_DECL
)
23904 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
23907 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
23909 error ("explicit instantiation of non-class template %qD", tmpl
);
23911 error ("explicit instantiation of non-template type %qT", t
);
23917 if (!COMPLETE_TYPE_P (t
))
23919 if (complain
& tf_error
)
23920 error ("explicit instantiation of %q#T before definition of template",
23925 if (storage
!= NULL_TREE
)
23927 if (!in_system_header_at (input_location
))
23929 if (storage
== ridpointers
[(int) RID_EXTERN
])
23931 if (cxx_dialect
== cxx98
)
23932 pedwarn (input_location
, OPT_Wpedantic
,
23933 "ISO C++ 1998 forbids the use of %<extern%> on "
23934 "explicit instantiations");
23937 pedwarn (input_location
, OPT_Wpedantic
,
23938 "ISO C++ forbids the use of %qE"
23939 " on explicit instantiations", storage
);
23942 if (storage
== ridpointers
[(int) RID_INLINE
])
23944 else if (storage
== ridpointers
[(int) RID_EXTERN
])
23946 else if (storage
== ridpointers
[(int) RID_STATIC
])
23950 error ("storage class %qD applied to template instantiation",
23956 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
23958 /* DR 259 [temp.spec].
23960 Both an explicit instantiation and a declaration of an explicit
23961 specialization shall not appear in a program unless the explicit
23962 instantiation follows a declaration of the explicit specialization.
23964 For a given set of template parameters, if an explicit
23965 instantiation of a template appears after a declaration of an
23966 explicit specialization for that template, the explicit
23967 instantiation has no effect. */
23970 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
23974 No program shall explicitly instantiate any template more
23977 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
23978 instantiation was `extern'. If EXTERN_P then the second is.
23979 These cases are OK. */
23980 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
23982 if (!previous_instantiation_extern_p
&& !extern_p
23983 && (complain
& tf_error
))
23984 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
23986 /* If we've already instantiated the template, just return now. */
23987 if (!CLASSTYPE_INTERFACE_ONLY (t
))
23991 check_explicit_instantiation_namespace (TYPE_NAME (t
));
23992 mark_class_instantiated (t
, extern_p
);
23997 /* In contrast to implicit instantiation, where only the
23998 declarations, and not the definitions, of members are
23999 instantiated, we have here:
24003 The explicit instantiation of a class template specialization
24004 implies the instantiation of all of its members not
24005 previously explicitly specialized in the translation unit
24006 containing the explicit instantiation.
24008 Of course, we can't instantiate member template classes, since we
24009 don't have any arguments for them. Note that the standard is
24010 unclear on whether the instantiation of the members are
24011 *explicit* instantiations or not. However, the most natural
24012 interpretation is that it should be an explicit
24014 for (tree fld
= TYPE_FIELDS (t
); fld
; fld
= DECL_CHAIN (fld
))
24016 || (TREE_CODE (fld
) == FUNCTION_DECL
24018 && user_provided_p (fld
)))
24019 && DECL_TEMPLATE_INSTANTIATION (fld
))
24021 mark_decl_instantiated (fld
, extern_p
);
24023 instantiate_decl (fld
, /*defer_ok=*/true,
24024 /*expl_inst_class_mem_p=*/true);
24027 if (CLASSTYPE_NESTED_UTDS (t
))
24028 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
24029 bt_instantiate_type_proc
, &storage
);
24032 /* Given a function DECL, which is a specialization of TMPL, modify
24033 DECL to be a re-instantiation of TMPL with the same template
24034 arguments. TMPL should be the template into which tsubst'ing
24035 should occur for DECL, not the most general template.
24037 One reason for doing this is a scenario like this:
24040 void f(const T&, int i);
24042 void g() { f(3, 7); }
24045 void f(const T& t, const int i) { }
24047 Note that when the template is first instantiated, with
24048 instantiate_template, the resulting DECL will have no name for the
24049 first parameter, and the wrong type for the second. So, when we go
24050 to instantiate the DECL, we regenerate it. */
24053 regenerate_decl_from_template (tree decl
, tree tmpl
, tree args
)
24055 /* The arguments used to instantiate DECL, from the most general
24059 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
24061 /* Make sure that we can see identifiers, and compute access
24063 push_access_scope (decl
);
24065 if (TREE_CODE (decl
) == FUNCTION_DECL
)
24073 args_depth
= TMPL_ARGS_DEPTH (args
);
24074 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
24075 if (args_depth
> parms_depth
)
24076 args
= get_innermost_template_args (args
, parms_depth
);
24078 /* Instantiate a dynamic exception-specification. noexcept will be
24080 if (tree raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (code_pattern
)))
24081 if (TREE_VALUE (raises
))
24083 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
24084 args
, tf_error
, NULL_TREE
,
24085 /*defer_ok*/false);
24086 if (specs
&& specs
!= error_mark_node
)
24087 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
24091 /* Merge parameter declarations. */
24092 decl_parm
= skip_artificial_parms_for (decl
,
24093 DECL_ARGUMENTS (decl
));
24095 = skip_artificial_parms_for (code_pattern
,
24096 DECL_ARGUMENTS (code_pattern
));
24097 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
24102 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
24103 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
24104 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
24106 parm_type
= type_decays_to (parm_type
);
24107 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
24108 TREE_TYPE (decl_parm
) = parm_type
;
24109 attributes
= DECL_ATTRIBUTES (pattern_parm
);
24110 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
24112 DECL_ATTRIBUTES (decl_parm
) = attributes
;
24113 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
24115 decl_parm
= DECL_CHAIN (decl_parm
);
24116 pattern_parm
= DECL_CHAIN (pattern_parm
);
24118 /* Merge any parameters that match with the function parameter
24120 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
24123 tree expanded_types
;
24124 /* Expand the TYPE_PACK_EXPANSION that provides the types for
24125 the parameters in this function parameter pack. */
24126 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
24127 args
, tf_error
, NULL_TREE
);
24128 len
= TREE_VEC_LENGTH (expanded_types
);
24129 for (i
= 0; i
< len
; i
++)
24134 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
24135 /* Rename the parameter to include the index. */
24136 DECL_NAME (decl_parm
) =
24137 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
24138 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
24139 parm_type
= type_decays_to (parm_type
);
24140 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
24141 TREE_TYPE (decl_parm
) = parm_type
;
24142 attributes
= DECL_ATTRIBUTES (pattern_parm
);
24143 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
24145 DECL_ATTRIBUTES (decl_parm
) = attributes
;
24146 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
24148 decl_parm
= DECL_CHAIN (decl_parm
);
24151 /* Merge additional specifiers from the CODE_PATTERN. */
24152 if (DECL_DECLARED_INLINE_P (code_pattern
)
24153 && !DECL_DECLARED_INLINE_P (decl
))
24154 DECL_DECLARED_INLINE_P (decl
) = 1;
24156 maybe_instantiate_noexcept (decl
, tf_error
);
24158 else if (VAR_P (decl
))
24160 start_lambda_scope (decl
);
24161 DECL_INITIAL (decl
) =
24162 tsubst_init (DECL_INITIAL (code_pattern
), decl
, args
,
24163 tf_error
, DECL_TI_TEMPLATE (decl
));
24164 finish_lambda_scope ();
24165 if (VAR_HAD_UNKNOWN_BOUND (decl
))
24166 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
24167 tf_error
, DECL_TI_TEMPLATE (decl
));
24170 gcc_unreachable ();
24172 pop_access_scope (decl
);
24175 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
24176 substituted to get DECL. */
24179 template_for_substitution (tree decl
)
24181 tree tmpl
= DECL_TI_TEMPLATE (decl
);
24183 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
24184 for the instantiation. This is not always the most general
24185 template. Consider, for example:
24188 struct S { template <class U> void f();
24189 template <> void f<int>(); };
24191 and an instantiation of S<double>::f<int>. We want TD to be the
24192 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
24193 while (/* An instantiation cannot have a definition, so we need a
24194 more general template. */
24195 DECL_TEMPLATE_INSTANTIATION (tmpl
)
24196 /* We must also deal with friend templates. Given:
24198 template <class T> struct S {
24199 template <class U> friend void f() {};
24202 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
24203 so far as the language is concerned, but that's still
24204 where we get the pattern for the instantiation from. On
24205 other hand, if the definition comes outside the class, say:
24207 template <class T> struct S {
24208 template <class U> friend void f();
24210 template <class U> friend void f() {}
24212 we don't need to look any further. That's what the check for
24213 DECL_INITIAL is for. */
24214 || (TREE_CODE (decl
) == FUNCTION_DECL
24215 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
24216 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
24218 /* The present template, TD, should not be a definition. If it
24219 were a definition, we should be using it! Note that we
24220 cannot restructure the loop to just keep going until we find
24221 a template with a definition, since that might go too far if
24222 a specialization was declared, but not defined. */
24224 /* Fetch the more general template. */
24225 tmpl
= DECL_TI_TEMPLATE (tmpl
);
24231 /* Returns true if we need to instantiate this template instance even if we
24232 know we aren't going to emit it. */
24235 always_instantiate_p (tree decl
)
24237 /* We always instantiate inline functions so that we can inline them. An
24238 explicit instantiation declaration prohibits implicit instantiation of
24239 non-inline functions. With high levels of optimization, we would
24240 normally inline non-inline functions -- but we're not allowed to do
24241 that for "extern template" functions. Therefore, we check
24242 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
24243 return ((TREE_CODE (decl
) == FUNCTION_DECL
24244 && (DECL_DECLARED_INLINE_P (decl
)
24245 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
24246 /* And we need to instantiate static data members so that
24247 their initializers are available in integral constant
24250 && decl_maybe_constant_var_p (decl
)));
24253 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
24254 instantiate it now, modifying TREE_TYPE (fn). Returns false on
24255 error, true otherwise. */
24258 maybe_instantiate_noexcept (tree fn
, tsubst_flags_t complain
)
24260 tree fntype
, spec
, noex
, clone
;
24262 /* Don't instantiate a noexcept-specification from template context. */
24263 if (processing_template_decl
24264 && (!flag_noexcept_type
|| type_dependent_expression_p (fn
)))
24267 if (DECL_CLONED_FUNCTION_P (fn
))
24268 fn
= DECL_CLONED_FUNCTION (fn
);
24270 tree orig_fn
= NULL_TREE
;
24271 /* For a member friend template we can get a TEMPLATE_DECL. Let's use
24272 its FUNCTION_DECL for the rest of this function -- push_access_scope
24273 doesn't accept TEMPLATE_DECLs. */
24274 if (DECL_FUNCTION_TEMPLATE_P (fn
))
24277 fn
= DECL_TEMPLATE_RESULT (fn
);
24280 fntype
= TREE_TYPE (fn
);
24281 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
24283 if (!spec
|| !TREE_PURPOSE (spec
))
24286 noex
= TREE_PURPOSE (spec
);
24288 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
24290 static hash_set
<tree
>* fns
= new hash_set
<tree
>;
24291 bool added
= false;
24292 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
24294 spec
= get_defaulted_eh_spec (fn
, complain
);
24295 if (spec
== error_mark_node
)
24296 /* This might have failed because of an unparsed DMI, so
24297 let's try again later. */
24300 else if (!(added
= !fns
->add (fn
)))
24302 /* If hash_set::add returns true, the element was already there. */
24303 location_t loc
= cp_expr_loc_or_loc (DEFERRED_NOEXCEPT_PATTERN (noex
),
24304 DECL_SOURCE_LOCATION (fn
));
24306 "exception specification of %qD depends on itself",
24308 spec
= noexcept_false_spec
;
24310 else if (push_tinst_level (fn
))
24312 push_access_scope (fn
);
24313 push_deferring_access_checks (dk_no_deferred
);
24314 input_location
= DECL_SOURCE_LOCATION (fn
);
24316 tree save_ccp
= current_class_ptr
;
24317 tree save_ccr
= current_class_ref
;
24318 /* If needed, set current_class_ptr for the benefit of
24319 tsubst_copy/PARM_DECL. */
24320 tree tdecl
= DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (fn
));
24321 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tdecl
))
24323 tree this_parm
= DECL_ARGUMENTS (tdecl
);
24324 current_class_ptr
= NULL_TREE
;
24325 current_class_ref
= cp_build_fold_indirect_ref (this_parm
);
24326 current_class_ptr
= this_parm
;
24329 /* If this function is represented by a TEMPLATE_DECL, then
24330 the deferred noexcept-specification might still contain
24331 dependent types, even after substitution. And we need the
24332 dependency check functions to work in build_noexcept_spec. */
24334 ++processing_template_decl
;
24336 /* Do deferred instantiation of the noexcept-specifier. */
24337 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
24338 DEFERRED_NOEXCEPT_ARGS (noex
),
24339 tf_warning_or_error
, fn
,
24340 /*function_p=*/false,
24343 current_class_ptr
= save_ccp
;
24344 current_class_ref
= save_ccr
;
24346 /* Build up the noexcept-specification. */
24347 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
24350 --processing_template_decl
;
24352 pop_deferring_access_checks ();
24353 pop_access_scope (fn
);
24354 pop_tinst_level ();
24357 spec
= noexcept_false_spec
;
24362 if (spec
== error_mark_node
)
24364 /* This failed with a hard error, so let's go with false. */
24365 gcc_assert (seen_error ());
24366 spec
= noexcept_false_spec
;
24369 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
24371 TREE_TYPE (orig_fn
) = TREE_TYPE (fn
);
24374 FOR_EACH_CLONE (clone
, fn
)
24376 if (TREE_TYPE (clone
) == fntype
)
24377 TREE_TYPE (clone
) = TREE_TYPE (fn
);
24379 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
24385 /* We're starting to process the function INST, an instantiation of PATTERN;
24386 add their parameters to local_specializations. */
24389 register_parameter_specializations (tree pattern
, tree inst
)
24391 tree tmpl_parm
= DECL_ARGUMENTS (pattern
);
24392 tree spec_parm
= DECL_ARGUMENTS (inst
);
24393 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (inst
))
24395 register_local_specialization (spec_parm
, tmpl_parm
);
24396 spec_parm
= skip_artificial_parms_for (inst
, spec_parm
);
24397 tmpl_parm
= skip_artificial_parms_for (pattern
, tmpl_parm
);
24399 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
24401 if (!DECL_PACK_P (tmpl_parm
))
24403 register_local_specialization (spec_parm
, tmpl_parm
);
24404 spec_parm
= DECL_CHAIN (spec_parm
);
24408 /* Register the (value) argument pack as a specialization of
24409 TMPL_PARM, then move on. */
24410 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
24411 register_local_specialization (argpack
, tmpl_parm
);
24414 gcc_assert (!spec_parm
);
24417 /* Produce the definition of D, a _DECL generated from a template. If
24418 DEFER_OK is true, then we don't have to actually do the
24419 instantiation now; we just have to do it sometime. Normally it is
24420 an error if this is an explicit instantiation but D is undefined.
24421 EXPL_INST_CLASS_MEM_P is true iff D is a member of an explicitly
24422 instantiated class template. */
24425 instantiate_decl (tree d
, bool defer_ok
, bool expl_inst_class_mem_p
)
24427 tree tmpl
= DECL_TI_TEMPLATE (d
);
24434 bool pattern_defined
;
24435 location_t saved_loc
= input_location
;
24436 int saved_unevaluated_operand
= cp_unevaluated_operand
;
24437 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
24441 /* This function should only be used to instantiate templates for
24442 functions and static member variables. */
24443 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
24445 /* A concept is never instantiated. */
24446 gcc_assert (!DECL_DECLARED_CONCEPT_P (d
));
24448 /* Variables are never deferred; if instantiation is required, they
24449 are instantiated right away. That allows for better code in the
24450 case that an expression refers to the value of the variable --
24451 if the variable has a constant value the referring expression can
24452 take advantage of that fact. */
24456 /* Don't instantiate cloned functions. Instead, instantiate the
24457 functions they cloned. */
24458 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
24459 d
= DECL_CLONED_FUNCTION (d
);
24461 if (DECL_TEMPLATE_INSTANTIATED (d
)
24462 || (TREE_CODE (d
) == FUNCTION_DECL
24463 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
24464 || DECL_TEMPLATE_SPECIALIZATION (d
))
24465 /* D has already been instantiated or explicitly specialized, so
24466 there's nothing for us to do here.
24468 It might seem reasonable to check whether or not D is an explicit
24469 instantiation, and, if so, stop here. But when an explicit
24470 instantiation is deferred until the end of the compilation,
24471 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
24472 the instantiation. */
24475 /* Check to see whether we know that this template will be
24476 instantiated in some other file, as with "extern template"
24478 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
24480 /* In general, we do not instantiate such templates. */
24481 if (external_p
&& !always_instantiate_p (d
))
24484 gen_tmpl
= most_general_template (tmpl
);
24485 gen_args
= DECL_TI_ARGS (d
);
24487 if (tmpl
!= gen_tmpl
)
24488 /* We should already have the extra args. */
24489 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
24490 == TMPL_ARGS_DEPTH (gen_args
));
24491 /* And what's in the hash table should match D. */
24492 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
24493 || spec
== NULL_TREE
);
24495 /* This needs to happen before any tsubsting. */
24496 if (! push_tinst_level (d
))
24499 timevar_push (TV_TEMPLATE_INST
);
24501 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
24502 for the instantiation. */
24503 td
= template_for_substitution (d
);
24508 /* Look up an explicit specialization, if any. */
24509 tree tid
= lookup_template_variable (gen_tmpl
, gen_args
);
24510 tree elt
= most_specialized_partial_spec (tid
, tf_warning_or_error
);
24511 if (elt
&& elt
!= error_mark_node
)
24513 td
= TREE_VALUE (elt
);
24514 args
= TREE_PURPOSE (elt
);
24518 code_pattern
= DECL_TEMPLATE_RESULT (td
);
24520 /* We should never be trying to instantiate a member of a class
24521 template or partial specialization. */
24522 gcc_assert (d
!= code_pattern
);
24524 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
24525 || DECL_TEMPLATE_SPECIALIZATION (td
))
24526 /* In the case of a friend template whose definition is provided
24527 outside the class, we may have too many arguments. Drop the
24528 ones we don't need. The same is true for specializations. */
24529 args
= get_innermost_template_args
24530 (args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
24532 if (TREE_CODE (d
) == FUNCTION_DECL
)
24534 deleted_p
= DECL_DELETED_FN (code_pattern
);
24535 pattern_defined
= ((DECL_SAVED_TREE (code_pattern
) != NULL_TREE
24536 && DECL_INITIAL (code_pattern
) != error_mark_node
)
24537 || DECL_DEFAULTED_FN (code_pattern
)
24543 if (DECL_CLASS_SCOPE_P (code_pattern
))
24544 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
24546 pattern_defined
= ! DECL_EXTERNAL (code_pattern
);
24549 /* We may be in the middle of deferred access check. Disable it now. */
24550 push_deferring_access_checks (dk_no_deferred
);
24552 /* Unless an explicit instantiation directive has already determined
24553 the linkage of D, remember that a definition is available for
24555 if (pattern_defined
24556 && !DECL_INTERFACE_KNOWN (d
)
24557 && !DECL_NOT_REALLY_EXTERN (d
))
24558 mark_definable (d
);
24560 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
24561 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
24562 input_location
= DECL_SOURCE_LOCATION (d
);
24564 /* If D is a member of an explicitly instantiated class template,
24565 and no definition is available, treat it like an implicit
24567 if (!pattern_defined
&& expl_inst_class_mem_p
24568 && DECL_EXPLICIT_INSTANTIATION (d
))
24570 /* Leave linkage flags alone on instantiations with anonymous
24572 if (TREE_PUBLIC (d
))
24574 DECL_NOT_REALLY_EXTERN (d
) = 0;
24575 DECL_INTERFACE_KNOWN (d
) = 0;
24577 SET_DECL_IMPLICIT_INSTANTIATION (d
);
24580 /* Defer all other templates, unless we have been explicitly
24581 forbidden from doing so. */
24582 if (/* If there is no definition, we cannot instantiate the
24585 /* If it's OK to postpone instantiation, do so. */
24587 /* If this is a static data member that will be defined
24588 elsewhere, we don't want to instantiate the entire data
24589 member, but we do want to instantiate the initializer so that
24590 we can substitute that elsewhere. */
24591 || (external_p
&& VAR_P (d
))
24592 /* Handle here a deleted function too, avoid generating
24593 its body (c++/61080). */
24596 /* The definition of the static data member is now required so
24597 we must substitute the initializer. */
24599 && !DECL_INITIAL (d
)
24600 && DECL_INITIAL (code_pattern
))
24604 bool const_init
= false;
24605 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
24607 ns
= decl_namespace_context (d
);
24608 push_nested_namespace (ns
);
24610 push_nested_class (DECL_CONTEXT (d
));
24611 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
24613 tf_warning_or_error
, NULL_TREE
,
24614 /*integral_constant_expression_p=*/false);
24615 /* If instantiating the initializer involved instantiating this
24616 again, don't call cp_finish_decl twice. */
24617 if (!DECL_INITIAL (d
))
24619 /* Make sure the initializer is still constant, in case of
24620 circular dependency (template/instantiate6.C). */
24622 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
24623 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
24624 /*asmspec_tree=*/NULL_TREE
,
24625 LOOKUP_ONLYCONVERTING
);
24628 pop_nested_class ();
24629 pop_nested_namespace (ns
);
24632 /* We restore the source position here because it's used by
24633 add_pending_template. */
24634 input_location
= saved_loc
;
24636 if (at_eof
&& !pattern_defined
24637 && DECL_EXPLICIT_INSTANTIATION (d
)
24638 && DECL_NOT_REALLY_EXTERN (d
))
24641 The definition of a non-exported function template, a
24642 non-exported member function template, or a non-exported
24643 member function or static data member of a class template
24644 shall be present in every translation unit in which it is
24645 explicitly instantiated. */
24646 permerror (input_location
, "explicit instantiation of %qD "
24647 "but no definition available", d
);
24649 /* If we're in unevaluated context, we just wanted to get the
24650 constant value; this isn't an odr use, so don't queue
24651 a full instantiation. */
24652 if (cp_unevaluated_operand
!= 0)
24654 /* ??? Historically, we have instantiated inline functions, even
24655 when marked as "extern template". */
24656 if (!(external_p
&& VAR_P (d
)))
24657 add_pending_template (d
);
24660 /* Tell the repository that D is available in this translation unit
24661 -- and see if it is supposed to be instantiated here. */
24662 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
24664 /* In a PCH file, despite the fact that the repository hasn't
24665 requested instantiation in the PCH it is still possible that
24666 an instantiation will be required in a file that includes the
24669 add_pending_template (d
);
24670 /* Instantiate inline functions so that the inliner can do its
24671 job, even though we'll not be emitting a copy of this
24673 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
24677 bool push_to_top
, nested
;
24679 fn_context
= decl_function_context (d
);
24680 if (LAMBDA_FUNCTION_P (d
))
24681 /* tsubst_lambda_expr resolved any references to enclosing functions. */
24682 fn_context
= NULL_TREE
;
24683 nested
= current_function_decl
!= NULL_TREE
;
24684 push_to_top
= !(nested
&& fn_context
== current_function_decl
);
24686 vec
<tree
> omp_privatization_save
;
24688 save_omp_privatization_clauses (omp_privatization_save
);
24691 push_to_top_level ();
24694 gcc_assert (!processing_template_decl
);
24695 push_function_context ();
24696 cp_unevaluated_operand
= 0;
24697 c_inhibit_evaluation_warnings
= 0;
24700 /* Mark D as instantiated so that recursive calls to
24701 instantiate_decl do not try to instantiate it again. */
24702 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
24704 /* Regenerate the declaration in case the template has been modified
24705 by a subsequent redeclaration. */
24706 regenerate_decl_from_template (d
, td
, args
);
24708 /* We already set the file and line above. Reset them now in case
24709 they changed as a result of calling regenerate_decl_from_template. */
24710 input_location
= DECL_SOURCE_LOCATION (d
);
24715 bool const_init
= false;
24717 /* Clear out DECL_RTL; whatever was there before may not be right
24718 since we've reset the type of the declaration. */
24719 SET_DECL_RTL (d
, NULL
);
24720 DECL_IN_AGGR_P (d
) = 0;
24722 /* The initializer is placed in DECL_INITIAL by
24723 regenerate_decl_from_template so we don't need to
24724 push/pop_access_scope again here. Pull it out so that
24725 cp_finish_decl can process it. */
24726 init
= DECL_INITIAL (d
);
24727 DECL_INITIAL (d
) = NULL_TREE
;
24728 DECL_INITIALIZED_P (d
) = 0;
24730 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
24731 initializer. That function will defer actual emission until
24732 we have a chance to determine linkage. */
24733 DECL_EXTERNAL (d
) = 0;
24735 /* Enter the scope of D so that access-checking works correctly. */
24736 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
24738 push_nested_class (DECL_CONTEXT (d
));
24740 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
24741 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
24744 pop_nested_class ();
24746 if (variable_template_p (gen_tmpl
))
24747 note_variable_template_instantiation (d
);
24749 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
24750 synthesize_method (d
);
24751 else if (TREE_CODE (d
) == FUNCTION_DECL
)
24753 /* Set up the list of local specializations. */
24754 local_specialization_stack
lss (push_to_top
? lss_blank
: lss_copy
);
24755 tree block
= NULL_TREE
;
24757 /* Set up context. */
24758 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
24759 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
24760 block
= push_stmt_list ();
24762 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
24764 /* Some typedefs referenced from within the template code need to be
24765 access checked at template instantiation time, i.e now. These
24766 types were added to the template at parsing time. Let's get those
24767 and perform the access checks then. */
24768 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (td
),
24771 /* Create substitution entries for the parameters. */
24772 register_parameter_specializations (code_pattern
, d
);
24774 /* Substitute into the body of the function. */
24775 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
24776 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
24777 tf_warning_or_error
, tmpl
);
24780 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
24781 tf_warning_or_error
, tmpl
,
24782 /*integral_constant_expression_p=*/false);
24784 /* Set the current input_location to the end of the function
24785 so that finish_function knows where we are. */
24787 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
24789 /* Remember if we saw an infinite loop in the template. */
24790 current_function_infinite_loop
24791 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
24794 /* Finish the function. */
24795 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
24796 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
24797 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
24800 d
= finish_function (/*inline_p=*/false);
24801 expand_or_defer_fn (d
);
24804 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
24805 cp_check_omp_declare_reduction (d
);
24808 /* We're not deferring instantiation any more. */
24809 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
24812 pop_from_top_level ();
24814 pop_function_context ();
24817 restore_omp_privatization_clauses (omp_privatization_save
);
24820 pop_deferring_access_checks ();
24821 timevar_pop (TV_TEMPLATE_INST
);
24822 pop_tinst_level ();
24823 input_location
= saved_loc
;
24824 cp_unevaluated_operand
= saved_unevaluated_operand
;
24825 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
24830 /* Run through the list of templates that we wish we could
24831 instantiate, and instantiate any we can. RETRIES is the
24832 number of times we retry pending template instantiation. */
24835 instantiate_pending_templates (int retries
)
24838 location_t saved_loc
= input_location
;
24840 /* Instantiating templates may trigger vtable generation. This in turn
24841 may require further template instantiations. We place a limit here
24842 to avoid infinite loop. */
24843 if (pending_templates
&& retries
>= max_tinst_depth
)
24845 tree decl
= pending_templates
->tinst
->maybe_get_node ();
24847 fatal_error (input_location
,
24848 "template instantiation depth exceeds maximum of %d"
24849 " instantiating %q+D, possibly from virtual table generation"
24850 " (use %<-ftemplate-depth=%> to increase the maximum)",
24851 max_tinst_depth
, decl
);
24852 if (TREE_CODE (decl
) == FUNCTION_DECL
)
24853 /* Pretend that we defined it. */
24854 DECL_INITIAL (decl
) = error_mark_node
;
24860 struct pending_template
**t
= &pending_templates
;
24861 struct pending_template
*last
= NULL
;
24865 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
24866 bool complete
= false;
24868 if (TYPE_P (instantiation
))
24870 if (!COMPLETE_TYPE_P (instantiation
))
24872 instantiate_class_template (instantiation
);
24873 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
24874 for (tree fld
= TYPE_FIELDS (instantiation
);
24875 fld
; fld
= TREE_CHAIN (fld
))
24877 || (TREE_CODE (fld
) == FUNCTION_DECL
24878 && !DECL_ARTIFICIAL (fld
)))
24879 && DECL_TEMPLATE_INSTANTIATION (fld
))
24880 instantiate_decl (fld
,
24881 /*defer_ok=*/false,
24882 /*expl_inst_class_mem_p=*/false);
24884 if (COMPLETE_TYPE_P (instantiation
))
24888 complete
= COMPLETE_TYPE_P (instantiation
);
24892 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
24893 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
24896 = instantiate_decl (instantiation
,
24897 /*defer_ok=*/false,
24898 /*expl_inst_class_mem_p=*/false);
24899 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
24903 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
24904 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
24909 /* If INSTANTIATION has been instantiated, then we don't
24910 need to consider it again in the future. */
24911 struct pending_template
*drop
= *t
;
24913 set_refcount_ptr (drop
->tinst
);
24914 pending_template_freelist ().free (drop
);
24922 set_refcount_ptr (current_tinst_level
);
24924 last_pending_template
= last
;
24926 while (reconsider
);
24928 input_location
= saved_loc
;
24931 /* Substitute ARGVEC into T, which is a list of initializers for
24932 either base class or a non-static data member. The TREE_PURPOSEs
24933 are DECLs, and the TREE_VALUEs are the initializer values. Used by
24934 instantiate_decl. */
24937 tsubst_initializer_list (tree t
, tree argvec
)
24939 tree inits
= NULL_TREE
;
24940 tree target_ctor
= error_mark_node
;
24942 for (; t
; t
= TREE_CHAIN (t
))
24946 tree expanded_bases
= NULL_TREE
;
24947 tree expanded_arguments
= NULL_TREE
;
24950 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
24955 /* Expand the base class expansion type into separate base
24957 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
24958 tf_warning_or_error
,
24960 if (expanded_bases
== error_mark_node
)
24963 /* We'll be building separate TREE_LISTs of arguments for
24965 len
= TREE_VEC_LENGTH (expanded_bases
);
24966 expanded_arguments
= make_tree_vec (len
);
24967 for (i
= 0; i
< len
; i
++)
24968 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
24970 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
24971 expand each argument in the TREE_VALUE of t. */
24972 expr
= make_node (EXPR_PACK_EXPANSION
);
24973 PACK_EXPANSION_LOCAL_P (expr
) = true;
24974 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
24975 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
24977 if (TREE_VALUE (t
) == void_type_node
)
24978 /* VOID_TYPE_NODE is used to indicate
24979 value-initialization. */
24981 for (i
= 0; i
< len
; i
++)
24982 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
24986 /* Substitute parameter packs into each argument in the
24988 in_base_initializer
= 1;
24989 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
24991 tree expanded_exprs
;
24993 /* Expand the argument. */
24994 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
24996 = tsubst_pack_expansion (expr
, argvec
,
24997 tf_warning_or_error
,
24999 if (expanded_exprs
== error_mark_node
)
25002 /* Prepend each of the expanded expressions to the
25003 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
25004 for (i
= 0; i
< len
; i
++)
25006 TREE_VEC_ELT (expanded_arguments
, i
) =
25007 tree_cons (NULL_TREE
,
25008 TREE_VEC_ELT (expanded_exprs
, i
),
25009 TREE_VEC_ELT (expanded_arguments
, i
));
25012 in_base_initializer
= 0;
25014 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
25015 since we built them backwards. */
25016 for (i
= 0; i
< len
; i
++)
25018 TREE_VEC_ELT (expanded_arguments
, i
) =
25019 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
25024 for (i
= 0; i
< len
; ++i
)
25026 if (expanded_bases
)
25028 decl
= TREE_VEC_ELT (expanded_bases
, i
);
25029 decl
= expand_member_init (decl
);
25030 init
= TREE_VEC_ELT (expanded_arguments
, i
);
25035 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
25036 tf_warning_or_error
, NULL_TREE
);
25038 decl
= expand_member_init (decl
);
25039 if (decl
&& !DECL_P (decl
))
25040 in_base_initializer
= 1;
25042 init
= TREE_VALUE (t
);
25044 if (init
!= void_type_node
)
25045 init
= tsubst_expr (init
, argvec
,
25046 tf_warning_or_error
, NULL_TREE
,
25047 /*integral_constant_expression_p=*/false);
25048 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
25049 /* If we had an initializer but it instantiated to nothing,
25050 value-initialize the object. This will only occur when
25051 the initializer was a pack expansion where the parameter
25052 packs used in that expansion were of length zero. */
25053 init
= void_type_node
;
25054 in_base_initializer
= 0;
25057 if (target_ctor
!= error_mark_node
25058 && init
!= error_mark_node
)
25060 error ("mem-initializer for %qD follows constructor delegation",
25064 /* Look for a target constructor. */
25065 if (init
!= error_mark_node
25066 && decl
&& CLASS_TYPE_P (decl
)
25067 && same_type_p (decl
, current_class_type
))
25069 maybe_warn_cpp0x (CPP0X_DELEGATING_CTORS
);
25072 error ("constructor delegation follows mem-initializer for %qD",
25073 TREE_PURPOSE (inits
));
25076 target_ctor
= init
;
25081 init
= build_tree_list (decl
, init
);
25082 TREE_CHAIN (init
) = inits
;
25090 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
25093 set_current_access_from_decl (tree decl
)
25095 if (TREE_PRIVATE (decl
))
25096 current_access_specifier
= access_private_node
;
25097 else if (TREE_PROTECTED (decl
))
25098 current_access_specifier
= access_protected_node
;
25100 current_access_specifier
= access_public_node
;
25103 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
25104 is the instantiation (which should have been created with
25105 start_enum) and ARGS are the template arguments to use. */
25108 tsubst_enum (tree tag
, tree newtag
, tree args
)
25112 if (SCOPED_ENUM_P (newtag
))
25113 begin_scope (sk_scoped_enum
, newtag
);
25115 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
25120 decl
= TREE_VALUE (e
);
25121 /* Note that in a template enum, the TREE_VALUE is the
25122 CONST_DECL, not the corresponding INTEGER_CST. */
25123 value
= tsubst_expr (DECL_INITIAL (decl
),
25124 args
, tf_warning_or_error
, NULL_TREE
,
25125 /*integral_constant_expression_p=*/true);
25127 /* Give this enumeration constant the correct access. */
25128 set_current_access_from_decl (decl
);
25130 /* Actually build the enumerator itself. Here we're assuming that
25131 enumerators can't have dependent attributes. */
25132 build_enumerator (DECL_NAME (decl
), value
, newtag
,
25133 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
25136 if (SCOPED_ENUM_P (newtag
))
25139 finish_enum_value_list (newtag
);
25140 finish_enum (newtag
);
25142 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
25143 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
25146 /* DECL is a FUNCTION_DECL that is a template specialization. Return
25147 its type -- but without substituting the innermost set of template
25148 arguments. So, innermost set of template parameters will appear in
25152 get_mostly_instantiated_function_type (tree decl
)
25154 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
25155 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
25158 /* Return truthvalue if we're processing a template different from
25159 the last one involved in diagnostics. */
25161 problematic_instantiation_changed (void)
25163 return current_tinst_level
!= last_error_tinst_level
;
25166 /* Remember current template involved in diagnostics. */
25168 record_last_problematic_instantiation (void)
25170 set_refcount_ptr (last_error_tinst_level
, current_tinst_level
);
25173 struct tinst_level
*
25174 current_instantiation (void)
25176 return current_tinst_level
;
25179 /* Return TRUE if current_function_decl is being instantiated, false
25183 instantiating_current_function_p (void)
25185 return (current_instantiation ()
25186 && (current_instantiation ()->maybe_get_node ()
25187 == current_function_decl
));
25190 /* [temp.param] Check that template non-type parm TYPE is of an allowable
25191 type. Return false for ok, true for disallowed. Issue error and
25192 inform messages under control of COMPLAIN. */
25195 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
25197 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
25199 else if (TYPE_PTR_P (type
))
25201 else if (TYPE_REF_P (type
)
25202 && !TYPE_REF_IS_RVALUE (type
))
25204 else if (TYPE_PTRMEM_P (type
))
25206 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
25208 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
25210 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
25212 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
25214 /* A bound template template parm could later be instantiated to have a valid
25215 nontype parm type via an alias template. */
25216 else if (cxx_dialect
>= cxx11
25217 && TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
25219 else if (CLASS_TYPE_P (type
))
25221 if (cxx_dialect
< cxx2a
)
25223 error ("non-type template parameters of class type only available "
25224 "with %<-std=c++2a%> or %<-std=gnu++2a%>");
25227 if (!complete_type_or_else (type
, NULL_TREE
))
25229 if (!literal_type_p (type
))
25231 error ("%qT is not a valid type for a template non-type parameter "
25232 "because it is not literal", type
);
25233 explain_non_literal_class (type
);
25236 if (cp_has_mutable_p (type
))
25238 error ("%qT is not a valid type for a template non-type parameter "
25239 "because it has a mutable member", type
);
25242 /* FIXME check op<=> and strong structural equality once spaceship is
25247 if (complain
& tf_error
)
25249 if (type
== error_mark_node
)
25250 inform (input_location
, "invalid template non-type parameter");
25252 error ("%q#T is not a valid type for a template non-type parameter",
25258 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
25259 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
25262 dependent_type_p_r (tree type
)
25268 A type is dependent if it is:
25270 -- a template parameter. Template template parameters are types
25271 for us (since TYPE_P holds true for them) so we handle
25273 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
25274 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
25276 /* -- a qualified-id with a nested-name-specifier which contains a
25277 class-name that names a dependent type or whose unqualified-id
25278 names a dependent type. */
25279 if (TREE_CODE (type
) == TYPENAME_TYPE
)
25282 /* An alias template specialization can be dependent even if the
25283 resulting type is not. */
25284 if (dependent_alias_template_spec_p (type
))
25287 /* -- a cv-qualified type where the cv-unqualified type is
25289 No code is necessary for this bullet; the code below handles
25290 cv-qualified types, and we don't want to strip aliases with
25291 TYPE_MAIN_VARIANT because of DR 1558. */
25292 /* -- a compound type constructed from any dependent type. */
25293 if (TYPE_PTRMEM_P (type
))
25294 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
25295 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
25297 else if (INDIRECT_TYPE_P (type
))
25298 return dependent_type_p (TREE_TYPE (type
));
25299 else if (FUNC_OR_METHOD_TYPE_P (type
))
25303 if (dependent_type_p (TREE_TYPE (type
)))
25305 for (arg_type
= TYPE_ARG_TYPES (type
);
25307 arg_type
= TREE_CHAIN (arg_type
))
25308 if (dependent_type_p (TREE_VALUE (arg_type
)))
25310 if (cxx_dialect
>= cxx17
)
25311 /* A value-dependent noexcept-specifier makes the type dependent. */
25312 if (tree spec
= TYPE_RAISES_EXCEPTIONS (type
))
25313 if (tree noex
= TREE_PURPOSE (spec
))
25314 /* Treat DEFERRED_NOEXCEPT as non-dependent, since it doesn't
25315 affect overload resolution and treating it as dependent breaks
25316 things. Same for an unparsed noexcept expression. */
25317 if (TREE_CODE (noex
) != DEFERRED_NOEXCEPT
25318 && TREE_CODE (noex
) != DEFERRED_PARSE
25319 && value_dependent_expression_p (noex
))
25323 /* -- an array type constructed from any dependent type or whose
25324 size is specified by a constant expression that is
25327 We checked for type- and value-dependence of the bounds in
25328 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
25329 if (TREE_CODE (type
) == ARRAY_TYPE
)
25331 if (TYPE_DOMAIN (type
)
25332 && dependent_type_p (TYPE_DOMAIN (type
)))
25334 return dependent_type_p (TREE_TYPE (type
));
25337 /* -- a template-id in which either the template name is a template
25339 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
25341 /* ... or any of the template arguments is a dependent type or
25342 an expression that is type-dependent or value-dependent. */
25343 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
25344 && (any_dependent_template_arguments_p
25345 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
25348 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
25349 dependent; if the argument of the `typeof' expression is not
25350 type-dependent, then it should already been have resolved. */
25351 if (TREE_CODE (type
) == TYPEOF_TYPE
25352 || TREE_CODE (type
) == DECLTYPE_TYPE
25353 || TREE_CODE (type
) == UNDERLYING_TYPE
)
25356 /* A template argument pack is dependent if any of its packed
25358 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
25360 tree args
= ARGUMENT_PACK_ARGS (type
);
25361 int i
, len
= TREE_VEC_LENGTH (args
);
25362 for (i
= 0; i
< len
; ++i
)
25363 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
25367 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
25368 be template parameters. */
25369 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
25372 if (any_dependent_type_attributes_p (TYPE_ATTRIBUTES (type
)))
25375 /* The standard does not specifically mention types that are local
25376 to template functions or local classes, but they should be
25377 considered dependent too. For example:
25379 template <int I> void f() {
25384 The size of `E' cannot be known until the value of `I' has been
25385 determined. Therefore, `E' must be considered dependent. */
25386 scope
= TYPE_CONTEXT (type
);
25387 if (scope
&& TYPE_P (scope
))
25388 return dependent_type_p (scope
);
25389 /* Don't use type_dependent_expression_p here, as it can lead
25390 to infinite recursion trying to determine whether a lambda
25391 nested in a lambda is dependent (c++/47687). */
25392 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
25393 && DECL_LANG_SPECIFIC (scope
)
25394 && DECL_TEMPLATE_INFO (scope
)
25395 && (any_dependent_template_arguments_p
25396 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
25399 /* Other types are non-dependent. */
25403 /* Returns TRUE if TYPE is dependent, in the sense of
25404 [temp.dep.type]. Note that a NULL type is considered dependent. */
25407 dependent_type_p (tree type
)
25409 /* If there are no template parameters in scope, then there can't be
25410 any dependent types. */
25411 if (!processing_template_decl
)
25413 /* If we are not processing a template, then nobody should be
25414 providing us with a dependent type. */
25416 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
25420 /* If the type is NULL, we have not computed a type for the entity
25421 in question; in that case, the type is dependent. */
25425 /* Erroneous types can be considered non-dependent. */
25426 if (type
== error_mark_node
)
25429 /* Getting here with global_type_node means we improperly called this
25430 function on the TREE_TYPE of an IDENTIFIER_NODE. */
25431 gcc_checking_assert (type
!= global_type_node
);
25433 /* If we have not already computed the appropriate value for TYPE,
25435 if (!TYPE_DEPENDENT_P_VALID (type
))
25437 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
25438 TYPE_DEPENDENT_P_VALID (type
) = 1;
25441 return TYPE_DEPENDENT_P (type
);
25444 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
25445 lookup. In other words, a dependent type that is not the current
25449 dependent_scope_p (tree scope
)
25451 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
25452 && !currently_open_class (scope
));
25455 /* T is a SCOPE_REF. Return whether it represents a non-static member of
25456 an unknown base of 'this' (and is therefore instantiation-dependent). */
25459 unknown_base_ref_p (tree t
)
25461 if (!current_class_ptr
)
25464 tree mem
= TREE_OPERAND (t
, 1);
25465 if (shared_member_p (mem
))
25468 tree cur
= current_nonlambda_class_type ();
25469 if (!any_dependent_bases_p (cur
))
25472 tree ctx
= TREE_OPERAND (t
, 0);
25473 if (DERIVED_FROM_P (ctx
, cur
))
25479 /* T is a SCOPE_REF; return whether we need to consider it
25480 instantiation-dependent so that we can check access at instantiation
25481 time even though we know which member it resolves to. */
25484 instantiation_dependent_scope_ref_p (tree t
)
25486 if (DECL_P (TREE_OPERAND (t
, 1))
25487 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
25488 && !unknown_base_ref_p (t
)
25489 && accessible_in_template_p (TREE_OPERAND (t
, 0),
25490 TREE_OPERAND (t
, 1)))
25496 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
25497 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
25500 /* Note that this predicate is not appropriate for general expressions;
25501 only constant expressions (that satisfy potential_constant_expression)
25502 can be tested for value dependence. */
25505 value_dependent_expression_p (tree expression
)
25507 if (!processing_template_decl
|| expression
== NULL_TREE
)
25510 /* A type-dependent expression is also value-dependent. */
25511 if (type_dependent_expression_p (expression
))
25514 switch (TREE_CODE (expression
))
25517 /* A dependent member function of the current instantiation. */
25518 return dependent_type_p (BINFO_TYPE (BASELINK_BINFO (expression
)));
25520 case FUNCTION_DECL
:
25521 /* A dependent member function of the current instantiation. */
25522 if (DECL_CLASS_SCOPE_P (expression
)
25523 && dependent_type_p (DECL_CONTEXT (expression
)))
25527 case IDENTIFIER_NODE
:
25528 /* A name that has not been looked up -- must be dependent. */
25531 case TEMPLATE_PARM_INDEX
:
25532 /* A non-type template parm. */
25536 /* A non-type template parm. */
25537 if (DECL_TEMPLATE_PARM_P (expression
))
25539 return value_dependent_expression_p (DECL_INITIAL (expression
));
25542 /* A constant with literal type and is initialized
25543 with an expression that is value-dependent. */
25544 if (DECL_DEPENDENT_INIT_P (expression
)
25545 /* FIXME cp_finish_decl doesn't fold reference initializers. */
25546 || TYPE_REF_P (TREE_TYPE (expression
)))
25548 if (DECL_HAS_VALUE_EXPR_P (expression
))
25550 tree value_expr
= DECL_VALUE_EXPR (expression
);
25551 if (value_dependent_expression_p (value_expr
))
25556 case DYNAMIC_CAST_EXPR
:
25557 case STATIC_CAST_EXPR
:
25558 case CONST_CAST_EXPR
:
25559 case REINTERPRET_CAST_EXPR
:
25561 case IMPLICIT_CONV_EXPR
:
25562 /* These expressions are value-dependent if the type to which
25563 the cast occurs is dependent or the expression being casted
25564 is value-dependent. */
25566 tree type
= TREE_TYPE (expression
);
25568 if (dependent_type_p (type
))
25571 /* A functional cast has a list of operands. */
25572 expression
= TREE_OPERAND (expression
, 0);
25575 /* If there are no operands, it must be an expression such
25576 as "int()". This should not happen for aggregate types
25577 because it would form non-constant expressions. */
25578 gcc_assert (cxx_dialect
>= cxx11
25579 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
25584 if (TREE_CODE (expression
) == TREE_LIST
)
25585 return any_value_dependent_elements_p (expression
);
25587 return value_dependent_expression_p (expression
);
25591 if (SIZEOF_EXPR_TYPE_P (expression
))
25592 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
25596 /* A `sizeof' expression is value-dependent if the operand is
25597 type-dependent or is a pack expansion. */
25598 expression
= TREE_OPERAND (expression
, 0);
25599 if (PACK_EXPANSION_P (expression
))
25601 else if (TYPE_P (expression
))
25602 return dependent_type_p (expression
);
25603 return instantiation_dependent_uneval_expression_p (expression
);
25605 case AT_ENCODE_EXPR
:
25606 /* An 'encode' expression is value-dependent if the operand is
25608 expression
= TREE_OPERAND (expression
, 0);
25609 return dependent_type_p (expression
);
25611 case NOEXCEPT_EXPR
:
25612 expression
= TREE_OPERAND (expression
, 0);
25613 return instantiation_dependent_uneval_expression_p (expression
);
25616 /* All instantiation-dependent expressions should also be considered
25617 value-dependent. */
25618 return instantiation_dependent_scope_ref_p (expression
);
25620 case COMPONENT_REF
:
25621 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
25622 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
25624 case NONTYPE_ARGUMENT_PACK
:
25625 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
25626 is value-dependent. */
25628 tree values
= ARGUMENT_PACK_ARGS (expression
);
25629 int i
, len
= TREE_VEC_LENGTH (values
);
25631 for (i
= 0; i
< len
; ++i
)
25632 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
25640 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
25642 if (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
)))
25648 if (TREE_CODE (type2
) != TREE_LIST
)
25649 return dependent_type_p (type2
);
25651 for (; type2
; type2
= TREE_CHAIN (type2
))
25652 if (dependent_type_p (TREE_VALUE (type2
)))
25659 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
25660 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
25663 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
25664 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
25668 tree op
= TREE_OPERAND (expression
, 0);
25669 return (value_dependent_expression_p (op
)
25670 || has_value_dependent_address (op
));
25673 case REQUIRES_EXPR
:
25674 /* Treat all requires-expressions as value-dependent so
25675 we don't try to fold them. */
25679 return dependent_type_p (TREE_OPERAND (expression
, 0));
25683 if (value_dependent_expression_p (CALL_EXPR_FN (expression
)))
25685 tree fn
= get_callee_fndecl (expression
);
25687 nargs
= call_expr_nargs (expression
);
25688 for (i
= 0; i
< nargs
; ++i
)
25690 tree op
= CALL_EXPR_ARG (expression
, i
);
25691 /* In a call to a constexpr member function, look through the
25692 implicit ADDR_EXPR on the object argument so that it doesn't
25693 cause the call to be considered value-dependent. We also
25694 look through it in potential_constant_expression. */
25695 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
25696 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
25697 && TREE_CODE (op
) == ADDR_EXPR
)
25698 op
= TREE_OPERAND (op
, 0);
25699 if (value_dependent_expression_p (op
))
25705 case TEMPLATE_ID_EXPR
:
25706 return variable_concept_p (TREE_OPERAND (expression
, 0));
25712 if (dependent_type_p (TREE_TYPE (expression
)))
25714 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
25715 if (value_dependent_expression_p (val
))
25721 /* Treat a GNU statement expression as dependent to avoid crashing
25722 under instantiate_non_dependent_expr; it can't be constant. */
25726 /* A constant expression is value-dependent if any subexpression is
25727 value-dependent. */
25728 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
25730 case tcc_reference
:
25732 case tcc_comparison
:
25734 case tcc_expression
:
25737 int i
, len
= cp_tree_operand_length (expression
);
25739 for (i
= 0; i
< len
; i
++)
25741 tree t
= TREE_OPERAND (expression
, i
);
25743 /* In some cases, some of the operands may be missing.
25744 (For example, in the case of PREDECREMENT_EXPR, the
25745 amount to increment by may be missing.) That doesn't
25746 make the expression dependent. */
25747 if (t
&& value_dependent_expression_p (t
))
25758 /* The expression is not value-dependent. */
25762 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
25763 [temp.dep.expr]. Note that an expression with no type is
25764 considered dependent. Other parts of the compiler arrange for an
25765 expression with type-dependent subexpressions to have no type, so
25766 this function doesn't have to be fully recursive. */
25769 type_dependent_expression_p (tree expression
)
25771 if (!processing_template_decl
)
25774 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
25777 STRIP_ANY_LOCATION_WRAPPER (expression
);
25779 /* An unresolved name is always dependent. */
25780 if (identifier_p (expression
)
25781 || TREE_CODE (expression
) == USING_DECL
25782 || TREE_CODE (expression
) == WILDCARD_DECL
)
25785 /* A lambda-expression in template context is dependent. dependent_type_p is
25786 true for a lambda in the scope of a class or function template, but that
25787 doesn't cover all template contexts, like a default template argument. */
25788 if (TREE_CODE (expression
) == LAMBDA_EXPR
)
25791 /* A fold expression is type-dependent. */
25792 if (TREE_CODE (expression
) == UNARY_LEFT_FOLD_EXPR
25793 || TREE_CODE (expression
) == UNARY_RIGHT_FOLD_EXPR
25794 || TREE_CODE (expression
) == BINARY_LEFT_FOLD_EXPR
25795 || TREE_CODE (expression
) == BINARY_RIGHT_FOLD_EXPR
)
25798 /* Some expression forms are never type-dependent. */
25799 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
25800 || TREE_CODE (expression
) == SIZEOF_EXPR
25801 || TREE_CODE (expression
) == ALIGNOF_EXPR
25802 || TREE_CODE (expression
) == AT_ENCODE_EXPR
25803 || TREE_CODE (expression
) == NOEXCEPT_EXPR
25804 || TREE_CODE (expression
) == TRAIT_EXPR
25805 || TREE_CODE (expression
) == TYPEID_EXPR
25806 || TREE_CODE (expression
) == DELETE_EXPR
25807 || TREE_CODE (expression
) == VEC_DELETE_EXPR
25808 || TREE_CODE (expression
) == THROW_EXPR
25809 || TREE_CODE (expression
) == REQUIRES_EXPR
)
25812 /* The types of these expressions depends only on the type to which
25813 the cast occurs. */
25814 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
25815 || TREE_CODE (expression
) == STATIC_CAST_EXPR
25816 || TREE_CODE (expression
) == CONST_CAST_EXPR
25817 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
25818 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
25819 || TREE_CODE (expression
) == CAST_EXPR
)
25820 return dependent_type_p (TREE_TYPE (expression
));
25822 /* The types of these expressions depends only on the type created
25823 by the expression. */
25824 if (TREE_CODE (expression
) == NEW_EXPR
25825 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
25827 /* For NEW_EXPR tree nodes created inside a template, either
25828 the object type itself or a TREE_LIST may appear as the
25830 tree type
= TREE_OPERAND (expression
, 1);
25831 if (TREE_CODE (type
) == TREE_LIST
)
25832 /* This is an array type. We need to check array dimensions
25834 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
25835 || value_dependent_expression_p
25836 (TREE_OPERAND (TREE_VALUE (type
), 1));
25838 return dependent_type_p (type
);
25841 if (TREE_CODE (expression
) == SCOPE_REF
)
25843 tree scope
= TREE_OPERAND (expression
, 0);
25844 tree name
= TREE_OPERAND (expression
, 1);
25846 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
25847 contains an identifier associated by name lookup with one or more
25848 declarations declared with a dependent type, or...a
25849 nested-name-specifier or qualified-id that names a member of an
25850 unknown specialization. */
25851 return (type_dependent_expression_p (name
)
25852 || dependent_scope_p (scope
));
25855 if (TREE_CODE (expression
) == TEMPLATE_DECL
25856 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
25857 return uses_outer_template_parms (expression
);
25859 if (TREE_CODE (expression
) == STMT_EXPR
)
25860 expression
= stmt_expr_value_expr (expression
);
25862 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
25867 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
25869 if (type_dependent_expression_p (elt
))
25875 /* A static data member of the current instantiation with incomplete
25876 array type is type-dependent, as the definition and specializations
25877 can have different bounds. */
25878 if (VAR_P (expression
)
25879 && DECL_CLASS_SCOPE_P (expression
)
25880 && dependent_type_p (DECL_CONTEXT (expression
))
25881 && VAR_HAD_UNKNOWN_BOUND (expression
))
25884 /* An array of unknown bound depending on a variadic parameter, eg:
25886 template<typename... Args>
25887 void foo (Args... args)
25889 int arr[] = { args... };
25892 template<int... vals>
25895 int arr[] = { vals... };
25898 If the array has no length and has an initializer, it must be that
25899 we couldn't determine its length in cp_complete_array_type because
25900 it is dependent. */
25901 if (VAR_P (expression
)
25902 && TREE_TYPE (expression
) != NULL_TREE
25903 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
25904 && !TYPE_DOMAIN (TREE_TYPE (expression
))
25905 && DECL_INITIAL (expression
))
25908 /* A function or variable template-id is type-dependent if it has any
25909 dependent template arguments. */
25910 if (VAR_OR_FUNCTION_DECL_P (expression
)
25911 && DECL_LANG_SPECIFIC (expression
)
25912 && DECL_TEMPLATE_INFO (expression
))
25914 /* Consider the innermost template arguments, since those are the ones
25915 that come from the template-id; the template arguments for the
25916 enclosing class do not make it type-dependent unless they are used in
25917 the type of the decl. */
25918 if (instantiates_primary_template_p (expression
)
25919 && (any_dependent_template_arguments_p
25920 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
25924 /* Otherwise, if the function decl isn't from a dependent scope, it can't be
25925 type-dependent. Checking this is important for functions with auto return
25926 type, which looks like a dependent type. */
25927 if (TREE_CODE (expression
) == FUNCTION_DECL
25928 && !(DECL_CLASS_SCOPE_P (expression
)
25929 && dependent_type_p (DECL_CONTEXT (expression
)))
25930 && !(DECL_LANG_SPECIFIC (expression
)
25931 && DECL_FRIEND_P (expression
)
25932 && (!DECL_FRIEND_CONTEXT (expression
)
25933 || dependent_type_p (DECL_FRIEND_CONTEXT (expression
))))
25934 && !DECL_LOCAL_FUNCTION_P (expression
))
25936 gcc_assert (!dependent_type_p (TREE_TYPE (expression
))
25937 || undeduced_auto_decl (expression
));
25941 /* Always dependent, on the number of arguments if nothing else. */
25942 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
25945 if (TREE_TYPE (expression
) == unknown_type_node
)
25947 if (TREE_CODE (expression
) == ADDR_EXPR
)
25948 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
25949 if (TREE_CODE (expression
) == COMPONENT_REF
25950 || TREE_CODE (expression
) == OFFSET_REF
)
25952 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
25954 expression
= TREE_OPERAND (expression
, 1);
25955 if (identifier_p (expression
))
25958 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
25959 if (TREE_CODE (expression
) == SCOPE_REF
)
25962 if (BASELINK_P (expression
))
25964 if (BASELINK_OPTYPE (expression
)
25965 && dependent_type_p (BASELINK_OPTYPE (expression
)))
25967 expression
= BASELINK_FUNCTIONS (expression
);
25970 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
25972 if (any_dependent_template_arguments_p
25973 (TREE_OPERAND (expression
, 1)))
25975 expression
= TREE_OPERAND (expression
, 0);
25976 if (identifier_p (expression
))
25980 gcc_assert (OVL_P (expression
));
25982 for (lkp_iterator
iter (expression
); iter
; ++iter
)
25983 if (type_dependent_expression_p (*iter
))
25989 /* The type of a non-type template parm declared with a placeholder type
25990 depends on the corresponding template argument, even though
25991 placeholders are not normally considered dependent. */
25992 if (TREE_CODE (expression
) == TEMPLATE_PARM_INDEX
25993 && is_auto (TREE_TYPE (expression
)))
25996 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
25998 /* Dependent type attributes might not have made it from the decl to
26000 if (DECL_P (expression
)
26001 && any_dependent_type_attributes_p (DECL_ATTRIBUTES (expression
)))
26004 return (dependent_type_p (TREE_TYPE (expression
)));
26007 /* [temp.dep.expr]/5: A class member access expression (5.2.5) is
26008 type-dependent if the expression refers to a member of the current
26009 instantiation and the type of the referenced member is dependent, or the
26010 class member access expression refers to a member of an unknown
26013 This function returns true if the OBJECT in such a class member access
26014 expression is of an unknown specialization. */
26017 type_dependent_object_expression_p (tree object
)
26019 /* An IDENTIFIER_NODE can sometimes have a TREE_TYPE, but it's still
26021 if (TREE_CODE (object
) == IDENTIFIER_NODE
)
26023 tree scope
= TREE_TYPE (object
);
26024 return (!scope
|| dependent_scope_p (scope
));
26027 /* walk_tree callback function for instantiation_dependent_expression_p,
26028 below. Returns non-zero if a dependent subexpression is found. */
26031 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
26036 /* We don't have to worry about decltype currently because decltype
26037 of an instantiation-dependent expr is a dependent type. This
26038 might change depending on the resolution of DR 1172. */
26039 *walk_subtrees
= false;
26042 enum tree_code code
= TREE_CODE (*tp
);
26045 /* Don't treat an argument list as dependent just because it has no
26049 case NONTYPE_ARGUMENT_PACK
:
26052 case TEMPLATE_PARM_INDEX
:
26053 if (dependent_type_p (TREE_TYPE (*tp
)))
26055 if (TEMPLATE_PARM_PARAMETER_PACK (*tp
))
26057 /* We'll check value-dependence separately. */
26060 /* Handle expressions with type operands. */
26064 case AT_ENCODE_EXPR
:
26066 tree op
= TREE_OPERAND (*tp
, 0);
26067 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
26068 op
= TREE_TYPE (op
);
26071 if (dependent_type_p (op
))
26075 *walk_subtrees
= false;
26082 case COMPONENT_REF
:
26083 if (identifier_p (TREE_OPERAND (*tp
, 1)))
26084 /* In a template, finish_class_member_access_expr creates a
26085 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
26086 type-dependent, so that we can check access control at
26087 instantiation time (PR 42277). See also Core issue 1273. */
26092 if (instantiation_dependent_scope_ref_p (*tp
))
26097 /* Treat statement-expressions as dependent. */
26101 /* Treat requires-expressions as dependent. */
26102 case REQUIRES_EXPR
:
26106 /* Treat calls to function concepts as dependent. */
26107 if (function_concept_check_p (*tp
))
26111 case TEMPLATE_ID_EXPR
:
26112 /* And variable concepts. */
26113 if (variable_concept_p (TREE_OPERAND (*tp
, 0)))
26118 if (CONSTRUCTOR_IS_DEPENDENT (*tp
))
26126 if (type_dependent_expression_p (*tp
))
26132 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
26133 sense defined by the ABI:
26135 "An expression is instantiation-dependent if it is type-dependent
26136 or value-dependent, or it has a subexpression that is type-dependent
26137 or value-dependent."
26139 Except don't actually check value-dependence for unevaluated expressions,
26140 because in sizeof(i) we don't care about the value of i. Checking
26141 type-dependence will in turn check value-dependence of array bounds/template
26142 arguments as needed. */
26145 instantiation_dependent_uneval_expression_p (tree expression
)
26149 if (!processing_template_decl
)
26152 if (expression
== error_mark_node
)
26155 result
= cp_walk_tree_without_duplicates (&expression
,
26156 instantiation_dependent_r
, NULL
);
26157 return result
!= NULL_TREE
;
26160 /* As above, but also check value-dependence of the expression as a whole. */
26163 instantiation_dependent_expression_p (tree expression
)
26165 return (instantiation_dependent_uneval_expression_p (expression
)
26166 || value_dependent_expression_p (expression
));
26169 /* Like type_dependent_expression_p, but it also works while not processing
26170 a template definition, i.e. during substitution or mangling. */
26173 type_dependent_expression_p_push (tree expr
)
26176 ++processing_template_decl
;
26177 b
= type_dependent_expression_p (expr
);
26178 --processing_template_decl
;
26182 /* Returns TRUE if ARGS contains a type-dependent expression. */
26185 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
26190 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
26192 if (type_dependent_expression_p (arg
))
26198 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
26199 expressions) contains any type-dependent expressions. */
26202 any_type_dependent_elements_p (const_tree list
)
26204 for (; list
; list
= TREE_CHAIN (list
))
26205 if (type_dependent_expression_p (TREE_VALUE (list
)))
26211 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
26212 expressions) contains any value-dependent expressions. */
26215 any_value_dependent_elements_p (const_tree list
)
26217 for (; list
; list
= TREE_CHAIN (list
))
26218 if (value_dependent_expression_p (TREE_VALUE (list
)))
26224 /* Returns TRUE if the ARG (a template argument) is dependent. */
26227 dependent_template_arg_p (tree arg
)
26229 if (!processing_template_decl
)
26232 /* Assume a template argument that was wrongly written by the user
26233 is dependent. This is consistent with what
26234 any_dependent_template_arguments_p [that calls this function]
26236 if (!arg
|| arg
== error_mark_node
)
26239 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
26240 arg
= argument_pack_select_arg (arg
);
26242 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
26244 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
26246 if (DECL_TEMPLATE_PARM_P (arg
))
26248 /* A member template of a dependent class is not necessarily
26249 type-dependent, but it is a dependent template argument because it
26250 will be a member of an unknown specialization to that template. */
26251 tree scope
= CP_DECL_CONTEXT (arg
);
26252 return TYPE_P (scope
) && dependent_type_p (scope
);
26254 else if (ARGUMENT_PACK_P (arg
))
26256 tree args
= ARGUMENT_PACK_ARGS (arg
);
26257 int i
, len
= TREE_VEC_LENGTH (args
);
26258 for (i
= 0; i
< len
; ++i
)
26260 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
26266 else if (TYPE_P (arg
))
26267 return dependent_type_p (arg
);
26269 return (type_dependent_expression_p (arg
)
26270 || value_dependent_expression_p (arg
));
26273 /* Returns true if ARGS (a collection of template arguments) contains
26274 any types that require structural equality testing. */
26277 any_template_arguments_need_structural_equality_p (tree args
)
26284 if (args
== error_mark_node
)
26287 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
26289 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
26290 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
26292 tree arg
= TREE_VEC_ELT (level
, j
);
26293 tree packed_args
= NULL_TREE
;
26296 if (ARGUMENT_PACK_P (arg
))
26298 /* Look inside the argument pack. */
26299 packed_args
= ARGUMENT_PACK_ARGS (arg
);
26300 len
= TREE_VEC_LENGTH (packed_args
);
26303 for (k
= 0; k
< len
; ++k
)
26306 arg
= TREE_VEC_ELT (packed_args
, k
);
26308 if (error_operand_p (arg
))
26310 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
26312 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
26314 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
26315 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
26324 /* Returns true if ARGS (a collection of template arguments) contains
26325 any dependent arguments. */
26328 any_dependent_template_arguments_p (const_tree args
)
26335 if (args
== error_mark_node
)
26338 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
26340 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
26341 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
26342 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
26349 /* Returns true if ARGS contains any errors. */
26352 any_erroneous_template_args_p (const_tree args
)
26357 if (args
== error_mark_node
)
26360 if (args
&& TREE_CODE (args
) != TREE_VEC
)
26362 if (tree ti
= get_template_info (args
))
26363 args
= TI_ARGS (ti
);
26371 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
26373 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
26374 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
26375 if (error_operand_p (TREE_VEC_ELT (level
, j
)))
26382 /* Returns TRUE if the template TMPL is type-dependent. */
26385 dependent_template_p (tree tmpl
)
26387 if (TREE_CODE (tmpl
) == OVERLOAD
)
26389 for (lkp_iterator
iter (tmpl
); iter
; ++iter
)
26390 if (dependent_template_p (*iter
))
26395 /* Template template parameters are dependent. */
26396 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
26397 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
26399 /* So are names that have not been looked up. */
26400 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
26405 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
26408 dependent_template_id_p (tree tmpl
, tree args
)
26410 return (dependent_template_p (tmpl
)
26411 || any_dependent_template_arguments_p (args
));
26414 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
26418 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
26422 if (!processing_template_decl
)
26425 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
26427 tree decl
= TREE_VEC_ELT (declv
, i
);
26428 tree init
= TREE_VEC_ELT (initv
, i
);
26429 tree cond
= TREE_VEC_ELT (condv
, i
);
26430 tree incr
= TREE_VEC_ELT (incrv
, i
);
26432 if (type_dependent_expression_p (decl
)
26433 || TREE_CODE (decl
) == SCOPE_REF
)
26436 if (init
&& type_dependent_expression_p (init
))
26439 if (cond
== global_namespace
)
26442 if (type_dependent_expression_p (cond
))
26445 if (COMPARISON_CLASS_P (cond
)
26446 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
26447 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
26450 if (TREE_CODE (incr
) == MODOP_EXPR
)
26452 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
26453 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
26456 else if (type_dependent_expression_p (incr
))
26458 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
26460 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
26462 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
26464 tree t
= TREE_OPERAND (incr
, 1);
26465 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
26466 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
26469 /* If this loop has a class iterator with != comparison
26470 with increment other than i++/++i/i--/--i, make sure the
26471 increment is constant. */
26472 if (CLASS_TYPE_P (TREE_TYPE (decl
))
26473 && TREE_CODE (cond
) == NE_EXPR
)
26475 if (TREE_OPERAND (t
, 0) == decl
)
26476 t
= TREE_OPERAND (t
, 1);
26478 t
= TREE_OPERAND (t
, 0);
26479 if (TREE_CODE (t
) != INTEGER_CST
)
26489 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
26490 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
26491 no such TYPE can be found. Note that this function peers inside
26492 uninstantiated templates and therefore should be used only in
26493 extremely limited situations. ONLY_CURRENT_P restricts this
26494 peering to the currently open classes hierarchy (which is required
26495 when comparing types). */
26498 resolve_typename_type (tree type
, bool only_current_p
)
26507 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
26509 scope
= TYPE_CONTEXT (type
);
26510 /* We shouldn't have built a TYPENAME_TYPE with a non-dependent scope. */
26511 gcc_checking_assert (uses_template_parms (scope
));
26513 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
26514 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
26515 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
26516 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
26517 identifier of the TYPENAME_TYPE anymore.
26518 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
26519 TYPENAME_TYPE instead, we avoid messing up with a possible
26520 typedef variant case. */
26521 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
26523 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
26524 it first before we can figure out what NAME refers to. */
26525 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
26527 if (TYPENAME_IS_RESOLVING_P (scope
))
26528 /* Given a class template A with a dependent base with nested type C,
26529 typedef typename A::C::C C will land us here, as trying to resolve
26530 the initial A::C leads to the local C typedef, which leads back to
26531 A::C::C. So we break the recursion now. */
26534 scope
= resolve_typename_type (scope
, only_current_p
);
26536 /* If we don't know what SCOPE refers to, then we cannot resolve the
26538 if (!CLASS_TYPE_P (scope
))
26540 /* If this is a typedef, we don't want to look inside (c++/11987). */
26541 if (typedef_variant_p (type
))
26543 /* If SCOPE isn't the template itself, it will not have a valid
26544 TYPE_FIELDS list. */
26545 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
26546 /* scope is either the template itself or a compatible instantiation
26547 like X<T>, so look up the name in the original template. */
26548 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
26549 /* If scope has no fields, it can't be a current instantiation. Check this
26550 before currently_open_class to avoid infinite recursion (71515). */
26551 if (!TYPE_FIELDS (scope
))
26553 /* If the SCOPE is not the current instantiation, there's no reason
26554 to look inside it. */
26555 if (only_current_p
&& !currently_open_class (scope
))
26557 /* Enter the SCOPE so that name lookup will be resolved as if we
26558 were in the class definition. In particular, SCOPE will no
26559 longer be considered a dependent type. */
26560 pushed_scope
= push_scope (scope
);
26561 /* Look up the declaration. */
26562 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
26563 tf_warning_or_error
);
26565 result
= NULL_TREE
;
26567 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
26568 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
26569 tree fullname
= TYPENAME_TYPE_FULLNAME (type
);
26572 else if (identifier_p (fullname
)
26573 && TREE_CODE (decl
) == TYPE_DECL
)
26575 result
= TREE_TYPE (decl
);
26576 if (result
== error_mark_node
)
26577 result
= NULL_TREE
;
26579 else if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
26580 && DECL_CLASS_TEMPLATE_P (decl
))
26582 /* Obtain the template and the arguments. */
26583 tree tmpl
= TREE_OPERAND (fullname
, 0);
26584 if (TREE_CODE (tmpl
) == IDENTIFIER_NODE
)
26586 /* We get here with a plain identifier because a previous tentative
26587 parse of the nested-name-specifier as part of a ptr-operator saw
26588 ::template X<A>. The use of ::template is necessary in a
26589 ptr-operator, but wrong in a declarator-id.
26591 [temp.names]: In a qualified-id of a declarator-id, the keyword
26592 template shall not appear at the top level. */
26593 pedwarn (cp_expr_loc_or_loc (fullname
, input_location
), OPT_Wpedantic
,
26594 "keyword %<template%> not allowed in declarator-id");
26597 tree args
= TREE_OPERAND (fullname
, 1);
26598 /* Instantiate the template. */
26599 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
26600 /*entering_scope=*/true,
26601 tf_error
| tf_user
);
26602 if (result
== error_mark_node
)
26603 result
= NULL_TREE
;
26606 /* Leave the SCOPE. */
26608 pop_scope (pushed_scope
);
26610 /* If we failed to resolve it, return the original typename. */
26614 /* If lookup found a typename type, resolve that too. */
26615 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
26617 /* Ill-formed programs can cause infinite recursion here, so we
26618 must catch that. */
26619 TYPENAME_IS_RESOLVING_P (result
) = 1;
26620 result
= resolve_typename_type (result
, only_current_p
);
26621 TYPENAME_IS_RESOLVING_P (result
) = 0;
26624 /* Qualify the resulting type. */
26625 quals
= cp_type_quals (type
);
26627 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
26632 /* EXPR is an expression which is not type-dependent. Return a proxy
26633 for EXPR that can be used to compute the types of larger
26634 expressions containing EXPR. */
26637 build_non_dependent_expr (tree expr
)
26639 tree orig_expr
= expr
;
26642 /* When checking, try to get a constant value for all non-dependent
26643 expressions in order to expose bugs in *_dependent_expression_p
26644 and constexpr. This can affect code generation, see PR70704, so
26645 only do this for -fchecking=2. */
26646 if (flag_checking
> 1
26647 && cxx_dialect
>= cxx11
26648 /* Don't do this during nsdmi parsing as it can lead to
26649 unexpected recursive instantiations. */
26650 && !parsing_nsdmi ()
26651 /* Don't do this during concept expansion either and for
26652 the same reason. */
26653 && !expanding_concept ())
26654 fold_non_dependent_expr (expr
, tf_none
);
26656 STRIP_ANY_LOCATION_WRAPPER (expr
);
26658 /* Preserve OVERLOADs; the functions must be available to resolve
26661 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
26662 inner_expr
= stmt_expr_value_expr (inner_expr
);
26663 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
26664 inner_expr
= TREE_OPERAND (inner_expr
, 0);
26665 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
26666 inner_expr
= TREE_OPERAND (inner_expr
, 1);
26667 if (is_overloaded_fn (inner_expr
)
26668 || TREE_CODE (inner_expr
) == OFFSET_REF
)
26670 /* There is no need to return a proxy for a variable or enumerator. */
26671 if (VAR_P (expr
) || TREE_CODE (expr
) == CONST_DECL
)
26673 /* Preserve string constants; conversions from string constants to
26674 "char *" are allowed, even though normally a "const char *"
26675 cannot be used to initialize a "char *". */
26676 if (TREE_CODE (expr
) == STRING_CST
)
26678 /* Preserve void and arithmetic constants, as an optimization -- there is no
26679 reason to create a new node. */
26680 if (TREE_CODE (expr
) == VOID_CST
26681 || TREE_CODE (expr
) == INTEGER_CST
26682 || TREE_CODE (expr
) == REAL_CST
)
26684 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
26685 There is at least one place where we want to know that a
26686 particular expression is a throw-expression: when checking a ?:
26687 expression, there are special rules if the second or third
26688 argument is a throw-expression. */
26689 if (TREE_CODE (expr
) == THROW_EXPR
)
26692 /* Don't wrap an initializer list, we need to be able to look inside. */
26693 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
26696 /* Don't wrap a dummy object, we need to be able to test for it. */
26697 if (is_dummy_object (expr
))
26700 if (TREE_CODE (expr
) == COND_EXPR
)
26701 return build3 (COND_EXPR
,
26703 TREE_OPERAND (expr
, 0),
26704 (TREE_OPERAND (expr
, 1)
26705 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
26706 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
26707 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
26708 if (TREE_CODE (expr
) == COMPOUND_EXPR
26709 && !COMPOUND_EXPR_OVERLOADED (expr
))
26710 return build2 (COMPOUND_EXPR
,
26712 TREE_OPERAND (expr
, 0),
26713 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
26715 /* If the type is unknown, it can't really be non-dependent */
26716 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
26718 /* Otherwise, build a NON_DEPENDENT_EXPR. */
26719 return build1_loc (EXPR_LOCATION (orig_expr
), NON_DEPENDENT_EXPR
,
26720 TREE_TYPE (expr
), expr
);
26723 /* ARGS is a vector of expressions as arguments to a function call.
26724 Replace the arguments with equivalent non-dependent expressions.
26725 This modifies ARGS in place. */
26728 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
26733 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
26735 tree newarg
= build_non_dependent_expr (arg
);
26737 (*args
)[ix
] = newarg
;
26741 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
26742 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
26743 parms. If set_canonical is true, we set TYPE_CANONICAL on it. */
26746 make_auto_1 (tree name
, bool set_canonical
)
26748 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
26749 TYPE_NAME (au
) = build_decl (input_location
,
26750 TYPE_DECL
, name
, au
);
26751 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
26752 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
26753 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
26754 TYPE_NAME (au
), NULL_TREE
);
26756 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
26757 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
26758 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
26764 make_decltype_auto (void)
26766 return make_auto_1 (decltype_auto_identifier
, true);
26772 return make_auto_1 (auto_identifier
, true);
26775 /* Return a C++17 deduction placeholder for class template TMPL. */
26778 make_template_placeholder (tree tmpl
)
26780 tree t
= make_auto_1 (auto_identifier
, false);
26781 CLASS_PLACEHOLDER_TEMPLATE (t
) = tmpl
;
26782 /* Our canonical type depends on the placeholder. */
26783 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
26787 /* True iff T is a C++17 class template deduction placeholder. */
26790 template_placeholder_p (tree t
)
26792 return is_auto (t
) && CLASS_PLACEHOLDER_TEMPLATE (t
);
26795 /* Make a "constrained auto" type-specifier. This is an
26796 auto type with constraints that must be associated after
26797 deduction. The constraint is formed from the given
26798 CONC and its optional sequence of arguments, which are
26799 non-null if written as partial-concept-id. */
26802 make_constrained_auto (tree con
, tree args
)
26804 tree type
= make_auto_1 (auto_identifier
, false);
26806 /* Build the constraint. */
26807 tree tmpl
= DECL_TI_TEMPLATE (con
);
26808 tree expr
= VAR_P (con
) ? tmpl
: ovl_make (tmpl
);
26809 expr
= build_concept_check (expr
, type
, args
);
26811 tree constr
= normalize_expression (expr
);
26812 PLACEHOLDER_TYPE_CONSTRAINTS (type
) = constr
;
26814 /* Our canonical type depends on the constraint. */
26815 TYPE_CANONICAL (type
) = canonical_type_parameter (type
);
26817 /* Attach the constraint to the type declaration. */
26818 tree decl
= TYPE_NAME (type
);
26822 /* Given type ARG, return std::initializer_list<ARG>. */
26827 tree std_init_list
= get_namespace_binding (std_node
, init_list_identifier
);
26829 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
26831 gcc_rich_location
richloc (input_location
);
26832 maybe_add_include_fixit (&richloc
, "<initializer_list>", false);
26833 error_at (&richloc
,
26834 "deducing from brace-enclosed initializer list"
26835 " requires %<#include <initializer_list>%>");
26837 return error_mark_node
;
26839 tree argvec
= make_tree_vec (1);
26840 TREE_VEC_ELT (argvec
, 0) = arg
;
26842 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
26843 NULL_TREE
, 0, tf_warning_or_error
);
26846 /* Replace auto in TYPE with std::initializer_list<auto>. */
26849 listify_autos (tree type
, tree auto_node
)
26851 tree init_auto
= listify (strip_top_quals (auto_node
));
26852 tree argvec
= make_tree_vec (1);
26853 TREE_VEC_ELT (argvec
, 0) = init_auto
;
26854 if (processing_template_decl
)
26855 argvec
= add_to_template_args (current_template_args (), argvec
);
26856 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
26859 /* Hash traits for hashing possibly constrained 'auto'
26860 TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
26862 struct auto_hash
: default_hash_traits
<tree
>
26864 static inline hashval_t
hash (tree
);
26865 static inline bool equal (tree
, tree
);
26868 /* Hash the 'auto' T. */
26871 auto_hash::hash (tree t
)
26873 if (tree c
= NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS (t
)))
26874 /* Matching constrained-type-specifiers denote the same template
26875 parameter, so hash the constraint. */
26876 return hash_placeholder_constraint (c
);
26878 /* But unconstrained autos are all separate, so just hash the pointer. */
26879 return iterative_hash_object (t
, 0);
26882 /* Compare two 'auto's. */
26885 auto_hash::equal (tree t1
, tree t2
)
26890 tree c1
= PLACEHOLDER_TYPE_CONSTRAINTS (t1
);
26891 tree c2
= PLACEHOLDER_TYPE_CONSTRAINTS (t2
);
26893 /* Two unconstrained autos are distinct. */
26897 return equivalent_placeholder_constraints (c1
, c2
);
26900 /* for_each_template_parm callback for extract_autos: if t is a (possibly
26901 constrained) auto, add it to the vector. */
26904 extract_autos_r (tree t
, void *data
)
26906 hash_table
<auto_hash
> &hash
= *(hash_table
<auto_hash
>*)data
;
26909 /* All the autos were built with index 0; fix that up now. */
26910 tree
*p
= hash
.find_slot (t
, INSERT
);
26913 /* If this is a repeated constrained-type-specifier, use the index we
26915 idx
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (*p
));
26918 /* Otherwise this is new, so use the current count. */
26920 idx
= hash
.elements () - 1;
26922 TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (t
)) = idx
;
26925 /* Always keep walking. */
26929 /* Return a TREE_VEC of the 'auto's used in type under the Concepts TS, which
26930 says they can appear anywhere in the type. */
26933 extract_autos (tree type
)
26935 hash_set
<tree
> visited
;
26936 hash_table
<auto_hash
> hash (2);
26938 for_each_template_parm (type
, extract_autos_r
, &hash
, &visited
, true);
26940 tree tree_vec
= make_tree_vec (hash
.elements());
26941 for (hash_table
<auto_hash
>::iterator iter
= hash
.begin();
26942 iter
!= hash
.end(); ++iter
)
26945 unsigned i
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (elt
));
26946 TREE_VEC_ELT (tree_vec
, i
)
26947 = build_tree_list (NULL_TREE
, TYPE_NAME (elt
));
26953 /* The stem for deduction guide names. */
26954 const char *const dguide_base
= "__dguide_";
26956 /* Return the name for a deduction guide for class template TMPL. */
26959 dguide_name (tree tmpl
)
26961 tree type
= (TYPE_P (tmpl
) ? tmpl
: TREE_TYPE (tmpl
));
26962 tree tname
= TYPE_IDENTIFIER (type
);
26963 char *buf
= (char *) alloca (1 + strlen (dguide_base
)
26964 + IDENTIFIER_LENGTH (tname
));
26965 memcpy (buf
, dguide_base
, strlen (dguide_base
));
26966 memcpy (buf
+ strlen (dguide_base
), IDENTIFIER_POINTER (tname
),
26967 IDENTIFIER_LENGTH (tname
) + 1);
26968 tree dname
= get_identifier (buf
);
26969 TREE_TYPE (dname
) = type
;
26973 /* True if NAME is the name of a deduction guide. */
26976 dguide_name_p (tree name
)
26978 return (TREE_CODE (name
) == IDENTIFIER_NODE
26979 && TREE_TYPE (name
)
26980 && !strncmp (IDENTIFIER_POINTER (name
), dguide_base
,
26981 strlen (dguide_base
)));
26984 /* True if FN is a deduction guide. */
26987 deduction_guide_p (const_tree fn
)
26990 if (tree name
= DECL_NAME (fn
))
26991 return dguide_name_p (name
);
26995 /* True if FN is the copy deduction guide, i.e. A(A)->A. */
26998 copy_guide_p (const_tree fn
)
27000 gcc_assert (deduction_guide_p (fn
));
27001 if (!DECL_ARTIFICIAL (fn
))
27003 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (DECL_TI_TEMPLATE (fn
));
27004 return (TREE_CHAIN (parms
) == void_list_node
27005 && same_type_p (TREE_VALUE (parms
), TREE_TYPE (DECL_NAME (fn
))));
27008 /* True if FN is a guide generated from a constructor template. */
27011 template_guide_p (const_tree fn
)
27013 gcc_assert (deduction_guide_p (fn
));
27014 if (!DECL_ARTIFICIAL (fn
))
27016 tree tmpl
= DECL_TI_TEMPLATE (fn
);
27017 if (tree org
= DECL_ABSTRACT_ORIGIN (tmpl
))
27018 return PRIMARY_TEMPLATE_P (org
);
27022 /* OLDDECL is a _DECL for a template parameter. Return a similar parameter at
27023 LEVEL:INDEX, using tsubst_args and complain for substitution into non-type
27024 template parameter types. Note that the handling of template template
27025 parameters relies on current_template_parms being set appropriately for the
27029 rewrite_template_parm (tree olddecl
, unsigned index
, unsigned level
,
27030 tree tsubst_args
, tsubst_flags_t complain
)
27032 if (olddecl
== error_mark_node
)
27033 return error_mark_node
;
27035 tree oldidx
= get_template_parm_index (olddecl
);
27038 if (TREE_CODE (olddecl
) == TYPE_DECL
27039 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
27041 tree oldtype
= TREE_TYPE (olddecl
);
27042 newtype
= cxx_make_type (TREE_CODE (oldtype
));
27043 TYPE_MAIN_VARIANT (newtype
) = newtype
;
27044 if (TREE_CODE (oldtype
) == TEMPLATE_TYPE_PARM
)
27045 TEMPLATE_TYPE_PARM_FOR_CLASS (newtype
)
27046 = TEMPLATE_TYPE_PARM_FOR_CLASS (oldtype
);
27050 newtype
= TREE_TYPE (olddecl
);
27051 if (type_uses_auto (newtype
))
27053 // Substitute once to fix references to other template parameters.
27054 newtype
= tsubst (newtype
, tsubst_args
,
27055 complain
|tf_partial
, NULL_TREE
);
27056 // Now substitute again to reduce the level of the auto.
27057 newtype
= tsubst (newtype
, current_template_args (),
27058 complain
, NULL_TREE
);
27061 newtype
= tsubst (newtype
, tsubst_args
,
27062 complain
, NULL_TREE
);
27066 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TREE_CODE (olddecl
),
27067 DECL_NAME (olddecl
), newtype
);
27068 SET_DECL_TEMPLATE_PARM_P (newdecl
);
27071 if (TREE_CODE (olddecl
) == TYPE_DECL
27072 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
27074 newidx
= TEMPLATE_TYPE_PARM_INDEX (newtype
)
27075 = build_template_parm_index (index
, level
, level
,
27077 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
27078 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
27079 TYPE_STUB_DECL (newtype
) = TYPE_NAME (newtype
) = newdecl
;
27080 TYPE_CANONICAL (newtype
) = canonical_type_parameter (newtype
);
27082 if (TREE_CODE (olddecl
) == TEMPLATE_DECL
)
27084 DECL_TEMPLATE_RESULT (newdecl
)
27085 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TYPE_DECL
,
27086 DECL_NAME (olddecl
), newtype
);
27087 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (newdecl
)) = true;
27088 // First create a copy (ttargs) of tsubst_args with an
27089 // additional level for the template template parameter's own
27090 // template parameters (ttparms).
27091 tree ttparms
= (INNERMOST_TEMPLATE_PARMS
27092 (DECL_TEMPLATE_PARMS (olddecl
)));
27093 const int depth
= TMPL_ARGS_DEPTH (tsubst_args
);
27094 tree ttargs
= make_tree_vec (depth
+ 1);
27095 for (int i
= 0; i
< depth
; ++i
)
27096 TREE_VEC_ELT (ttargs
, i
) = TREE_VEC_ELT (tsubst_args
, i
);
27097 TREE_VEC_ELT (ttargs
, depth
)
27098 = template_parms_level_to_args (ttparms
);
27099 // Substitute ttargs into ttparms to fix references to
27100 // other template parameters.
27101 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
27102 complain
|tf_partial
);
27103 // Now substitute again with args based on tparms, to reduce
27104 // the level of the ttparms.
27105 ttargs
= current_template_args ();
27106 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
27108 // Finally, tack the adjusted parms onto tparms.
27109 ttparms
= tree_cons (size_int (depth
), ttparms
,
27110 current_template_parms
);
27111 DECL_TEMPLATE_PARMS (newdecl
) = ttparms
;
27116 tree oldconst
= TEMPLATE_PARM_DECL (oldidx
);
27118 = build_decl (DECL_SOURCE_LOCATION (oldconst
),
27119 TREE_CODE (oldconst
),
27120 DECL_NAME (oldconst
), newtype
);
27121 TREE_CONSTANT (newconst
) = TREE_CONSTANT (newdecl
)
27122 = TREE_READONLY (newconst
) = TREE_READONLY (newdecl
) = true;
27123 SET_DECL_TEMPLATE_PARM_P (newconst
);
27124 newidx
= build_template_parm_index (index
, level
, level
,
27125 newconst
, newtype
);
27126 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
27127 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
27128 DECL_INITIAL (newdecl
) = DECL_INITIAL (newconst
) = newidx
;
27134 /* Returns a C++17 class deduction guide template based on the constructor
27135 CTOR. As a special case, CTOR can be a RECORD_TYPE for an implicit default
27136 guide, or REFERENCE_TYPE for an implicit copy/move guide. */
27139 build_deduction_guide (tree ctor
, tree outer_args
, tsubst_flags_t complain
)
27141 tree type
, tparms
, targs
, fparms
, fargs
, ci
;
27142 bool memtmpl
= false;
27145 tree fn_tmpl
= NULL_TREE
;
27150 bool copy_p
= TYPE_REF_P (type
);
27153 type
= TREE_TYPE (type
);
27154 fparms
= tree_cons (NULL_TREE
, type
, void_list_node
);
27157 fparms
= void_list_node
;
27159 tree ctmpl
= CLASSTYPE_TI_TEMPLATE (type
);
27160 tparms
= DECL_TEMPLATE_PARMS (ctmpl
);
27161 targs
= CLASSTYPE_TI_ARGS (type
);
27164 loc
= DECL_SOURCE_LOCATION (ctmpl
);
27165 explicit_p
= false;
27169 ++processing_template_decl
;
27173 = (TREE_CODE (ctor
) == TEMPLATE_DECL
? ctor
27174 : DECL_TI_TEMPLATE (ctor
));
27176 fn_tmpl
= tsubst (fn_tmpl
, outer_args
, complain
, ctor
);
27177 ctor
= DECL_TEMPLATE_RESULT (fn_tmpl
);
27179 type
= DECL_CONTEXT (ctor
);
27181 tparms
= DECL_TEMPLATE_PARMS (fn_tmpl
);
27182 /* If type is a member class template, DECL_TI_ARGS (ctor) will have
27183 fully specialized args for the enclosing class. Strip those off, as
27184 the deduction guide won't have those template parameters. */
27185 targs
= get_innermost_template_args (DECL_TI_ARGS (ctor
),
27186 TMPL_PARMS_DEPTH (tparms
));
27187 /* Discard the 'this' parameter. */
27188 fparms
= FUNCTION_ARG_CHAIN (ctor
);
27189 fargs
= TREE_CHAIN (DECL_ARGUMENTS (ctor
));
27190 ci
= get_constraints (ctor
);
27191 loc
= DECL_SOURCE_LOCATION (ctor
);
27192 explicit_p
= DECL_NONCONVERTING_P (ctor
);
27194 if (PRIMARY_TEMPLATE_P (fn_tmpl
))
27198 /* For a member template constructor, we need to flatten the two
27199 template parameter lists into one, and then adjust the function
27200 signature accordingly. This gets...complicated. */
27201 tree save_parms
= current_template_parms
;
27203 /* For a member template we should have two levels of parms/args, one
27204 for the class and one for the constructor. We stripped
27205 specialized args for further enclosing classes above. */
27206 const int depth
= 2;
27207 gcc_assert (TMPL_ARGS_DEPTH (targs
) == depth
);
27209 /* Template args for translating references to the two-level template
27210 parameters into references to the one-level template parameters we
27212 tree tsubst_args
= copy_node (targs
);
27213 TMPL_ARGS_LEVEL (tsubst_args
, depth
)
27214 = copy_node (TMPL_ARGS_LEVEL (tsubst_args
, depth
));
27216 /* Template parms for the constructor template. */
27217 tree ftparms
= TREE_VALUE (tparms
);
27218 unsigned flen
= TREE_VEC_LENGTH (ftparms
);
27219 /* Template parms for the class template. */
27220 tparms
= TREE_CHAIN (tparms
);
27221 tree ctparms
= TREE_VALUE (tparms
);
27222 unsigned clen
= TREE_VEC_LENGTH (ctparms
);
27223 /* Template parms for the deduction guide start as a copy of the
27224 template parms for the class. We set current_template_parms for
27225 lookup_template_class_1. */
27226 current_template_parms
= tparms
= copy_node (tparms
);
27227 tree new_vec
= TREE_VALUE (tparms
) = make_tree_vec (flen
+ clen
);
27228 for (unsigned i
= 0; i
< clen
; ++i
)
27229 TREE_VEC_ELT (new_vec
, i
) = TREE_VEC_ELT (ctparms
, i
);
27231 /* Now we need to rewrite the constructor parms to append them to the
27233 for (unsigned i
= 0; i
< flen
; ++i
)
27235 unsigned index
= i
+ clen
;
27236 unsigned level
= 1;
27237 tree oldelt
= TREE_VEC_ELT (ftparms
, i
);
27238 tree olddecl
= TREE_VALUE (oldelt
);
27239 tree newdecl
= rewrite_template_parm (olddecl
, index
, level
,
27240 tsubst_args
, complain
);
27241 if (newdecl
== error_mark_node
)
27243 tree newdef
= tsubst_template_arg (TREE_PURPOSE (oldelt
),
27244 tsubst_args
, complain
, ctor
);
27245 tree list
= build_tree_list (newdef
, newdecl
);
27246 TEMPLATE_PARM_CONSTRAINTS (list
)
27247 = tsubst_constraint_info (TEMPLATE_PARM_CONSTRAINTS (oldelt
),
27248 tsubst_args
, complain
, ctor
);
27249 TREE_VEC_ELT (new_vec
, index
) = list
;
27250 TMPL_ARG (tsubst_args
, depth
, i
) = template_parm_to_arg (list
);
27253 /* Now we have a final set of template parms to substitute into the
27254 function signature. */
27255 targs
= template_parms_to_args (tparms
);
27256 fparms
= tsubst_arg_types (fparms
, tsubst_args
, NULL_TREE
,
27258 if (fparms
== error_mark_node
)
27260 fargs
= tsubst (fargs
, tsubst_args
, complain
, ctor
);
27262 ci
= tsubst_constraint_info (ci
, tsubst_args
, complain
, ctor
);
27264 current_template_parms
= save_parms
;
27267 --processing_template_decl
;
27269 return error_mark_node
;
27274 /* Copy the parms so we can set DECL_PRIMARY_TEMPLATE. */
27275 tparms
= copy_node (tparms
);
27276 INNERMOST_TEMPLATE_PARMS (tparms
)
27277 = copy_node (INNERMOST_TEMPLATE_PARMS (tparms
));
27280 tree fntype
= build_function_type (type
, fparms
);
27281 tree ded_fn
= build_lang_decl_loc (loc
,
27283 dguide_name (type
), fntype
);
27284 DECL_ARGUMENTS (ded_fn
) = fargs
;
27285 DECL_ARTIFICIAL (ded_fn
) = true;
27286 DECL_NONCONVERTING_P (ded_fn
) = explicit_p
;
27287 tree ded_tmpl
= build_template_decl (ded_fn
, tparms
, /*member*/false);
27288 DECL_ARTIFICIAL (ded_tmpl
) = true;
27289 DECL_TEMPLATE_RESULT (ded_tmpl
) = ded_fn
;
27290 TREE_TYPE (ded_tmpl
) = TREE_TYPE (ded_fn
);
27291 DECL_TEMPLATE_INFO (ded_fn
) = build_template_info (ded_tmpl
, targs
);
27292 DECL_PRIMARY_TEMPLATE (ded_tmpl
) = ded_tmpl
;
27294 DECL_ABSTRACT_ORIGIN (ded_tmpl
) = fn_tmpl
;
27296 set_constraints (ded_tmpl
, ci
);
27301 /* Deduce template arguments for the class template placeholder PTYPE for
27302 template TMPL based on the initializer INIT, and return the resulting
27306 do_class_deduction (tree ptype
, tree tmpl
, tree init
, int flags
,
27307 tsubst_flags_t complain
)
27309 if (!DECL_CLASS_TEMPLATE_P (tmpl
))
27311 /* We should have handled this in the caller. */
27312 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
))
27314 if (complain
& tf_error
)
27315 error ("non-class template %qT used without template arguments", tmpl
);
27316 return error_mark_node
;
27318 if (init
&& TREE_TYPE (init
) == ptype
)
27319 /* Using the template parm as its own argument. */
27322 tree type
= TREE_TYPE (tmpl
);
27324 bool try_list_ctor
= false;
27326 releasing_vec rv_args
= NULL
;
27327 vec
<tree
,va_gc
> *&args
= *&rv_args
;
27328 if (init
== NULL_TREE
27329 || TREE_CODE (init
) == TREE_LIST
)
27330 args
= make_tree_vector_from_list (init
);
27331 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
27333 try_list_ctor
= TYPE_HAS_LIST_CTOR (type
);
27334 if (try_list_ctor
&& CONSTRUCTOR_NELTS (init
) == 1)
27336 /* As an exception, the first phase in 16.3.1.7 (considering the
27337 initializer list as a single argument) is omitted if the
27338 initializer list consists of a single expression of type cv U,
27339 where U is a specialization of C or a class derived from a
27340 specialization of C. */
27341 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
27342 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
27344 tree etype
= TREE_TYPE (elt
);
27345 tree tparms
= (INNERMOST_TEMPLATE_PARMS
27346 (DECL_TEMPLATE_PARMS (tmpl
)));
27347 tree targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
27348 int err
= unify (tparms
, targs
, type
, etype
,
27349 UNIFY_ALLOW_DERIVED
, /*explain*/false);
27351 try_list_ctor
= false;
27355 if (try_list_ctor
|| is_std_init_list (type
))
27356 args
= make_tree_vector_single (init
);
27358 args
= make_tree_vector_from_ctor (init
);
27361 args
= make_tree_vector_single (init
);
27363 tree dname
= dguide_name (tmpl
);
27364 tree cands
= lookup_qualified_name (CP_DECL_CONTEXT (tmpl
), dname
,
27365 /*type*/false, /*complain*/false,
27367 bool elided
= false;
27368 if (cands
== error_mark_node
)
27371 /* Prune explicit deduction guides in copy-initialization context. */
27372 if (flags
& LOOKUP_ONLYCONVERTING
)
27374 for (lkp_iterator
iter (cands
); !elided
&& iter
; ++iter
)
27375 if (DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
27380 /* Found a nonconverting guide, prune the candidates. */
27381 tree pruned
= NULL_TREE
;
27382 for (lkp_iterator
iter (cands
); iter
; ++iter
)
27383 if (!DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
27384 pruned
= lookup_add (*iter
, pruned
);
27390 tree outer_args
= NULL_TREE
;
27391 if (DECL_CLASS_SCOPE_P (tmpl
)
27392 && CLASSTYPE_TEMPLATE_INSTANTIATION (DECL_CONTEXT (tmpl
)))
27394 outer_args
= CLASSTYPE_TI_ARGS (DECL_CONTEXT (tmpl
));
27395 type
= TREE_TYPE (most_general_template (tmpl
));
27398 bool saw_ctor
= false;
27399 // FIXME cache artificial deduction guides
27400 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (type
)); iter
; ++iter
)
27402 /* Skip inherited constructors. */
27403 if (iter
.using_p ())
27406 tree guide
= build_deduction_guide (*iter
, outer_args
, complain
);
27407 if (guide
== error_mark_node
)
27408 return error_mark_node
;
27409 if ((flags
& LOOKUP_ONLYCONVERTING
)
27410 && DECL_NONCONVERTING_P (STRIP_TEMPLATE (guide
)))
27413 cands
= lookup_add (guide
, cands
);
27418 tree call
= error_mark_node
;
27420 /* If this is list-initialization and the class has a list constructor, first
27421 try deducing from the list as a single argument, as [over.match.list]. */
27422 tree list_cands
= NULL_TREE
;
27423 if (try_list_ctor
&& cands
)
27424 for (lkp_iterator
iter (cands
); iter
; ++iter
)
27427 if (is_list_ctor (dg
))
27428 list_cands
= lookup_add (dg
, list_cands
);
27432 ++cp_unevaluated_operand
;
27433 call
= build_new_function_call (list_cands
, &args
, tf_decltype
);
27434 --cp_unevaluated_operand
;
27436 if (call
== error_mark_node
)
27438 /* That didn't work, now try treating the list as a sequence of
27440 release_tree_vector (args
);
27441 args
= make_tree_vector_from_ctor (init
);
27445 /* Maybe generate an implicit deduction guide. */
27446 if (call
== error_mark_node
&& args
->length () < 2)
27448 tree gtype
= NULL_TREE
;
27450 if (args
->length () == 1)
27451 /* Generate a copy guide. */
27452 gtype
= build_reference_type (type
);
27453 else if (!saw_ctor
)
27454 /* Generate a default guide. */
27459 tree guide
= build_deduction_guide (gtype
, outer_args
, complain
);
27460 if (guide
== error_mark_node
)
27461 return error_mark_node
;
27462 cands
= lookup_add (guide
, cands
);
27466 if (elided
&& !cands
)
27468 error ("cannot deduce template arguments for copy-initialization"
27469 " of %qT, as it has no non-explicit deduction guides or "
27470 "user-declared constructors", type
);
27471 return error_mark_node
;
27473 else if (!cands
&& call
== error_mark_node
)
27475 error ("cannot deduce template arguments of %qT, as it has no viable "
27476 "deduction guides", type
);
27477 return error_mark_node
;
27480 if (call
== error_mark_node
)
27482 ++cp_unevaluated_operand
;
27483 call
= build_new_function_call (cands
, &args
, tf_decltype
);
27484 --cp_unevaluated_operand
;
27487 if (call
== error_mark_node
&& (complain
& tf_warning_or_error
))
27489 error ("class template argument deduction failed:");
27491 ++cp_unevaluated_operand
;
27492 call
= build_new_function_call (cands
, &args
, complain
| tf_decltype
);
27493 --cp_unevaluated_operand
;
27496 inform (input_location
, "explicit deduction guides not considered "
27497 "for copy-initialization");
27500 return cp_build_qualified_type (TREE_TYPE (call
), cp_type_quals (ptype
));
27503 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
27504 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
27505 The CONTEXT determines the context in which auto deduction is performed
27506 and is used to control error diagnostics. FLAGS are the LOOKUP_* flags.
27507 OUTER_TARGS are used during template argument deduction
27508 (context == adc_unify) to properly substitute the result, and is ignored
27511 For partial-concept-ids, extra args may be appended to the list of deduced
27512 template arguments prior to determining constraint satisfaction. */
27515 do_auto_deduction (tree type
, tree init
, tree auto_node
,
27516 tsubst_flags_t complain
, auto_deduction_context context
,
27517 tree outer_targs
, int flags
)
27521 if (init
== error_mark_node
)
27522 return error_mark_node
;
27524 if (init
&& type_dependent_expression_p (init
)
27525 && context
!= adc_unify
)
27526 /* Defining a subset of type-dependent expressions that we can deduce
27527 from ahead of time isn't worth the trouble. */
27530 /* Similarly, we can't deduce from another undeduced decl. */
27531 if (init
&& undeduced_auto_decl (init
))
27534 /* We may be doing a partial substitution, but we still want to replace
27536 complain
&= ~tf_partial
;
27538 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
27539 /* C++17 class template argument deduction. */
27540 return do_class_deduction (type
, tmpl
, init
, flags
, complain
);
27542 if (init
== NULL_TREE
|| TREE_TYPE (init
) == NULL_TREE
)
27543 /* Nothing we can do with this, even in deduction context. */
27546 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
27547 with either a new invented type template parameter U or, if the
27548 initializer is a braced-init-list (8.5.4), with
27549 std::initializer_list<U>. */
27550 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
27552 if (!DIRECT_LIST_INIT_P (init
))
27553 type
= listify_autos (type
, auto_node
);
27554 else if (CONSTRUCTOR_NELTS (init
) == 1)
27555 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
27558 if (complain
& tf_warning_or_error
)
27560 if (permerror (input_location
, "direct-list-initialization of "
27561 "%<auto%> requires exactly one element"))
27562 inform (input_location
,
27563 "for deduction to %<std::initializer_list%>, use copy-"
27564 "list-initialization (i.e. add %<=%> before the %<{%>)");
27566 type
= listify_autos (type
, auto_node
);
27570 if (type
== error_mark_node
)
27571 return error_mark_node
;
27573 init
= resolve_nondeduced_context (init
, complain
);
27575 if (context
== adc_decomp_type
27576 && auto_node
== type
27577 && init
!= error_mark_node
27578 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
27579 /* [dcl.decomp]/1 - if decomposition declaration has no ref-qualifiers
27580 and initializer has array type, deduce cv-qualified array type. */
27581 return cp_build_qualified_type_real (TREE_TYPE (init
), TYPE_QUALS (type
),
27583 else if (AUTO_IS_DECLTYPE (auto_node
))
27585 tree stripped_init
= tree_strip_any_location_wrapper (init
);
27586 bool id
= (DECL_P (stripped_init
)
27587 || ((TREE_CODE (init
) == COMPONENT_REF
27588 || TREE_CODE (init
) == SCOPE_REF
)
27589 && !REF_PARENTHESIZED_P (init
)));
27590 targs
= make_tree_vec (1);
27591 TREE_VEC_ELT (targs
, 0)
27592 = finish_decltype_type (init
, id
, tf_warning_or_error
);
27593 if (type
!= auto_node
)
27595 if (complain
& tf_error
)
27596 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
27597 return error_mark_node
;
27602 tree parms
= build_tree_list (NULL_TREE
, type
);
27606 tparms
= extract_autos (type
);
27609 tparms
= make_tree_vec (1);
27610 TREE_VEC_ELT (tparms
, 0)
27611 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
27614 targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
27615 int val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
27617 NULL
, /*explain_p=*/false);
27620 if (processing_template_decl
)
27621 /* Try again at instantiation time. */
27623 if (type
&& type
!= error_mark_node
27624 && (complain
& tf_error
))
27625 /* If type is error_mark_node a diagnostic must have been
27626 emitted by now. Also, having a mention to '<type error>'
27627 in the diagnostic is not really useful to the user. */
27630 && FNDECL_USED_AUTO (current_function_decl
)
27632 == DECL_SAVED_AUTO_RETURN_TYPE (current_function_decl
))
27633 && LAMBDA_FUNCTION_P (current_function_decl
))
27634 error ("unable to deduce lambda return type from %qE", init
);
27636 error ("unable to deduce %qT from %qE", type
, init
);
27637 type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
27639 NULL
, /*explain_p=*/true);
27641 return error_mark_node
;
27645 /* Check any placeholder constraints against the deduced type. */
27646 if (flag_concepts
&& !processing_template_decl
)
27647 if (tree constr
= NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS (auto_node
)))
27649 /* Use the deduced type to check the associated constraints. If we
27650 have a partial-concept-id, rebuild the argument list so that
27651 we check using the extra arguments. */
27652 gcc_assert (TREE_CODE (constr
) == CHECK_CONSTR
);
27653 tree cargs
= CHECK_CONSTR_ARGS (constr
);
27654 if (TREE_VEC_LENGTH (cargs
) > 1)
27656 cargs
= copy_node (cargs
);
27657 TREE_VEC_ELT (cargs
, 0) = TREE_VEC_ELT (targs
, 0);
27661 if (!constraints_satisfied_p (constr
, cargs
))
27663 if (complain
& tf_warning_or_error
)
27665 auto_diagnostic_group d
;
27668 case adc_unspecified
:
27670 error("placeholder constraints not satisfied");
27672 case adc_variable_type
:
27673 case adc_decomp_type
:
27674 error ("deduced initializer does not satisfy "
27675 "placeholder constraints");
27677 case adc_return_type
:
27678 error ("deduced return type does not satisfy "
27679 "placeholder constraints");
27681 case adc_requirement
:
27682 error ("deduced expression type does not satisfy "
27683 "placeholder constraints");
27686 diagnose_constraints (input_location
, constr
, targs
);
27688 return error_mark_node
;
27692 if (processing_template_decl
&& context
!= adc_unify
)
27693 outer_targs
= current_template_args ();
27694 targs
= add_to_template_args (outer_targs
, targs
);
27695 return tsubst (type
, targs
, complain
, NULL_TREE
);
27698 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
27702 splice_late_return_type (tree type
, tree late_return_type
)
27704 if (is_auto (type
))
27706 if (late_return_type
)
27707 return late_return_type
;
27709 tree idx
= get_template_parm_index (type
);
27710 if (TEMPLATE_PARM_LEVEL (idx
) <= processing_template_decl
)
27711 /* In an abbreviated function template we didn't know we were dealing
27712 with a function template when we saw the auto return type, so update
27713 it to have the correct level. */
27714 return make_auto_1 (TYPE_IDENTIFIER (type
), true);
27719 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
27720 'decltype(auto)' or a deduced class template. */
27723 is_auto (const_tree type
)
27725 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
27726 && (TYPE_IDENTIFIER (type
) == auto_identifier
27727 || TYPE_IDENTIFIER (type
) == decltype_auto_identifier
))
27733 /* for_each_template_parm callback for type_uses_auto. */
27736 is_auto_r (tree tp
, void */
*data*/
)
27738 return is_auto (tp
);
27741 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
27742 a use of `auto'. Returns NULL_TREE otherwise. */
27745 type_uses_auto (tree type
)
27747 if (type
== NULL_TREE
)
27749 else if (flag_concepts
)
27751 /* The Concepts TS allows multiple autos in one type-specifier; just
27752 return the first one we find, do_auto_deduction will collect all of
27754 if (uses_template_parms (type
))
27755 return for_each_template_parm (type
, is_auto_r
, /*data*/NULL
,
27756 /*visited*/NULL
, /*nondeduced*/false);
27761 return find_type_usage (type
, is_auto
);
27764 /* Report ill-formed occurrences of auto types in ARGUMENTS. If
27765 concepts are enabled, auto is acceptable in template arguments, but
27766 only when TEMPL identifies a template class. Return TRUE if any
27767 such errors were reported. */
27770 check_auto_in_tmpl_args (tree tmpl
, tree args
)
27772 /* If there were previous errors, nevermind. */
27773 if (!args
|| TREE_CODE (args
) != TREE_VEC
)
27776 /* If TMPL is an identifier, we're parsing and we can't tell yet
27777 whether TMPL is supposed to be a type, a function or a variable.
27778 We'll only be able to tell during template substitution, so we
27779 expect to be called again then. If concepts are enabled and we
27780 know we have a type, we're ok. */
27782 && (identifier_p (tmpl
)
27784 && (DECL_TYPE_TEMPLATE_P (tmpl
)
27785 || DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)))))
27788 /* Quickly search for any occurrences of auto; usually there won't
27789 be any, and then we'll avoid allocating the vector. */
27790 if (!type_uses_auto (args
))
27793 bool errors
= false;
27795 tree vec
= extract_autos (args
);
27796 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); i
++)
27798 tree xauto
= TREE_VALUE (TREE_VEC_ELT (vec
, i
));
27799 error_at (DECL_SOURCE_LOCATION (xauto
),
27800 "invalid use of %qT in template argument", xauto
);
27807 /* For a given template T, return the vector of typedefs referenced
27808 in T for which access check is needed at T instantiation time.
27809 T is either a FUNCTION_DECL or a RECORD_TYPE.
27810 Those typedefs were added to T by the function
27811 append_type_to_template_for_access_check. */
27813 vec
<qualified_typedef_usage_t
, va_gc
> *
27814 get_types_needing_access_check (tree t
)
27817 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
27819 if (!t
|| t
== error_mark_node
)
27822 if (!(ti
= get_template_info (t
)))
27825 if (CLASS_TYPE_P (t
)
27826 || TREE_CODE (t
) == FUNCTION_DECL
)
27828 if (!TI_TEMPLATE (ti
))
27831 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
27837 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
27838 tied to T. That list of typedefs will be access checked at
27839 T instantiation time.
27840 T is either a FUNCTION_DECL or a RECORD_TYPE.
27841 TYPE_DECL is a TYPE_DECL node representing a typedef.
27842 SCOPE is the scope through which TYPE_DECL is accessed.
27843 LOCATION is the location of the usage point of TYPE_DECL.
27845 This function is a subroutine of
27846 append_type_to_template_for_access_check. */
27849 append_type_to_template_for_access_check_1 (tree t
,
27852 location_t location
)
27854 qualified_typedef_usage_t typedef_usage
;
27857 if (!t
|| t
== error_mark_node
)
27860 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
27861 || CLASS_TYPE_P (t
))
27863 && TREE_CODE (type_decl
) == TYPE_DECL
27866 if (!(ti
= get_template_info (t
)))
27869 gcc_assert (TI_TEMPLATE (ti
));
27871 typedef_usage
.typedef_decl
= type_decl
;
27872 typedef_usage
.context
= scope
;
27873 typedef_usage
.locus
= location
;
27875 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
27878 /* Append TYPE_DECL to the template TEMPL.
27879 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
27880 At TEMPL instanciation time, TYPE_DECL will be checked to see
27881 if it can be accessed through SCOPE.
27882 LOCATION is the location of the usage point of TYPE_DECL.
27884 e.g. consider the following code snippet:
27891 template<class U> struct S
27893 C::myint mi; // <-- usage point of the typedef C::myint
27898 At S<char> instantiation time, we need to check the access of C::myint
27899 In other words, we need to check the access of the myint typedef through
27900 the C scope. For that purpose, this function will add the myint typedef
27901 and the scope C through which its being accessed to a list of typedefs
27902 tied to the template S. That list will be walked at template instantiation
27903 time and access check performed on each typedefs it contains.
27904 Note that this particular code snippet should yield an error because
27905 myint is private to C. */
27908 append_type_to_template_for_access_check (tree templ
,
27911 location_t location
)
27913 qualified_typedef_usage_t
*iter
;
27916 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
27918 /* Make sure we don't append the type to the template twice. */
27919 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
27920 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
27923 append_type_to_template_for_access_check_1 (templ
, type_decl
,
27927 /* Convert the generic type parameters in PARM that match the types given in the
27928 range [START_IDX, END_IDX) from the current_template_parms into generic type
27932 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
27934 tree current
= current_template_parms
;
27935 int depth
= TMPL_PARMS_DEPTH (current
);
27936 current
= INNERMOST_TEMPLATE_PARMS (current
);
27937 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
27939 for (int i
= 0; i
< start_idx
; ++i
)
27940 TREE_VEC_ELT (replacement
, i
)
27941 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
27943 for (int i
= start_idx
; i
< end_idx
; ++i
)
27945 /* Create a distinct parameter pack type from the current parm and add it
27946 to the replacement args to tsubst below into the generic function
27949 tree o
= TREE_TYPE (TREE_VALUE
27950 (TREE_VEC_ELT (current
, i
)));
27951 tree t
= copy_type (o
);
27952 TEMPLATE_TYPE_PARM_INDEX (t
)
27953 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
27955 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
27956 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
27957 TYPE_MAIN_VARIANT (t
) = t
;
27958 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
27959 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
27960 TREE_VEC_ELT (replacement
, i
) = t
;
27961 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
27964 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
27965 TREE_VEC_ELT (replacement
, i
)
27966 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
27968 /* If there are more levels then build up the replacement with the outer
27971 replacement
= add_to_template_args (template_parms_to_args
27972 (TREE_CHAIN (current_template_parms
)),
27975 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
27978 /* Entries in the decl_constraint hash table. */
27979 struct GTY((for_user
)) constr_entry
27985 /* Hashing function and equality for constraint entries. */
27986 struct constr_hasher
: ggc_ptr_hash
<constr_entry
>
27988 static hashval_t
hash (constr_entry
*e
)
27990 return (hashval_t
)DECL_UID (e
->decl
);
27993 static bool equal (constr_entry
*e1
, constr_entry
*e2
)
27995 return e1
->decl
== e2
->decl
;
27999 /* A mapping from declarations to constraint information. Note that
28000 both templates and their underlying declarations are mapped to the
28001 same constraint information.
28003 FIXME: This is defined in pt.c because garbage collection
28004 code is not being generated for constraint.cc. */
28006 static GTY (()) hash_table
<constr_hasher
> *decl_constraints
;
28008 /* Returns the template constraints of declaration T. If T is not
28009 constrained, return NULL_TREE. Note that T must be non-null. */
28012 get_constraints (tree t
)
28014 if (!flag_concepts
)
28017 gcc_assert (DECL_P (t
));
28018 if (TREE_CODE (t
) == TEMPLATE_DECL
)
28019 t
= DECL_TEMPLATE_RESULT (t
);
28020 constr_entry elt
= { t
, NULL_TREE
};
28021 constr_entry
* found
= decl_constraints
->find (&elt
);
28028 /* Associate the given constraint information CI with the declaration
28029 T. If T is a template, then the constraints are associated with
28030 its underlying declaration. Don't build associations if CI is
28034 set_constraints (tree t
, tree ci
)
28038 gcc_assert (t
&& flag_concepts
);
28039 if (TREE_CODE (t
) == TEMPLATE_DECL
)
28040 t
= DECL_TEMPLATE_RESULT (t
);
28041 gcc_assert (!get_constraints (t
));
28042 constr_entry elt
= {t
, ci
};
28043 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, INSERT
);
28044 constr_entry
* entry
= ggc_alloc
<constr_entry
> ();
28049 /* Remove the associated constraints of the declaration T. */
28052 remove_constraints (tree t
)
28054 gcc_assert (DECL_P (t
));
28055 if (TREE_CODE (t
) == TEMPLATE_DECL
)
28056 t
= DECL_TEMPLATE_RESULT (t
);
28058 constr_entry elt
= {t
, NULL_TREE
};
28059 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, NO_INSERT
);
28061 decl_constraints
->clear_slot (slot
);
28064 /* Memoized satisfaction results for declarations. This
28065 maps the pair (constraint_info, arguments) to the result computed
28066 by constraints_satisfied_p. */
28068 struct GTY((for_user
)) constraint_sat_entry
28075 /* Hashing function and equality for constraint entries. */
28077 struct constraint_sat_hasher
: ggc_ptr_hash
<constraint_sat_entry
>
28079 static hashval_t
hash (constraint_sat_entry
*e
)
28081 hashval_t val
= iterative_hash_object(e
->ci
, 0);
28082 return iterative_hash_template_arg (e
->args
, val
);
28085 static bool equal (constraint_sat_entry
*e1
, constraint_sat_entry
*e2
)
28087 return e1
->ci
== e2
->ci
&& comp_template_args (e1
->args
, e2
->args
);
28091 /* Memoized satisfaction results for concept checks. */
28093 struct GTY((for_user
)) concept_spec_entry
28100 /* Hashing function and equality for constraint entries. */
28102 struct concept_spec_hasher
: ggc_ptr_hash
<concept_spec_entry
>
28104 static hashval_t
hash (concept_spec_entry
*e
)
28106 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
28109 static bool equal (concept_spec_entry
*e1
, concept_spec_entry
*e2
)
28111 ++comparing_specializations
;
28112 bool eq
= e1
->tmpl
== e2
->tmpl
&& comp_template_args (e1
->args
, e2
->args
);
28113 --comparing_specializations
;
28118 static GTY (()) hash_table
<constraint_sat_hasher
> *constraint_memos
;
28119 static GTY (()) hash_table
<concept_spec_hasher
> *concept_memos
;
28121 /* Search for a memoized satisfaction result. Returns one of the
28122 truth value nodes if previously memoized, or NULL_TREE otherwise. */
28125 lookup_constraint_satisfaction (tree ci
, tree args
)
28127 constraint_sat_entry elt
= { ci
, args
, NULL_TREE
};
28128 constraint_sat_entry
* found
= constraint_memos
->find (&elt
);
28130 return found
->result
;
28135 /* Memoize the result of a satisfication test. Returns the saved result. */
28138 memoize_constraint_satisfaction (tree ci
, tree args
, tree result
)
28140 constraint_sat_entry elt
= {ci
, args
, result
};
28141 constraint_sat_entry
** slot
= constraint_memos
->find_slot (&elt
, INSERT
);
28142 constraint_sat_entry
* entry
= ggc_alloc
<constraint_sat_entry
> ();
28148 /* Search for a memoized satisfaction result for a concept. */
28151 lookup_concept_satisfaction (tree tmpl
, tree args
)
28153 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
28154 concept_spec_entry
* found
= concept_memos
->find (&elt
);
28156 return found
->result
;
28161 /* Memoize the result of a concept check. Returns the saved result. */
28164 memoize_concept_satisfaction (tree tmpl
, tree args
, tree result
)
28166 concept_spec_entry elt
= {tmpl
, args
, result
};
28167 concept_spec_entry
** slot
= concept_memos
->find_slot (&elt
, INSERT
);
28168 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
28174 static GTY (()) hash_table
<concept_spec_hasher
> *concept_expansions
;
28176 /* Returns a prior concept specialization. This returns the substituted
28177 and normalized constraints defined by the concept. */
28180 get_concept_expansion (tree tmpl
, tree args
)
28182 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
28183 concept_spec_entry
* found
= concept_expansions
->find (&elt
);
28185 return found
->result
;
28190 /* Save a concept expansion for later. */
28193 save_concept_expansion (tree tmpl
, tree args
, tree def
)
28195 concept_spec_entry elt
= {tmpl
, args
, def
};
28196 concept_spec_entry
** slot
= concept_expansions
->find_slot (&elt
, INSERT
);
28197 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
28204 hash_subsumption_args (tree t1
, tree t2
)
28206 gcc_assert (TREE_CODE (t1
) == CHECK_CONSTR
);
28207 gcc_assert (TREE_CODE (t2
) == CHECK_CONSTR
);
28209 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t1
), val
);
28210 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t1
), val
);
28211 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t2
), val
);
28212 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t2
), val
);
28216 /* Compare the constraints of two subsumption entries. The LEFT1 and
28217 LEFT2 arguments comprise the first subsumption pair and the RIGHT1
28218 and RIGHT2 arguments comprise the second. These are all CHECK_CONSTRs. */
28221 comp_subsumption_args (tree left1
, tree left2
, tree right1
, tree right2
)
28223 if (CHECK_CONSTR_CONCEPT (left1
) == CHECK_CONSTR_CONCEPT (right1
))
28224 if (CHECK_CONSTR_CONCEPT (left2
) == CHECK_CONSTR_CONCEPT (right2
))
28225 if (comp_template_args (CHECK_CONSTR_ARGS (left1
),
28226 CHECK_CONSTR_ARGS (right1
)))
28227 return comp_template_args (CHECK_CONSTR_ARGS (left2
),
28228 CHECK_CONSTR_ARGS (right2
));
28232 /* Key/value pair for learning and memoizing subsumption results. This
28233 associates a pair of check constraints (including arguments) with
28234 a boolean value indicating the result. */
28236 struct GTY((for_user
)) subsumption_entry
28243 /* Hashing function and equality for constraint entries. */
28245 struct subsumption_hasher
: ggc_ptr_hash
<subsumption_entry
>
28247 static hashval_t
hash (subsumption_entry
*e
)
28249 return hash_subsumption_args (e
->t1
, e
->t2
);
28252 static bool equal (subsumption_entry
*e1
, subsumption_entry
*e2
)
28254 ++comparing_specializations
;
28255 bool eq
= comp_subsumption_args(e1
->t1
, e1
->t2
, e2
->t1
, e2
->t2
);
28256 --comparing_specializations
;
28261 static GTY (()) hash_table
<subsumption_hasher
> *subsumption_table
;
28263 /* Search for a previously cached subsumption result. */
28266 lookup_subsumption_result (tree t1
, tree t2
)
28268 subsumption_entry elt
= { t1
, t2
, false };
28269 subsumption_entry
* found
= subsumption_table
->find (&elt
);
28271 return &found
->result
;
28276 /* Save a subsumption result. */
28279 save_subsumption_result (tree t1
, tree t2
, bool result
)
28281 subsumption_entry elt
= {t1
, t2
, result
};
28282 subsumption_entry
** slot
= subsumption_table
->find_slot (&elt
, INSERT
);
28283 subsumption_entry
* entry
= ggc_alloc
<subsumption_entry
> ();
28289 /* Set up the hash table for constraint association. */
28292 init_constraint_processing (void)
28294 if (!flag_concepts
)
28297 decl_constraints
= hash_table
<constr_hasher
>::create_ggc(37);
28298 constraint_memos
= hash_table
<constraint_sat_hasher
>::create_ggc(37);
28299 concept_memos
= hash_table
<concept_spec_hasher
>::create_ggc(37);
28300 concept_expansions
= hash_table
<concept_spec_hasher
>::create_ggc(37);
28301 subsumption_table
= hash_table
<subsumption_hasher
>::create_ggc(37);
28304 /* __integer_pack(N) in a pack expansion expands to a sequence of numbers from
28308 declare_integer_pack (void)
28310 tree ipfn
= push_library_fn (get_identifier ("__integer_pack"),
28311 build_function_type_list (integer_type_node
,
28314 NULL_TREE
, ECF_CONST
);
28315 DECL_DECLARED_CONSTEXPR_P (ipfn
) = true;
28316 DECL_BUILT_IN_CLASS (ipfn
) = BUILT_IN_FRONTEND
;
28317 DECL_FUNCTION_CODE (ipfn
)
28318 = (enum built_in_function
) (int) CP_BUILT_IN_INTEGER_PACK
;
28321 /* Set up the hash tables for template instantiations. */
28324 init_template_processing (void)
28326 /* FIXME: enable sanitization (PR87847) */
28327 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37, false);
28328 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37, false);
28330 if (cxx_dialect
>= cxx11
)
28331 declare_integer_pack ();
28334 /* Print stats about the template hash tables for -fstats. */
28337 print_template_statistics (void)
28339 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
28340 "%f collisions\n", (long) decl_specializations
->size (),
28341 (long) decl_specializations
->elements (),
28342 decl_specializations
->collisions ());
28343 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
28344 "%f collisions\n", (long) type_specializations
->size (),
28345 (long) type_specializations
->elements (),
28346 type_specializations
->collisions ());
28351 namespace selftest
{
28353 /* Verify that build_non_dependent_expr () works, for various expressions,
28354 and that location wrappers don't affect the results. */
28357 test_build_non_dependent_expr ()
28359 location_t loc
= BUILTINS_LOCATION
;
28361 /* Verify constants, without and with location wrappers. */
28362 tree int_cst
= build_int_cst (integer_type_node
, 42);
28363 ASSERT_EQ (int_cst
, build_non_dependent_expr (int_cst
));
28365 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
28366 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
28367 ASSERT_EQ (wrapped_int_cst
, build_non_dependent_expr (wrapped_int_cst
));
28369 tree string_lit
= build_string (4, "foo");
28370 TREE_TYPE (string_lit
) = char_array_type_node
;
28371 string_lit
= fix_string_type (string_lit
);
28372 ASSERT_EQ (string_lit
, build_non_dependent_expr (string_lit
));
28374 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
28375 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
28376 ASSERT_EQ (wrapped_string_lit
,
28377 build_non_dependent_expr (wrapped_string_lit
));
28380 /* Verify that type_dependent_expression_p () works correctly, even
28381 in the presence of location wrapper nodes. */
28384 test_type_dependent_expression_p ()
28386 location_t loc
= BUILTINS_LOCATION
;
28388 tree name
= get_identifier ("foo");
28390 /* If no templates are involved, nothing is type-dependent. */
28391 gcc_assert (!processing_template_decl
);
28392 ASSERT_FALSE (type_dependent_expression_p (name
));
28394 ++processing_template_decl
;
28396 /* Within a template, an unresolved name is always type-dependent. */
28397 ASSERT_TRUE (type_dependent_expression_p (name
));
28399 /* Ensure it copes with NULL_TREE and errors. */
28400 ASSERT_FALSE (type_dependent_expression_p (NULL_TREE
));
28401 ASSERT_FALSE (type_dependent_expression_p (error_mark_node
));
28403 /* A USING_DECL in a template should be type-dependent, even if wrapped
28404 with a location wrapper (PR c++/83799). */
28405 tree using_decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
28406 TREE_TYPE (using_decl
) = integer_type_node
;
28407 ASSERT_TRUE (type_dependent_expression_p (using_decl
));
28408 tree wrapped_using_decl
= maybe_wrap_with_location (using_decl
, loc
);
28409 ASSERT_TRUE (location_wrapper_p (wrapped_using_decl
));
28410 ASSERT_TRUE (type_dependent_expression_p (wrapped_using_decl
));
28412 --processing_template_decl
;
28415 /* Run all of the selftests within this file. */
28420 test_build_non_dependent_expr ();
28421 test_type_dependent_expression_p ();
28424 } // namespace selftest
28426 #endif /* #if CHECKING_P */
28428 #include "gt-cp-pt.h"