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 permerror (input_location
,
1062 "specializing %q#T in different namespace", type
);
1063 permerror (DECL_SOURCE_LOCATION (tmpl
),
1064 " from definition of %q#D", tmpl
);
1067 /* Check for invalid specialization after instantiation:
1069 template <> template <> class C<int>::D<int>;
1070 template <> template <class U> class C<int>::D; */
1072 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
1073 t
; t
= TREE_CHAIN (t
))
1075 tree inst
= TREE_VALUE (t
);
1076 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
1077 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
1079 /* We already have a full specialization of this partial
1080 instantiation, or a full specialization has been
1081 looked up but not instantiated. Reassign it to the
1082 new member specialization template. */
1086 elt
.tmpl
= most_general_template (tmpl
);
1087 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
1090 type_specializations
->remove_elt (&elt
);
1093 CLASSTYPE_TI_ARGS (inst
)
1094 = elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
1097 = type_specializations
->find_slot (&elt
, INSERT
);
1098 entry
= ggc_alloc
<spec_entry
> ();
1103 /* But if we've had an implicit instantiation, that's a
1104 problem ([temp.expl.spec]/6). */
1105 error ("specialization %qT after instantiation %qT",
1109 /* Mark TYPE as a specialization. And as a result, we only
1110 have one level of template argument for the innermost
1112 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
1113 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
1114 CLASSTYPE_TI_ARGS (type
)
1115 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
1118 else if (processing_specialization
)
1120 /* Someday C++0x may allow for enum template specialization. */
1121 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
1122 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
1123 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
1124 "of %qD not allowed by ISO C++", type
);
1127 error ("explicit specialization of non-template %qT", type
);
1128 return error_mark_node
;
1135 /* Returns nonzero if we can optimize the retrieval of specializations
1136 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1137 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1140 optimize_specialization_lookup_p (tree tmpl
)
1142 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
1143 && DECL_CLASS_SCOPE_P (tmpl
)
1144 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1146 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
1147 /* The optimized lookup depends on the fact that the
1148 template arguments for the member function template apply
1149 purely to the containing class, which is not true if the
1150 containing class is an explicit or partial
1152 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1153 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1154 && !DECL_CONV_FN_P (tmpl
)
1155 /* It is possible to have a template that is not a member
1156 template and is not a member of a template class:
1158 template <typename T>
1159 struct S { friend A::f(); };
1161 Here, the friend function is a template, but the context does
1162 not have template information. The optimized lookup relies
1163 on having ARGS be the template arguments for both the class
1164 and the function template. */
1165 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1168 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1169 gone through coerce_template_parms by now. */
1172 verify_unstripped_args_1 (tree inner
)
1174 for (int i
= 0; i
< TREE_VEC_LENGTH (inner
); ++i
)
1176 tree arg
= TREE_VEC_ELT (inner
, i
);
1177 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1179 else if (TYPE_P (arg
))
1180 gcc_assert (strip_typedefs (arg
, NULL
) == arg
);
1181 else if (ARGUMENT_PACK_P (arg
))
1182 verify_unstripped_args_1 (ARGUMENT_PACK_ARGS (arg
));
1183 else if (strip_typedefs (TREE_TYPE (arg
), NULL
) != TREE_TYPE (arg
))
1184 /* Allow typedefs on the type of a non-type argument, since a
1185 parameter can have them. */;
1187 gcc_assert (strip_typedefs_expr (arg
, NULL
) == arg
);
1192 verify_unstripped_args (tree args
)
1194 ++processing_template_decl
;
1195 if (!any_dependent_template_arguments_p (args
))
1196 verify_unstripped_args_1 (INNERMOST_TEMPLATE_ARGS (args
));
1197 --processing_template_decl
;
1200 /* Retrieve the specialization (in the sense of [temp.spec] - a
1201 specialization is either an instantiation or an explicit
1202 specialization) of TMPL for the given template ARGS. If there is
1203 no such specialization, return NULL_TREE. The ARGS are a vector of
1204 arguments, or a vector of vectors of arguments, in the case of
1205 templates with more than one level of parameters.
1207 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1208 then we search for a partial specialization matching ARGS. This
1209 parameter is ignored if TMPL is not a class template.
1211 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1212 result is a NONTYPE_ARGUMENT_PACK. */
1215 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1217 if (tmpl
== NULL_TREE
)
1220 if (args
== error_mark_node
)
1223 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1224 || TREE_CODE (tmpl
) == FIELD_DECL
);
1226 /* There should be as many levels of arguments as there are
1227 levels of parameters. */
1228 gcc_assert (TMPL_ARGS_DEPTH (args
)
1229 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1230 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1231 : template_class_depth (DECL_CONTEXT (tmpl
))));
1234 verify_unstripped_args (args
);
1236 /* Lambda functions in templates aren't instantiated normally, but through
1237 tsubst_lambda_expr. */
1238 if (lambda_fn_in_template_p (tmpl
))
1241 if (optimize_specialization_lookup_p (tmpl
))
1243 /* The template arguments actually apply to the containing
1244 class. Find the class specialization with those
1246 tree class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1247 tree class_specialization
1248 = retrieve_specialization (class_template
, args
, 0);
1249 if (!class_specialization
)
1252 /* Find the instance of TMPL. */
1253 tree fns
= get_class_binding (class_specialization
, DECL_NAME (tmpl
));
1254 for (ovl_iterator
iter (fns
); iter
; ++iter
)
1257 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1258 /* using-declarations can add base methods to the method vec,
1259 and we don't want those here. */
1260 && DECL_CONTEXT (fn
) == class_specialization
)
1269 hash_table
<spec_hasher
> *specializations
;
1273 elt
.spec
= NULL_TREE
;
1275 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1276 specializations
= type_specializations
;
1278 specializations
= decl_specializations
;
1281 hash
= spec_hasher::hash (&elt
);
1282 found
= specializations
->find_with_hash (&elt
, hash
);
1290 /* Like retrieve_specialization, but for local declarations. */
1293 retrieve_local_specialization (tree tmpl
)
1295 if (local_specializations
== NULL
)
1298 tree
*slot
= local_specializations
->get (tmpl
);
1299 return slot
? *slot
: NULL_TREE
;
1302 /* Returns nonzero iff DECL is a specialization of TMPL. */
1305 is_specialization_of (tree decl
, tree tmpl
)
1309 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1313 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1319 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1321 for (t
= TREE_TYPE (decl
);
1323 t
= CLASSTYPE_USE_TEMPLATE (t
)
1324 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1325 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1332 /* Returns nonzero iff DECL is a specialization of friend declaration
1333 FRIEND_DECL according to [temp.friend]. */
1336 is_specialization_of_friend (tree decl
, tree friend_decl
)
1338 bool need_template
= true;
1341 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1342 || TREE_CODE (decl
) == TYPE_DECL
);
1344 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1345 of a template class, we want to check if DECL is a specialization
1347 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1348 && DECL_TEMPLATE_INFO (friend_decl
)
1349 && !DECL_USE_TEMPLATE (friend_decl
))
1351 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1352 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1353 need_template
= false;
1355 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1356 && !PRIMARY_TEMPLATE_P (friend_decl
))
1357 need_template
= false;
1359 /* There is nothing to do if this is not a template friend. */
1360 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1363 if (is_specialization_of (decl
, friend_decl
))
1367 A member of a class template may be declared to be a friend of a
1368 non-template class. In this case, the corresponding member of
1369 every specialization of the class template is a friend of the
1370 class granting friendship.
1372 For example, given a template friend declaration
1374 template <class T> friend void A<T>::f();
1376 the member function below is considered a friend
1378 template <> struct A<int> {
1382 For this type of template friend, TEMPLATE_DEPTH below will be
1383 nonzero. To determine if DECL is a friend of FRIEND, we first
1384 check if the enclosing class is a specialization of another. */
1386 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1388 && DECL_CLASS_SCOPE_P (decl
)
1389 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1390 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1392 /* Next, we check the members themselves. In order to handle
1393 a few tricky cases, such as when FRIEND_DECL's are
1395 template <class T> friend void A<T>::g(T t);
1396 template <class T> template <T t> friend void A<T>::h();
1400 void A<int>::g(int);
1401 template <int> void A<int>::h();
1403 we need to figure out ARGS, the template arguments from
1404 the context of DECL. This is required for template substitution
1405 of `T' in the function parameter of `g' and template parameter
1406 of `h' in the above examples. Here ARGS corresponds to `int'. */
1408 tree context
= DECL_CONTEXT (decl
);
1409 tree args
= NULL_TREE
;
1410 int current_depth
= 0;
1412 while (current_depth
< template_depth
)
1414 if (CLASSTYPE_TEMPLATE_INFO (context
))
1416 if (current_depth
== 0)
1417 args
= TYPE_TI_ARGS (context
);
1419 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1422 context
= TYPE_CONTEXT (context
);
1425 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1430 tree friend_args_type
;
1431 tree decl_args_type
;
1433 /* Make sure that both DECL and FRIEND_DECL are templates or
1435 is_template
= DECL_TEMPLATE_INFO (decl
)
1436 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1437 if (need_template
^ is_template
)
1439 else if (is_template
)
1441 /* If both are templates, check template parameter list. */
1443 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1445 if (!comp_template_parms
1446 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1450 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1453 decl_type
= TREE_TYPE (decl
);
1455 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1456 tf_none
, NULL_TREE
);
1457 if (friend_type
== error_mark_node
)
1460 /* Check if return types match. */
1461 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1464 /* Check if function parameter types match, ignoring the
1465 `this' parameter. */
1466 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1467 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1468 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1469 friend_args_type
= TREE_CHAIN (friend_args_type
);
1470 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1471 decl_args_type
= TREE_CHAIN (decl_args_type
);
1473 return compparms (decl_args_type
, friend_args_type
);
1477 /* DECL is a TYPE_DECL */
1479 tree decl_type
= TREE_TYPE (decl
);
1481 /* Make sure that both DECL and FRIEND_DECL are templates or
1484 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1485 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1487 if (need_template
^ is_template
)
1489 else if (is_template
)
1492 /* If both are templates, check the name of the two
1493 TEMPLATE_DECL's first because is_friend didn't. */
1494 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1495 != DECL_NAME (friend_decl
))
1498 /* Now check template parameter list. */
1500 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1502 return comp_template_parms
1503 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1507 return (DECL_NAME (decl
)
1508 == DECL_NAME (friend_decl
));
1514 /* Register the specialization SPEC as a specialization of TMPL with
1515 the indicated ARGS. IS_FRIEND indicates whether the specialization
1516 is actually just a friend declaration. ATTRLIST is the list of
1517 attributes that the specialization is declared with or NULL when
1518 it isn't. Returns SPEC, or an equivalent prior declaration, if
1521 We also store instantiations of field packs in the hash table, even
1522 though they are not themselves templates, to make lookup easier. */
1525 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1529 spec_entry
**slot
= NULL
;
1532 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1533 || (TREE_CODE (tmpl
) == FIELD_DECL
1534 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1536 if (TREE_CODE (spec
) == FUNCTION_DECL
1537 && uses_template_parms (DECL_TI_ARGS (spec
)))
1538 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1539 register it; we want the corresponding TEMPLATE_DECL instead.
1540 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1541 the more obvious `uses_template_parms (spec)' to avoid problems
1542 with default function arguments. In particular, given
1543 something like this:
1545 template <class T> void f(T t1, T t = T())
1547 the default argument expression is not substituted for in an
1548 instantiation unless and until it is actually needed. */
1551 if (optimize_specialization_lookup_p (tmpl
))
1552 /* We don't put these specializations in the hash table, but we might
1553 want to give an error about a mismatch. */
1554 fn
= retrieve_specialization (tmpl
, args
, 0);
1562 hash
= spec_hasher::hash (&elt
);
1565 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1567 fn
= ((spec_entry
*) *slot
)->spec
;
1572 /* We can sometimes try to re-register a specialization that we've
1573 already got. In particular, regenerate_decl_from_template calls
1574 duplicate_decls which will update the specialization list. But,
1575 we'll still get called again here anyhow. It's more convenient
1576 to simply allow this than to try to prevent it. */
1579 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1581 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1583 if (DECL_ODR_USED (fn
)
1584 || DECL_EXPLICIT_INSTANTIATION (fn
))
1586 error ("specialization of %qD after instantiation",
1588 return error_mark_node
;
1593 /* This situation should occur only if the first
1594 specialization is an implicit instantiation, the
1595 second is an explicit specialization, and the
1596 implicit instantiation has not yet been used. That
1597 situation can occur if we have implicitly
1598 instantiated a member function and then specialized
1601 We can also wind up here if a friend declaration that
1602 looked like an instantiation turns out to be a
1605 template <class T> void foo(T);
1606 class S { friend void foo<>(int) };
1607 template <> void foo(int);
1609 We transform the existing DECL in place so that any
1610 pointers to it become pointers to the updated
1613 If there was a definition for the template, but not
1614 for the specialization, we want this to look as if
1615 there were no definition, and vice versa. */
1616 DECL_INITIAL (fn
) = NULL_TREE
;
1617 duplicate_decls (spec
, fn
, is_friend
);
1618 /* The call to duplicate_decls will have applied
1621 An explicit specialization of a function template
1622 is inline only if it is explicitly declared to be,
1623 and independently of whether its function template
1626 to the primary function; now copy the inline bits to
1627 the various clones. */
1628 FOR_EACH_CLONE (clone
, fn
)
1630 DECL_DECLARED_INLINE_P (clone
)
1631 = DECL_DECLARED_INLINE_P (fn
);
1632 DECL_SOURCE_LOCATION (clone
)
1633 = DECL_SOURCE_LOCATION (fn
);
1634 DECL_DELETED_FN (clone
)
1635 = DECL_DELETED_FN (fn
);
1637 check_specialization_namespace (tmpl
);
1642 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1644 tree dd
= duplicate_decls (spec
, fn
, is_friend
);
1645 if (dd
== error_mark_node
)
1646 /* We've already complained in duplicate_decls. */
1647 return error_mark_node
;
1649 if (dd
== NULL_TREE
&& DECL_INITIAL (spec
))
1650 /* Dup decl failed, but this is a new definition. Set the
1651 line number so any errors match this new
1653 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1659 return duplicate_decls (spec
, fn
, is_friend
);
1661 /* A specialization must be declared in the same namespace as the
1662 template it is specializing. */
1663 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1664 && !check_specialization_namespace (tmpl
))
1665 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1667 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1669 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1670 gcc_assert (tmpl
&& args
&& spec
);
1673 if ((TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1674 && PRIMARY_TEMPLATE_P (tmpl
)
1675 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1676 || variable_template_p (tmpl
))
1677 /* If TMPL is a forward declaration of a template function, keep a list
1678 of all specializations in case we need to reassign them to a friend
1679 template later in tsubst_friend_function.
1681 Also keep a list of all variable template instantiations so that
1682 process_partial_specialization can check whether a later partial
1683 specialization would have used it. */
1684 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1685 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1691 /* Returns true iff two spec_entry nodes are equivalent. */
1693 int comparing_specializations
;
1696 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1700 ++comparing_specializations
;
1701 equal
= (e1
->tmpl
== e2
->tmpl
1702 && comp_template_args (e1
->args
, e2
->args
));
1703 if (equal
&& flag_concepts
1704 /* tmpl could be a FIELD_DECL for a capture pack. */
1705 && TREE_CODE (e1
->tmpl
) == TEMPLATE_DECL
1706 && VAR_P (DECL_TEMPLATE_RESULT (e1
->tmpl
))
1707 && uses_template_parms (e1
->args
))
1709 /* Partial specializations of a variable template can be distinguished by
1711 tree c1
= e1
->spec
? get_constraints (e1
->spec
) : NULL_TREE
;
1712 tree c2
= e2
->spec
? get_constraints (e2
->spec
) : NULL_TREE
;
1713 equal
= equivalent_constraints (c1
, c2
);
1715 --comparing_specializations
;
1720 /* Returns a hash for a template TMPL and template arguments ARGS. */
1723 hash_tmpl_and_args (tree tmpl
, tree args
)
1725 hashval_t val
= iterative_hash_object (DECL_UID (tmpl
), 0);
1726 return iterative_hash_template_arg (args
, val
);
1729 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1733 spec_hasher::hash (spec_entry
*e
)
1735 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1738 /* Recursively calculate a hash value for a template argument ARG, for use
1739 in the hash tables of template specializations. */
1742 iterative_hash_template_arg (tree arg
, hashval_t val
)
1744 unsigned HOST_WIDE_INT i
;
1745 enum tree_code code
;
1748 if (arg
== NULL_TREE
)
1749 return iterative_hash_object (arg
, val
);
1754 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1757 code
= TREE_CODE (arg
);
1758 tclass
= TREE_CODE_CLASS (code
);
1760 val
= iterative_hash_object (code
, val
);
1767 case IDENTIFIER_NODE
:
1768 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1772 int i
, len
= TREE_VEC_LENGTH (arg
);
1773 for (i
= 0; i
< len
; ++i
)
1774 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1778 case TYPE_PACK_EXPANSION
:
1779 case EXPR_PACK_EXPANSION
:
1780 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1781 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1783 case TYPE_ARGUMENT_PACK
:
1784 case NONTYPE_ARGUMENT_PACK
:
1785 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1788 for (; arg
; arg
= TREE_CHAIN (arg
))
1789 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1793 for (lkp_iterator
iter (arg
); iter
; ++iter
)
1794 val
= iterative_hash_template_arg (*iter
, val
);
1800 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1801 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1803 val
= iterative_hash_template_arg (field
, val
);
1804 val
= iterative_hash_template_arg (value
, val
);
1810 if (!DECL_ARTIFICIAL (arg
))
1812 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1813 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1815 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1818 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1821 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1822 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1824 case TEMPLATE_PARM_INDEX
:
1825 val
= iterative_hash_template_arg
1826 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1827 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1828 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1831 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1832 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1833 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1836 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1838 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1842 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1843 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1844 val
= iterative_hash_object (code
, val
);
1845 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1848 /* [temp.over.link] Two lambda-expressions are never considered
1851 So just hash the closure type. */
1852 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1855 case IMPLICIT_CONV_EXPR
:
1856 case STATIC_CAST_EXPR
:
1857 case REINTERPRET_CAST_EXPR
:
1858 case CONST_CAST_EXPR
:
1859 case DYNAMIC_CAST_EXPR
:
1861 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1862 /* Now hash operands as usual. */
1867 tree fn
= CALL_EXPR_FN (arg
);
1868 if (tree name
= dependent_name (fn
))
1870 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
1871 val
= iterative_hash_template_arg (TREE_OPERAND (fn
, 1), val
);
1874 val
= iterative_hash_template_arg (fn
, val
);
1875 call_expr_arg_iterator ai
;
1876 for (tree x
= first_call_expr_arg (arg
, &ai
); x
;
1877 x
= next_call_expr_arg (&ai
))
1878 val
= iterative_hash_template_arg (x
, val
);
1889 if (alias_template_specialization_p (arg
))
1891 // We want an alias specialization that survived strip_typedefs
1892 // to hash differently from its TYPE_CANONICAL, to avoid hash
1893 // collisions that compare as different in template_args_equal.
1894 // These could be dependent specializations that strip_typedefs
1895 // left alone, or untouched specializations because
1896 // coerce_template_parms returns the unconverted template
1897 // arguments if it sees incomplete argument packs.
1898 tree ti
= TYPE_ALIAS_TEMPLATE_INFO (arg
);
1899 return hash_tmpl_and_args (TI_TEMPLATE (ti
), TI_ARGS (ti
));
1901 if (TYPE_CANONICAL (arg
))
1902 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1904 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1905 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1906 /* Otherwise just compare the types during lookup. */
1909 case tcc_declaration
:
1911 return iterative_hash_expr (arg
, val
);
1914 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1916 unsigned n
= cp_tree_operand_length (arg
);
1917 for (i
= 0; i
< n
; ++i
)
1918 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1926 /* Unregister the specialization SPEC as a specialization of TMPL.
1927 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1928 if the SPEC was listed as a specialization of TMPL.
1930 Note that SPEC has been ggc_freed, so we can't look inside it. */
1933 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1938 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1939 elt
.args
= TI_ARGS (tinfo
);
1940 elt
.spec
= NULL_TREE
;
1942 entry
= decl_specializations
->find (&elt
);
1945 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1946 gcc_assert (new_spec
!= NULL_TREE
);
1947 entry
->spec
= new_spec
;
1954 /* Like register_specialization, but for local declarations. We are
1955 registering SPEC, an instantiation of TMPL. */
1958 register_local_specialization (tree spec
, tree tmpl
)
1960 gcc_assert (tmpl
!= spec
);
1961 local_specializations
->put (tmpl
, spec
);
1964 /* TYPE is a class type. Returns true if TYPE is an explicitly
1965 specialized class. */
1968 explicit_class_specialization_p (tree type
)
1970 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1972 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1975 /* Print the list of functions at FNS, going through all the overloads
1976 for each element of the list. Alternatively, FNS cannot be a
1977 TREE_LIST, in which case it will be printed together with all the
1980 MORE and *STR should respectively be FALSE and NULL when the function
1981 is called from the outside. They are used internally on recursive
1982 calls. print_candidates manages the two parameters and leaves NULL
1983 in *STR when it ends. */
1986 print_candidates_1 (tree fns
, char **str
, bool more
= false)
1988 if (TREE_CODE (fns
) == TREE_LIST
)
1989 for (; fns
; fns
= TREE_CHAIN (fns
))
1990 print_candidates_1 (TREE_VALUE (fns
), str
, more
|| TREE_CHAIN (fns
));
1992 for (lkp_iterator
iter (fns
); iter
;)
1997 const char *pfx
= *str
;
2001 pfx
= _("candidates are:");
2003 pfx
= _("candidate is:");
2004 *str
= get_spaces (pfx
);
2006 inform (DECL_SOURCE_LOCATION (cand
), "%s %#qD", pfx
, cand
);
2010 /* Print the list of candidate FNS in an error message. FNS can also
2011 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
2014 print_candidates (tree fns
)
2017 print_candidates_1 (fns
, &str
);
2021 /* Get a (possibly) constrained template declaration for the
2022 purpose of ordering candidates. */
2024 get_template_for_ordering (tree list
)
2026 gcc_assert (TREE_CODE (list
) == TREE_LIST
);
2027 tree f
= TREE_VALUE (list
);
2028 if (tree ti
= DECL_TEMPLATE_INFO (f
))
2029 return TI_TEMPLATE (ti
);
2033 /* Among candidates having the same signature, return the
2034 most constrained or NULL_TREE if there is no best candidate.
2035 If the signatures of candidates vary (e.g., template
2036 specialization vs. member function), then there can be no
2039 Note that we don't compare constraints on the functions
2040 themselves, but rather those of their templates. */
2042 most_constrained_function (tree candidates
)
2044 // Try to find the best candidate in a first pass.
2045 tree champ
= candidates
;
2046 for (tree c
= TREE_CHAIN (champ
); c
; c
= TREE_CHAIN (c
))
2048 int winner
= more_constrained (get_template_for_ordering (champ
),
2049 get_template_for_ordering (c
));
2051 champ
= c
; // The candidate is more constrained
2052 else if (winner
== 0)
2053 return NULL_TREE
; // Neither is more constrained
2056 // Verify that the champ is better than previous candidates.
2057 for (tree c
= candidates
; c
!= champ
; c
= TREE_CHAIN (c
)) {
2058 if (!more_constrained (get_template_for_ordering (champ
),
2059 get_template_for_ordering (c
)))
2067 /* Returns the template (one of the functions given by TEMPLATE_ID)
2068 which can be specialized to match the indicated DECL with the
2069 explicit template args given in TEMPLATE_ID. The DECL may be
2070 NULL_TREE if none is available. In that case, the functions in
2071 TEMPLATE_ID are non-members.
2073 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2074 specialization of a member template.
2076 The TEMPLATE_COUNT is the number of references to qualifying
2077 template classes that appeared in the name of the function. See
2078 check_explicit_specialization for a more accurate description.
2080 TSK indicates what kind of template declaration (if any) is being
2081 declared. TSK_TEMPLATE indicates that the declaration given by
2082 DECL, though a FUNCTION_DECL, has template parameters, and is
2083 therefore a template function.
2085 The template args (those explicitly specified and those deduced)
2086 are output in a newly created vector *TARGS_OUT.
2088 If it is impossible to determine the result, an error message is
2089 issued. The error_mark_node is returned to indicate failure. */
2092 determine_specialization (tree template_id
,
2095 int need_member_template
,
2101 tree explicit_targs
;
2102 tree candidates
= NULL_TREE
;
2104 /* A TREE_LIST of templates of which DECL may be a specialization.
2105 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2106 corresponding TREE_PURPOSE is the set of template arguments that,
2107 when used to instantiate the template, would produce a function
2108 with the signature of DECL. */
2109 tree templates
= NULL_TREE
;
2111 cp_binding_level
*b
;
2113 *targs_out
= NULL_TREE
;
2115 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
2116 return error_mark_node
;
2118 /* We shouldn't be specializing a member template of an
2119 unspecialized class template; we already gave an error in
2120 check_specialization_scope, now avoid crashing. */
2122 && template_count
&& DECL_CLASS_SCOPE_P (decl
)
2123 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
2125 gcc_assert (errorcount
);
2126 return error_mark_node
;
2129 fns
= TREE_OPERAND (template_id
, 0);
2130 explicit_targs
= TREE_OPERAND (template_id
, 1);
2132 if (fns
== error_mark_node
)
2133 return error_mark_node
;
2135 /* Check for baselinks. */
2136 if (BASELINK_P (fns
))
2137 fns
= BASELINK_FUNCTIONS (fns
);
2139 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
2141 error ("%qD is not a function template", fns
);
2142 return error_mark_node
;
2144 else if (VAR_P (decl
) && !variable_template_p (fns
))
2146 error ("%qD is not a variable template", fns
);
2147 return error_mark_node
;
2150 /* Count the number of template headers specified for this
2153 for (b
= current_binding_level
;
2154 b
->kind
== sk_template_parms
;
2158 tree orig_fns
= fns
;
2160 if (variable_template_p (fns
))
2162 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns
));
2163 targs
= coerce_template_parms (parms
, explicit_targs
, fns
,
2164 tf_warning_or_error
,
2165 /*req_all*/true, /*use_defarg*/true);
2166 if (targs
!= error_mark_node
)
2167 templates
= tree_cons (targs
, fns
, templates
);
2169 else for (lkp_iterator
iter (fns
); iter
; ++iter
)
2173 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2175 tree decl_arg_types
;
2179 /* In case of explicit specialization, we need to check if
2180 the number of template headers appearing in the specialization
2181 is correct. This is usually done in check_explicit_specialization,
2182 but the check done there cannot be exhaustive when specializing
2183 member functions. Consider the following code:
2185 template <> void A<int>::f(int);
2186 template <> template <> void A<int>::f(int);
2188 Assuming that A<int> is not itself an explicit specialization
2189 already, the first line specializes "f" which is a non-template
2190 member function, whilst the second line specializes "f" which
2191 is a template member function. So both lines are syntactically
2192 correct, and check_explicit_specialization does not reject
2195 Here, we can do better, as we are matching the specialization
2196 against the declarations. We count the number of template
2197 headers, and we check if they match TEMPLATE_COUNT + 1
2198 (TEMPLATE_COUNT is the number of qualifying template classes,
2199 plus there must be another header for the member template
2202 Notice that if header_count is zero, this is not a
2203 specialization but rather a template instantiation, so there
2204 is no check we can perform here. */
2205 if (header_count
&& header_count
!= template_count
+ 1)
2208 /* Check that the number of template arguments at the
2209 innermost level for DECL is the same as for FN. */
2210 if (current_binding_level
->kind
== sk_template_parms
2211 && !current_binding_level
->explicit_spec_p
2212 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
2213 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
2214 (current_template_parms
))))
2217 /* DECL might be a specialization of FN. */
2218 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2219 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2221 /* For a non-static member function, we need to make sure
2222 that the const qualification is the same. Since
2223 get_bindings does not try to merge the "this" parameter,
2224 we must do the comparison explicitly. */
2225 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
2227 if (!same_type_p (TREE_VALUE (fn_arg_types
),
2228 TREE_VALUE (decl_arg_types
)))
2231 /* And the ref-qualification. */
2232 if (type_memfn_rqual (TREE_TYPE (decl
))
2233 != type_memfn_rqual (TREE_TYPE (fn
)))
2237 /* Skip the "this" parameter and, for constructors of
2238 classes with virtual bases, the VTT parameter. A
2239 full specialization of a constructor will have a VTT
2240 parameter, but a template never will. */
2242 = skip_artificial_parms_for (decl
, decl_arg_types
);
2244 = skip_artificial_parms_for (fn
, fn_arg_types
);
2246 /* Function templates cannot be specializations; there are
2247 no partial specializations of functions. Therefore, if
2248 the type of DECL does not match FN, there is no
2251 Note that it should never be the case that we have both
2252 candidates added here, and for regular member functions
2254 if (tsk
== tsk_template
)
2256 if (compparms (fn_arg_types
, decl_arg_types
))
2257 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2261 /* See whether this function might be a specialization of this
2262 template. Suppress access control because we might be trying
2263 to make this specialization a friend, and we have already done
2264 access control for the declaration of the specialization. */
2265 push_deferring_access_checks (dk_no_check
);
2266 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
2267 pop_deferring_access_checks ();
2270 /* We cannot deduce template arguments that when used to
2271 specialize TMPL will produce DECL. */
2274 if (uses_template_parms (targs
))
2275 /* We deduced something involving 'auto', which isn't a valid
2276 template argument. */
2279 /* Remove, from the set of candidates, all those functions
2280 whose constraints are not satisfied. */
2281 if (flag_concepts
&& !constraints_satisfied_p (fn
, targs
))
2284 // Then, try to form the new function type.
2285 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_fndecl_type
, NULL_TREE
);
2286 if (insttype
== error_mark_node
)
2289 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
2290 if (!compparms (fn_arg_types
, decl_arg_types
))
2293 /* Save this template, and the arguments deduced. */
2294 templates
= tree_cons (targs
, fn
, templates
);
2296 else if (need_member_template
)
2297 /* FN is an ordinary member function, and we need a
2298 specialization of a member template. */
2300 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2301 /* We can get IDENTIFIER_NODEs here in certain erroneous
2304 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2305 /* This is just an ordinary non-member function. Nothing can
2306 be a specialization of that. */
2308 else if (DECL_ARTIFICIAL (fn
))
2309 /* Cannot specialize functions that are created implicitly. */
2313 tree decl_arg_types
;
2315 /* This is an ordinary member function. However, since
2316 we're here, we can assume its enclosing class is a
2317 template class. For example,
2319 template <typename T> struct S { void f(); };
2320 template <> void S<int>::f() {}
2322 Here, S<int>::f is a non-template, but S<int> is a
2323 template class. If FN has the same type as DECL, we
2324 might be in business. */
2326 if (!DECL_TEMPLATE_INFO (fn
))
2327 /* Its enclosing class is an explicit specialization
2328 of a template class. This is not a candidate. */
2331 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2332 TREE_TYPE (TREE_TYPE (fn
))))
2333 /* The return types differ. */
2336 /* Adjust the type of DECL in case FN is a static member. */
2337 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2338 if (DECL_STATIC_FUNCTION_P (fn
)
2339 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2340 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2342 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2346 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2347 && (type_memfn_rqual (TREE_TYPE (decl
))
2348 != type_memfn_rqual (TREE_TYPE (fn
))))
2351 // If the deduced arguments do not satisfy the constraints,
2352 // this is not a candidate.
2353 if (flag_concepts
&& !constraints_satisfied_p (fn
))
2356 // Add the candidate.
2357 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2361 if (templates
&& TREE_CHAIN (templates
))
2367 It is possible for a specialization with a given function
2368 signature to be instantiated from more than one function
2369 template. In such cases, explicit specification of the
2370 template arguments must be used to uniquely identify the
2371 function template specialization being specialized.
2373 Note that here, there's no suggestion that we're supposed to
2374 determine which of the candidate templates is most
2375 specialized. However, we, also have:
2379 Partial ordering of overloaded function template
2380 declarations is used in the following contexts to select
2381 the function template to which a function template
2382 specialization refers:
2384 -- when an explicit specialization refers to a function
2387 So, we do use the partial ordering rules, at least for now.
2388 This extension can only serve to make invalid programs valid,
2389 so it's safe. And, there is strong anecdotal evidence that
2390 the committee intended the partial ordering rules to apply;
2391 the EDG front end has that behavior, and John Spicer claims
2392 that the committee simply forgot to delete the wording in
2393 [temp.expl.spec]. */
2394 tree tmpl
= most_specialized_instantiation (templates
);
2395 if (tmpl
!= error_mark_node
)
2398 TREE_CHAIN (templates
) = NULL_TREE
;
2402 // Concepts allows multiple declarations of member functions
2403 // with the same signature. Like above, we need to rely on
2404 // on the partial ordering of those candidates to determine which
2406 if (flag_concepts
&& candidates
&& TREE_CHAIN (candidates
))
2408 if (tree cand
= most_constrained_function (candidates
))
2411 TREE_CHAIN (cand
) = NULL_TREE
;
2415 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2417 error ("template-id %qD for %q+D does not match any template "
2418 "declaration", template_id
, decl
);
2419 if (header_count
&& header_count
!= template_count
+ 1)
2420 inform (input_location
, "saw %d %<template<>%>, need %d for "
2421 "specializing a member function template",
2422 header_count
, template_count
+ 1);
2424 print_candidates (orig_fns
);
2425 return error_mark_node
;
2427 else if ((templates
&& TREE_CHAIN (templates
))
2428 || (candidates
&& TREE_CHAIN (candidates
))
2429 || (templates
&& candidates
))
2431 error ("ambiguous template specialization %qD for %q+D",
2433 candidates
= chainon (candidates
, templates
);
2434 print_candidates (candidates
);
2435 return error_mark_node
;
2438 /* We have one, and exactly one, match. */
2441 tree fn
= TREE_VALUE (candidates
);
2442 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2444 // Propagate the candidate's constraints to the declaration.
2445 set_constraints (decl
, get_constraints (fn
));
2447 /* DECL is a re-declaration or partial instantiation of a template
2449 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2451 /* It was a specialization of an ordinary member function in a
2453 return DECL_TI_TEMPLATE (fn
);
2456 /* It was a specialization of a template. */
2457 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2458 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2460 *targs_out
= copy_node (targs
);
2461 SET_TMPL_ARGS_LEVEL (*targs_out
,
2462 TMPL_ARGS_DEPTH (*targs_out
),
2463 TREE_PURPOSE (templates
));
2466 *targs_out
= TREE_PURPOSE (templates
);
2467 return TREE_VALUE (templates
);
2470 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2471 but with the default argument values filled in from those in the
2475 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2478 tree new_spec_types
;
2483 if (spec_types
== void_list_node
)
2484 return void_list_node
;
2486 /* Substitute into the rest of the list. */
2488 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2489 TREE_CHAIN (tmpl_types
));
2491 /* Add the default argument for this parameter. */
2492 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2493 TREE_VALUE (spec_types
),
2497 /* DECL is an explicit specialization. Replicate default arguments
2498 from the template it specializes. (That way, code like:
2500 template <class T> void f(T = 3);
2501 template <> void f(double);
2504 works, as required.) An alternative approach would be to look up
2505 the correct default arguments at the call-site, but this approach
2506 is consistent with how implicit instantiations are handled. */
2509 copy_default_args_to_explicit_spec (tree decl
)
2514 tree new_spec_types
;
2518 tree object_type
= NULL_TREE
;
2519 tree in_charge
= NULL_TREE
;
2520 tree vtt
= NULL_TREE
;
2522 /* See if there's anything we need to do. */
2523 tmpl
= DECL_TI_TEMPLATE (decl
);
2524 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2525 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2526 if (TREE_PURPOSE (t
))
2531 old_type
= TREE_TYPE (decl
);
2532 spec_types
= TYPE_ARG_TYPES (old_type
);
2534 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2536 /* Remove the this pointer, but remember the object's type for
2538 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2539 spec_types
= TREE_CHAIN (spec_types
);
2540 tmpl_types
= TREE_CHAIN (tmpl_types
);
2542 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2544 /* DECL may contain more parameters than TMPL due to the extra
2545 in-charge parameter in constructors and destructors. */
2546 in_charge
= spec_types
;
2547 spec_types
= TREE_CHAIN (spec_types
);
2549 if (DECL_HAS_VTT_PARM_P (decl
))
2552 spec_types
= TREE_CHAIN (spec_types
);
2556 /* Compute the merged default arguments. */
2558 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2560 /* Compute the new FUNCTION_TYPE. */
2564 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2569 /* Put the in-charge parameter back. */
2570 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2571 TREE_VALUE (in_charge
),
2574 new_type
= build_method_type_directly (object_type
,
2575 TREE_TYPE (old_type
),
2579 new_type
= build_function_type (TREE_TYPE (old_type
),
2581 new_type
= cp_build_type_attribute_variant (new_type
,
2582 TYPE_ATTRIBUTES (old_type
));
2583 new_type
= cxx_copy_lang_qualifiers (new_type
, old_type
);
2585 TREE_TYPE (decl
) = new_type
;
2588 /* Return the number of template headers we expect to see for a definition
2589 or specialization of CTYPE or one of its non-template members. */
2592 num_template_headers_for_class (tree ctype
)
2594 int num_templates
= 0;
2596 while (ctype
&& CLASS_TYPE_P (ctype
))
2598 /* You're supposed to have one `template <...>' for every
2599 template class, but you don't need one for a full
2600 specialization. For example:
2602 template <class T> struct S{};
2603 template <> struct S<int> { void f(); };
2604 void S<int>::f () {}
2606 is correct; there shouldn't be a `template <>' for the
2607 definition of `S<int>::f'. */
2608 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2609 /* If CTYPE does not have template information of any
2610 kind, then it is not a template, nor is it nested
2611 within a template. */
2613 if (explicit_class_specialization_p (ctype
))
2615 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2618 ctype
= TYPE_CONTEXT (ctype
);
2621 return num_templates
;
2624 /* Do a simple sanity check on the template headers that precede the
2625 variable declaration DECL. */
2628 check_template_variable (tree decl
)
2630 tree ctx
= CP_DECL_CONTEXT (decl
);
2631 int wanted
= num_template_headers_for_class (ctx
);
2632 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2633 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2635 if (cxx_dialect
< cxx14
)
2636 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2637 "variable templates only available with "
2638 "%<-std=c++14%> or %<-std=gnu++14%>");
2640 // Namespace-scope variable templates should have a template header.
2643 if (template_header_count
> wanted
)
2645 auto_diagnostic_group d
;
2646 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2647 "too many template headers for %qD "
2650 if (warned
&& CLASS_TYPE_P (ctx
)
2651 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2652 inform (DECL_SOURCE_LOCATION (decl
),
2653 "members of an explicitly specialized class are defined "
2654 "without a template header");
2658 /* An explicit specialization whose declarator-id or class-head-name is not
2659 qualified shall be declared in the nearest enclosing namespace of the
2660 template, or, if the namespace is inline (7.3.1), any namespace from its
2661 enclosing namespace set.
2663 If the name declared in the explicit instantiation is an unqualified name,
2664 the explicit instantiation shall appear in the namespace where its template
2665 is declared or, if that namespace is inline (7.3.1), any namespace from its
2666 enclosing namespace set. */
2669 check_unqualified_spec_or_inst (tree t
, location_t loc
)
2671 tree tmpl
= most_general_template (t
);
2672 if (DECL_NAMESPACE_SCOPE_P (tmpl
)
2673 && !is_nested_namespace (current_namespace
,
2674 CP_DECL_CONTEXT (tmpl
), true))
2676 if (processing_specialization
)
2677 permerror (loc
, "explicit specialization of %qD outside its "
2678 "namespace must use a nested-name-specifier", tmpl
);
2679 else if (processing_explicit_instantiation
2680 && cxx_dialect
>= cxx11
)
2681 /* This was allowed in C++98, so only pedwarn. */
2682 pedwarn (loc
, OPT_Wpedantic
, "explicit instantiation of %qD "
2683 "outside its namespace must use a nested-name-"
2688 /* Warn for a template specialization SPEC that is missing some of a set
2689 of function or type attributes that the template TEMPL is declared with.
2690 ATTRLIST is a list of additional attributes that SPEC should be taken
2691 to ultimately be declared with. */
2694 warn_spec_missing_attributes (tree tmpl
, tree spec
, tree attrlist
)
2696 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
2697 tmpl
= DECL_TEMPLATE_RESULT (tmpl
);
2699 /* Avoid warning if the difference between the primary and
2700 the specialization is not in one of the attributes below. */
2701 const char* const blacklist
[] = {
2702 "alloc_align", "alloc_size", "assume_aligned", "format",
2703 "format_arg", "malloc", "nonnull", NULL
2706 /* Put together a list of the black listed attributes that the primary
2707 template is declared with that the specialization is not, in case
2708 it's not apparent from the most recent declaration of the primary. */
2710 unsigned nattrs
= decls_mismatched_attributes (tmpl
, spec
, attrlist
,
2716 auto_diagnostic_group d
;
2717 if (warning_at (DECL_SOURCE_LOCATION (spec
), OPT_Wmissing_attributes
,
2718 "explicit specialization %q#D may be missing attributes",
2720 inform (DECL_SOURCE_LOCATION (tmpl
),
2722 ? G_("missing primary template attributes %s")
2723 : G_("missing primary template attribute %s"),
2724 pp_formatted_text (&str
));
2727 /* Check to see if the function just declared, as indicated in
2728 DECLARATOR, and in DECL, is a specialization of a function
2729 template. We may also discover that the declaration is an explicit
2730 instantiation at this point.
2732 Returns DECL, or an equivalent declaration that should be used
2733 instead if all goes well. Issues an error message if something is
2734 amiss. Returns error_mark_node if the error is not easily
2737 FLAGS is a bitmask consisting of the following flags:
2739 2: The function has a definition.
2740 4: The function is a friend.
2742 The TEMPLATE_COUNT is the number of references to qualifying
2743 template classes that appeared in the name of the function. For
2746 template <class T> struct S { void f(); };
2749 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2750 classes are not counted in the TEMPLATE_COUNT, so that in
2752 template <class T> struct S {};
2753 template <> struct S<int> { void f(); }
2754 template <> void S<int>::f();
2756 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2757 invalid; there should be no template <>.)
2759 If the function is a specialization, it is marked as such via
2760 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2761 is set up correctly, and it is added to the list of specializations
2762 for that template. */
2765 check_explicit_specialization (tree declarator
,
2771 int have_def
= flags
& 2;
2772 int is_friend
= flags
& 4;
2773 bool is_concept
= flags
& 8;
2774 int specialization
= 0;
2775 int explicit_instantiation
= 0;
2776 int member_specialization
= 0;
2777 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2778 tree dname
= DECL_NAME (decl
);
2783 if (!processing_specialization
)
2786 tsk
= tsk_excessive_parms
;
2789 tsk
= current_tmpl_spec_kind (template_count
);
2794 if (processing_specialization
&& !VAR_P (decl
))
2797 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2799 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2802 /* This could be something like:
2804 template <class T> void f(T);
2805 class S { friend void f<>(int); } */
2809 /* This case handles bogus declarations like template <>
2810 template <class T> void f<int>(); */
2812 error ("template-id %qD in declaration of primary template",
2819 case tsk_invalid_member_spec
:
2820 /* The error has already been reported in
2821 check_specialization_scope. */
2822 return error_mark_node
;
2824 case tsk_invalid_expl_inst
:
2825 error ("template parameter list used in explicit instantiation");
2831 error ("definition provided for explicit instantiation");
2833 explicit_instantiation
= 1;
2836 case tsk_excessive_parms
:
2837 case tsk_insufficient_parms
:
2838 if (tsk
== tsk_excessive_parms
)
2839 error ("too many template parameter lists in declaration of %qD",
2841 else if (template_header_count
)
2842 error("too few template parameter lists in declaration of %qD", decl
);
2844 error("explicit specialization of %qD must be introduced by "
2845 "%<template <>%>", decl
);
2850 error ("explicit specialization declared %<concept%>");
2852 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2853 /* In cases like template<> constexpr bool v = true;
2854 We'll give an error in check_template_variable. */
2857 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2859 member_specialization
= 1;
2865 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2867 /* This case handles bogus declarations like template <>
2868 template <class T> void f<int>(); */
2870 if (!uses_template_parms (TREE_OPERAND (declarator
, 1)))
2871 error ("template-id %qD in declaration of primary template",
2873 else if (variable_template_p (TREE_OPERAND (declarator
, 0)))
2875 /* Partial specialization of variable template. */
2876 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2880 else if (cxx_dialect
< cxx14
)
2881 error ("non-type partial specialization %qD "
2882 "is not allowed", declarator
);
2884 error ("non-class, non-variable partial specialization %qD "
2885 "is not allowed", declarator
);
2890 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2891 /* This is a specialization of a member template, without
2892 specialization the containing class. Something like:
2894 template <class T> struct S {
2895 template <class U> void f (U);
2897 template <> template <class U> void S<int>::f(U) {}
2899 That's a specialization -- but of the entire template. */
2907 if ((specialization
|| member_specialization
)
2908 /* This doesn't apply to variable templates. */
2909 && (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
2910 || TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
))
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", max
);
3611 return error_mark_node
;
3614 tree vec
= make_tree_vec (len
);
3616 for (int i
= 0; i
< len
; ++i
)
3617 TREE_VEC_ELT (vec
, i
) = size_int (i
);
3623 /* Return a TREE_VEC for the expansion of built-in template parameter pack
3627 expand_builtin_pack_call (tree call
, tree args
, tsubst_flags_t complain
,
3630 if (!builtin_pack_call_p (call
))
3633 tree fn
= CALL_EXPR_FN (call
);
3635 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3636 return expand_integer_pack (call
, args
, complain
, in_decl
);
3641 /* Structure used to track the progress of find_parameter_packs_r. */
3642 struct find_parameter_pack_data
3644 /* TREE_LIST that will contain all of the parameter packs found by
3646 tree
* parameter_packs
;
3648 /* Set of AST nodes that have been visited by the traversal. */
3649 hash_set
<tree
> *visited
;
3651 /* True iff we're making a type pack expansion. */
3652 bool type_pack_expansion_p
;
3655 /* Identifies all of the argument packs that occur in a template
3656 argument and appends them to the TREE_LIST inside DATA, which is a
3657 find_parameter_pack_data structure. This is a subroutine of
3658 make_pack_expansion and uses_parameter_packs. */
3660 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3663 struct find_parameter_pack_data
* ppd
=
3664 (struct find_parameter_pack_data
*)data
;
3665 bool parameter_pack_p
= false;
3667 /* Handle type aliases/typedefs. */
3668 if (TYPE_ALIAS_P (t
))
3670 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
3671 cp_walk_tree (&TI_ARGS (tinfo
),
3672 &find_parameter_packs_r
,
3678 /* Identify whether this is a parameter pack or not. */
3679 switch (TREE_CODE (t
))
3681 case TEMPLATE_PARM_INDEX
:
3682 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3683 parameter_pack_p
= true;
3686 case TEMPLATE_TYPE_PARM
:
3687 t
= TYPE_MAIN_VARIANT (t
);
3689 case TEMPLATE_TEMPLATE_PARM
:
3690 /* If the placeholder appears in the decl-specifier-seq of a function
3691 parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3692 is a pack expansion, the invented template parameter is a template
3694 if (ppd
->type_pack_expansion_p
&& is_auto (t
))
3695 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
3696 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3697 parameter_pack_p
= true;
3702 if (DECL_PACK_P (t
))
3704 /* We don't want to walk into the type of a PARM_DECL,
3705 because we don't want to see the type parameter pack. */
3707 parameter_pack_p
= true;
3712 if (DECL_PACK_P (t
))
3714 /* We don't want to walk into the type of a variadic capture proxy,
3715 because we don't want to see the type parameter pack. */
3717 parameter_pack_p
= true;
3719 else if (variable_template_specialization_p (t
))
3721 cp_walk_tree (&DECL_TI_ARGS (t
),
3722 find_parameter_packs_r
,
3729 if (builtin_pack_call_p (t
))
3730 parameter_pack_p
= true;
3734 parameter_pack_p
= true;
3737 /* Not a parameter pack. */
3741 if (parameter_pack_p
)
3743 /* Add this parameter pack to the list. */
3744 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3748 cp_walk_tree (&TYPE_CONTEXT (t
),
3749 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3751 /* This switch statement will return immediately if we don't find a
3753 switch (TREE_CODE (t
))
3755 case TEMPLATE_PARM_INDEX
:
3758 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3759 /* Check the template itself. */
3760 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3761 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3762 /* Check the template arguments. */
3763 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3768 case TEMPLATE_TYPE_PARM
:
3769 case TEMPLATE_TEMPLATE_PARM
:
3776 /* Ignore the declaration of a capture proxy for a parameter pack. */
3777 if (is_capture_proxy (DECL_EXPR_DECL (t
)))
3782 if (TYPE_PTRMEMFUNC_P (t
))
3788 if (TYPE_TEMPLATE_INFO (t
))
3789 cp_walk_tree (&TYPE_TI_ARGS (t
),
3790 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3796 if (!DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
3801 cp_walk_tree (&TREE_TYPE (t
),
3802 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3806 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3811 case TYPE_PACK_EXPANSION
:
3812 case EXPR_PACK_EXPANSION
:
3817 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3822 case IDENTIFIER_NODE
:
3823 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3830 /* Look at explicit captures. */
3831 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
);
3832 cap
; cap
= TREE_CHAIN (cap
))
3833 cp_walk_tree (&TREE_VALUE (cap
), &find_parameter_packs_r
, ppd
,
3835 /* Since we defer implicit capture, look in the parms and body. */
3836 tree fn
= lambda_function (t
);
3837 cp_walk_tree (&TREE_TYPE (fn
), &find_parameter_packs_r
, ppd
,
3839 cp_walk_tree (&DECL_SAVED_TREE (fn
), &find_parameter_packs_r
, ppd
,
3847 /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
3848 type_pack_expansion_p to false so that any placeholders
3849 within the expression don't get marked as parameter packs. */
3850 bool type_pack_expansion_p
= ppd
->type_pack_expansion_p
;
3851 ppd
->type_pack_expansion_p
= false;
3852 cp_walk_tree (&DECLTYPE_TYPE_EXPR (t
), &find_parameter_packs_r
,
3854 ppd
->type_pack_expansion_p
= type_pack_expansion_p
;
3860 cp_walk_tree (&IF_COND (t
), &find_parameter_packs_r
,
3862 cp_walk_tree (&THEN_CLAUSE (t
), &find_parameter_packs_r
,
3864 cp_walk_tree (&ELSE_CLAUSE (t
), &find_parameter_packs_r
,
3866 /* Don't walk into IF_STMT_EXTRA_ARGS. */
3877 /* Determines if the expression or type T uses any parameter packs. */
3879 uses_parameter_packs (tree t
)
3881 tree parameter_packs
= NULL_TREE
;
3882 struct find_parameter_pack_data ppd
;
3883 ppd
.parameter_packs
= ¶meter_packs
;
3884 ppd
.visited
= new hash_set
<tree
>;
3885 ppd
.type_pack_expansion_p
= false;
3886 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3888 return parameter_packs
!= NULL_TREE
;
3891 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3892 representation a base-class initializer into a parameter pack
3893 expansion. If all goes well, the resulting node will be an
3894 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3897 make_pack_expansion (tree arg
, tsubst_flags_t complain
)
3900 tree parameter_packs
= NULL_TREE
;
3901 bool for_types
= false;
3902 struct find_parameter_pack_data ppd
;
3904 if (!arg
|| arg
== error_mark_node
)
3907 if (TREE_CODE (arg
) == TREE_LIST
&& TREE_PURPOSE (arg
))
3909 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3910 class initializer. In this case, the TREE_PURPOSE will be a
3911 _TYPE node (representing the base class expansion we're
3912 initializing) and the TREE_VALUE will be a TREE_LIST
3913 containing the initialization arguments.
3915 The resulting expansion looks somewhat different from most
3916 expansions. Rather than returning just one _EXPANSION, we
3917 return a TREE_LIST whose TREE_PURPOSE is a
3918 TYPE_PACK_EXPANSION containing the bases that will be
3919 initialized. The TREE_VALUE will be identical to the
3920 original TREE_VALUE, which is a list of arguments that will
3921 be passed to each base. We do not introduce any new pack
3922 expansion nodes into the TREE_VALUE (although it is possible
3923 that some already exist), because the TREE_PURPOSE and
3924 TREE_VALUE all need to be expanded together with the same
3925 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3926 resulting TREE_PURPOSE will mention the parameter packs in
3927 both the bases and the arguments to the bases. */
3930 tree parameter_packs
= NULL_TREE
;
3932 /* Determine which parameter packs will be used by the base
3934 ppd
.visited
= new hash_set
<tree
>;
3935 ppd
.parameter_packs
= ¶meter_packs
;
3936 ppd
.type_pack_expansion_p
= false;
3937 gcc_assert (TYPE_P (TREE_PURPOSE (arg
)));
3938 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3941 if (parameter_packs
== NULL_TREE
)
3943 if (complain
& tf_error
)
3944 error ("base initializer expansion %qT contains no parameter packs",
3947 return error_mark_node
;
3950 if (TREE_VALUE (arg
) != void_type_node
)
3952 /* Collect the sets of parameter packs used in each of the
3953 initialization arguments. */
3954 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3956 /* Determine which parameter packs will be expanded in this
3958 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3965 /* Create the pack expansion type for the base type. */
3966 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3967 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3968 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3969 PACK_EXPANSION_LOCAL_P (purpose
) = at_function_scope_p ();
3971 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3972 they will rarely be compared to anything. */
3973 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3975 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3978 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3981 /* Build the PACK_EXPANSION_* node. */
3983 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3984 : make_node (EXPR_PACK_EXPANSION
);
3985 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3986 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3988 /* Propagate type and const-expression information. */
3989 TREE_TYPE (result
) = TREE_TYPE (arg
);
3990 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3991 /* Mark this read now, since the expansion might be length 0. */
3992 mark_exp_read (arg
);
3995 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3996 they will rarely be compared to anything. */
3997 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3999 /* Determine which parameter packs will be expanded. */
4000 ppd
.parameter_packs
= ¶meter_packs
;
4001 ppd
.visited
= new hash_set
<tree
>;
4002 ppd
.type_pack_expansion_p
= TYPE_P (arg
);
4003 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
4006 /* Make sure we found some parameter packs. */
4007 if (parameter_packs
== NULL_TREE
)
4009 if (complain
& tf_error
)
4012 error ("expansion pattern %qT contains no parameter packs", arg
);
4014 error ("expansion pattern %qE contains no parameter packs", arg
);
4016 return error_mark_node
;
4018 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
4020 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
4025 /* Checks T for any "bare" parameter packs, which have not yet been
4026 expanded, and issues an error if any are found. This operation can
4027 only be done on full expressions or types (e.g., an expression
4028 statement, "if" condition, etc.), because we could have expressions like:
4030 foo(f(g(h(args)))...)
4032 where "args" is a parameter pack. check_for_bare_parameter_packs
4033 should not be called for the subexpressions args, h(args),
4034 g(h(args)), or f(g(h(args))), because we would produce erroneous
4037 Returns TRUE and emits an error if there were bare parameter packs,
4038 returns FALSE otherwise. */
4040 check_for_bare_parameter_packs (tree t
, location_t loc
/* = UNKNOWN_LOCATION */)
4042 tree parameter_packs
= NULL_TREE
;
4043 struct find_parameter_pack_data ppd
;
4045 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
4048 /* A lambda might use a parameter pack from the containing context. */
4049 if (current_class_type
&& LAMBDA_TYPE_P (current_class_type
)
4050 && CLASSTYPE_TEMPLATE_INFO (current_class_type
))
4053 if (TREE_CODE (t
) == TYPE_DECL
)
4056 ppd
.parameter_packs
= ¶meter_packs
;
4057 ppd
.visited
= new hash_set
<tree
>;
4058 ppd
.type_pack_expansion_p
= false;
4059 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
4062 if (parameter_packs
)
4064 if (loc
== UNKNOWN_LOCATION
)
4065 loc
= cp_expr_loc_or_loc (t
, input_location
);
4066 error_at (loc
, "parameter packs not expanded with %<...%>:");
4067 while (parameter_packs
)
4069 tree pack
= TREE_VALUE (parameter_packs
);
4070 tree name
= NULL_TREE
;
4072 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
4073 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
4074 name
= TYPE_NAME (pack
);
4075 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
4076 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
4077 else if (TREE_CODE (pack
) == CALL_EXPR
)
4078 name
= DECL_NAME (CALL_EXPR_FN (pack
));
4080 name
= DECL_NAME (pack
);
4083 inform (loc
, " %qD", name
);
4085 inform (loc
, " <anonymous>");
4087 parameter_packs
= TREE_CHAIN (parameter_packs
);
4096 /* Expand any parameter packs that occur in the template arguments in
4099 expand_template_argument_pack (tree args
)
4101 if (args
== error_mark_node
)
4102 return error_mark_node
;
4104 tree result_args
= NULL_TREE
;
4105 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
4106 int num_result_args
= -1;
4107 int non_default_args_count
= -1;
4109 /* First, determine if we need to expand anything, and the number of
4110 slots we'll need. */
4111 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
4113 tree arg
= TREE_VEC_ELT (args
, in_arg
);
4114 if (arg
== NULL_TREE
)
4116 if (ARGUMENT_PACK_P (arg
))
4118 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
4119 if (num_result_args
< 0)
4120 num_result_args
= in_arg
+ num_packed
;
4122 num_result_args
+= num_packed
;
4126 if (num_result_args
>= 0)
4131 /* If no expansion is necessary, we're done. */
4132 if (num_result_args
< 0)
4135 /* Expand arguments. */
4136 result_args
= make_tree_vec (num_result_args
);
4137 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
4138 non_default_args_count
=
4139 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
4140 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
4142 tree arg
= TREE_VEC_ELT (args
, in_arg
);
4143 if (ARGUMENT_PACK_P (arg
))
4145 tree packed
= ARGUMENT_PACK_ARGS (arg
);
4146 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
4147 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
4148 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
4149 if (non_default_args_count
> 0)
4150 non_default_args_count
+= num_packed
- 1;
4154 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
4158 if (non_default_args_count
>= 0)
4159 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
4163 /* Checks if DECL shadows a template parameter.
4165 [temp.local]: A template-parameter shall not be redeclared within its
4166 scope (including nested scopes).
4168 Emits an error and returns TRUE if the DECL shadows a parameter,
4169 returns FALSE otherwise. */
4172 check_template_shadow (tree decl
)
4176 /* If we're not in a template, we can't possibly shadow a template
4178 if (!current_template_parms
)
4181 /* Figure out what we're shadowing. */
4182 decl
= OVL_FIRST (decl
);
4183 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
4185 /* If there's no previous binding for this name, we're not shadowing
4186 anything, let alone a template parameter. */
4190 /* If we're not shadowing a template parameter, we're done. Note
4191 that OLDDECL might be an OVERLOAD (or perhaps even an
4192 ERROR_MARK), so we can't just blithely assume it to be a _DECL
4194 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
4197 /* We check for decl != olddecl to avoid bogus errors for using a
4198 name inside a class. We check TPFI to avoid duplicate errors for
4199 inline member templates. */
4201 || (DECL_TEMPLATE_PARM_P (decl
)
4202 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
4205 /* Don't complain about the injected class name, as we've already
4206 complained about the class itself. */
4207 if (DECL_SELF_REFERENCE_P (decl
))
4210 if (DECL_TEMPLATE_PARM_P (decl
))
4211 error ("declaration of template parameter %q+D shadows "
4212 "template parameter", decl
);
4214 error ("declaration of %q+#D shadows template parameter", decl
);
4215 inform (DECL_SOURCE_LOCATION (olddecl
),
4216 "template parameter %qD declared here", olddecl
);
4220 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
4221 ORIG_LEVEL, DECL, and TYPE. */
4224 build_template_parm_index (int index
,
4230 tree t
= make_node (TEMPLATE_PARM_INDEX
);
4231 TEMPLATE_PARM_IDX (t
) = index
;
4232 TEMPLATE_PARM_LEVEL (t
) = level
;
4233 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
4234 TEMPLATE_PARM_DECL (t
) = decl
;
4235 TREE_TYPE (t
) = type
;
4236 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
4237 TREE_READONLY (t
) = TREE_READONLY (decl
);
4242 /* Find the canonical type parameter for the given template type
4243 parameter. Returns the canonical type parameter, which may be TYPE
4244 if no such parameter existed. */
4247 canonical_type_parameter (tree type
)
4250 int idx
= TEMPLATE_TYPE_IDX (type
);
4251 if (!canonical_template_parms
)
4252 vec_alloc (canonical_template_parms
, idx
+ 1);
4254 if (canonical_template_parms
->length () <= (unsigned) idx
)
4255 vec_safe_grow_cleared (canonical_template_parms
, idx
+ 1);
4257 list
= (*canonical_template_parms
)[idx
];
4258 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
4259 list
= TREE_CHAIN (list
);
4262 return TREE_VALUE (list
);
4265 (*canonical_template_parms
)[idx
]
4266 = tree_cons (NULL_TREE
, type
, (*canonical_template_parms
)[idx
]);
4271 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
4272 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
4273 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
4274 new one is created. */
4277 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
4278 tsubst_flags_t complain
)
4280 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
4281 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
4282 != TEMPLATE_PARM_LEVEL (index
) - levels
)
4283 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
4285 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
4288 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
4289 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
4290 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
4291 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
4292 DECL_ARTIFICIAL (decl
) = 1;
4293 SET_DECL_TEMPLATE_PARM_P (decl
);
4295 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
4296 TEMPLATE_PARM_LEVEL (index
) - levels
,
4297 TEMPLATE_PARM_ORIG_LEVEL (index
),
4299 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
4300 TEMPLATE_PARM_PARAMETER_PACK (t
)
4301 = TEMPLATE_PARM_PARAMETER_PACK (index
);
4303 /* Template template parameters need this. */
4304 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4306 DECL_TEMPLATE_RESULT (decl
)
4307 = build_decl (DECL_SOURCE_LOCATION (decl
),
4308 TYPE_DECL
, DECL_NAME (decl
), type
);
4309 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (decl
)) = true;
4310 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
4311 (DECL_TEMPLATE_PARMS (orig_decl
), args
, complain
);
4315 return TEMPLATE_PARM_DESCENDANTS (index
);
4318 /* Process information from new template parameter PARM and append it
4319 to the LIST being built. This new parameter is a non-type
4320 parameter iff IS_NON_TYPE is true. This new parameter is a
4321 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4325 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
4326 bool is_non_type
, bool is_parameter_pack
)
4331 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
4332 tree defval
= TREE_PURPOSE (parm
);
4333 tree constr
= TREE_TYPE (parm
);
4337 tree p
= tree_last (list
);
4339 if (p
&& TREE_VALUE (p
) != error_mark_node
)
4342 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
4343 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
4345 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
4353 parm
= TREE_VALUE (parm
);
4355 SET_DECL_TEMPLATE_PARM_P (parm
);
4357 if (TREE_TYPE (parm
) != error_mark_node
)
4361 The top-level cv-qualifiers on the template-parameter are
4362 ignored when determining its type. */
4363 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
4364 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
4365 TREE_TYPE (parm
) = error_mark_node
;
4366 else if (uses_parameter_packs (TREE_TYPE (parm
))
4367 && !is_parameter_pack
4368 /* If we're in a nested template parameter list, the template
4369 template parameter could be a parameter pack. */
4370 && processing_template_parmlist
== 1)
4372 /* This template parameter is not a parameter pack, but it
4373 should be. Complain about "bare" parameter packs. */
4374 check_for_bare_parameter_packs (TREE_TYPE (parm
));
4376 /* Recover by calling this a parameter pack. */
4377 is_parameter_pack
= true;
4381 /* A template parameter is not modifiable. */
4382 TREE_CONSTANT (parm
) = 1;
4383 TREE_READONLY (parm
) = 1;
4384 decl
= build_decl (parm_loc
,
4385 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
4386 TREE_CONSTANT (decl
) = 1;
4387 TREE_READONLY (decl
) = 1;
4388 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
4389 = build_template_parm_index (idx
, processing_template_decl
,
4390 processing_template_decl
,
4391 decl
, TREE_TYPE (parm
));
4393 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
4394 = is_parameter_pack
;
4399 parm
= TREE_VALUE (TREE_VALUE (parm
));
4401 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
4403 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
4404 /* This is for distinguishing between real templates and template
4405 template parameters */
4406 TREE_TYPE (parm
) = t
;
4407 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
4412 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
4413 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4414 decl
= build_decl (parm_loc
,
4415 TYPE_DECL
, parm
, t
);
4418 TYPE_NAME (t
) = decl
;
4419 TYPE_STUB_DECL (t
) = decl
;
4421 TEMPLATE_TYPE_PARM_INDEX (t
)
4422 = build_template_parm_index (idx
, processing_template_decl
,
4423 processing_template_decl
,
4424 decl
, TREE_TYPE (parm
));
4425 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
4426 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
4428 DECL_ARTIFICIAL (decl
) = 1;
4429 SET_DECL_TEMPLATE_PARM_P (decl
);
4431 /* Build requirements for the type/template parameter.
4432 This must be done after SET_DECL_TEMPLATE_PARM_P or
4433 process_template_parm could fail. */
4434 tree reqs
= finish_shorthand_constraint (parm
, constr
);
4436 decl
= pushdecl (decl
);
4440 /* Build the parameter node linking the parameter declaration,
4441 its default argument (if any), and its constraints (if any). */
4442 parm
= build_tree_list (defval
, parm
);
4443 TEMPLATE_PARM_CONSTRAINTS (parm
) = reqs
;
4445 return chainon (list
, parm
);
4448 /* The end of a template parameter list has been reached. Process the
4449 tree list into a parameter vector, converting each parameter into a more
4450 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4454 end_template_parm_list (tree parms
)
4458 tree saved_parmlist
= make_tree_vec (list_length (parms
));
4460 /* Pop the dummy parameter level and add the real one. */
4461 current_template_parms
= TREE_CHAIN (current_template_parms
);
4463 current_template_parms
4464 = tree_cons (size_int (processing_template_decl
),
4465 saved_parmlist
, current_template_parms
);
4467 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
4469 next
= TREE_CHAIN (parm
);
4470 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
4471 TREE_CHAIN (parm
) = NULL_TREE
;
4474 --processing_template_parmlist
;
4476 return saved_parmlist
;
4479 // Explicitly indicate the end of the template parameter list. We assume
4480 // that the current template parameters have been constructed and/or
4481 // managed explicitly, as when creating new template template parameters
4482 // from a shorthand constraint.
4484 end_template_parm_list ()
4486 --processing_template_parmlist
;
4489 /* end_template_decl is called after a template declaration is seen. */
4492 end_template_decl (void)
4494 reset_specialization ();
4496 if (! processing_template_decl
)
4499 /* This matches the pushlevel in begin_template_parm_list. */
4502 --processing_template_decl
;
4503 current_template_parms
= TREE_CHAIN (current_template_parms
);
4506 /* Takes a TREE_LIST representing a template parameter and convert it
4507 into an argument suitable to be passed to the type substitution
4508 functions. Note that If the TREE_LIST contains an error_mark
4509 node, the returned argument is error_mark_node. */
4512 template_parm_to_arg (tree t
)
4516 || TREE_CODE (t
) != TREE_LIST
)
4519 if (error_operand_p (TREE_VALUE (t
)))
4520 return error_mark_node
;
4524 if (TREE_CODE (t
) == TYPE_DECL
4525 || TREE_CODE (t
) == TEMPLATE_DECL
)
4529 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
4531 /* Turn this argument into a TYPE_ARGUMENT_PACK
4532 with a single element, which expands T. */
4533 tree vec
= make_tree_vec (1);
4535 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4537 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4539 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
4540 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4545 t
= DECL_INITIAL (t
);
4547 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
4549 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4550 with a single element, which expands T. */
4551 tree vec
= make_tree_vec (1);
4553 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4555 t
= convert_from_reference (t
);
4556 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4558 t
= make_node (NONTYPE_ARGUMENT_PACK
);
4559 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4562 t
= convert_from_reference (t
);
4567 /* Given a single level of template parameters (a TREE_VEC), return it
4568 as a set of template arguments. */
4571 template_parms_level_to_args (tree parms
)
4573 tree a
= copy_node (parms
);
4574 TREE_TYPE (a
) = NULL_TREE
;
4575 for (int i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
4576 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
4579 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
4584 /* Given a set of template parameters, return them as a set of template
4585 arguments. The template parameters are represented as a TREE_VEC, in
4586 the form documented in cp-tree.h for template arguments. */
4589 template_parms_to_args (tree parms
)
4592 tree args
= NULL_TREE
;
4593 int length
= TMPL_PARMS_DEPTH (parms
);
4596 /* If there is only one level of template parameters, we do not
4597 create a TREE_VEC of TREE_VECs. Instead, we return a single
4598 TREE_VEC containing the arguments. */
4600 args
= make_tree_vec (length
);
4602 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
4604 tree a
= template_parms_level_to_args (TREE_VALUE (header
));
4607 TREE_VEC_ELT (args
, --l
) = a
;
4615 /* Within the declaration of a template, return the currently active
4616 template parameters as an argument TREE_VEC. */
4619 current_template_args (void)
4621 return template_parms_to_args (current_template_parms
);
4624 /* Update the declared TYPE by doing any lookups which were thought to be
4625 dependent, but are not now that we know the SCOPE of the declarator. */
4628 maybe_update_decl_type (tree orig_type
, tree scope
)
4630 tree type
= orig_type
;
4632 if (type
== NULL_TREE
)
4635 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4636 type
= TREE_TYPE (type
);
4638 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
4639 && dependent_type_p (type
)
4640 /* Don't bother building up the args in this case. */
4641 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
4643 /* tsubst in the args corresponding to the template parameters,
4644 including auto if present. Most things will be unchanged, but
4645 make_typename_type and tsubst_qualified_id will resolve
4646 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4647 tree args
= current_template_args ();
4648 tree auto_node
= type_uses_auto (type
);
4652 tree auto_vec
= make_tree_vec (1);
4653 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4654 args
= add_to_template_args (args
, auto_vec
);
4656 pushed
= push_scope (scope
);
4657 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4662 if (type
== error_mark_node
)
4665 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4667 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4670 type
= TYPE_NAME (type
);
4675 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4676 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4677 the new template is a member template. */
4680 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4682 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4683 SET_DECL_LANGUAGE (tmpl
, DECL_LANGUAGE (decl
));
4684 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4685 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4686 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4687 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4692 struct template_parm_data
4694 /* The level of the template parameters we are currently
4698 /* The index of the specialization argument we are currently
4702 /* An array whose size is the number of template parameters. The
4703 elements are nonzero if the parameter has been used in any one
4704 of the arguments processed so far. */
4707 /* An array whose size is the number of template arguments. The
4708 elements are nonzero if the argument makes use of template
4709 parameters of this level. */
4710 int* arg_uses_template_parms
;
4713 /* Subroutine of push_template_decl used to see if each template
4714 parameter in a partial specialization is used in the explicit
4715 argument list. If T is of the LEVEL given in DATA (which is
4716 treated as a template_parm_data*), then DATA->PARMS is marked
4720 mark_template_parm (tree t
, void* data
)
4724 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4726 template_parm_level_and_index (t
, &level
, &idx
);
4728 if (level
== tpd
->level
)
4730 tpd
->parms
[idx
] = 1;
4731 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4734 /* In C++17 the type of a non-type argument is a deduced context. */
4735 if (cxx_dialect
>= cxx17
4736 && TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4737 for_each_template_parm (TREE_TYPE (t
),
4738 &mark_template_parm
,
4741 /*include_nondeduced_p=*/false);
4743 /* Return zero so that for_each_template_parm will continue the
4744 traversal of the tree; we want to mark *every* template parm. */
4748 /* Process the partial specialization DECL. */
4751 process_partial_specialization (tree decl
)
4753 tree type
= TREE_TYPE (decl
);
4754 tree tinfo
= get_template_info (decl
);
4755 tree maintmpl
= TI_TEMPLATE (tinfo
);
4756 tree specargs
= TI_ARGS (tinfo
);
4757 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4758 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4761 int nargs
= TREE_VEC_LENGTH (inner_args
);
4764 bool did_error_intro
= false;
4765 struct template_parm_data tpd
;
4766 struct template_parm_data tpd2
;
4768 gcc_assert (current_template_parms
);
4770 /* A concept cannot be specialized. */
4771 if (flag_concepts
&& variable_concept_p (maintmpl
))
4773 error ("specialization of variable concept %q#D", maintmpl
);
4774 return error_mark_node
;
4777 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4778 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4780 /* We check that each of the template parameters given in the
4781 partial specialization is used in the argument list to the
4782 specialization. For example:
4784 template <class T> struct S;
4785 template <class T> struct S<T*>;
4787 The second declaration is OK because `T*' uses the template
4788 parameter T, whereas
4790 template <class T> struct S<int>;
4792 is no good. Even trickier is:
4803 The S2<T> declaration is actually invalid; it is a
4804 full-specialization. Of course,
4807 struct S2<T (*)(U)>;
4809 or some such would have been OK. */
4810 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4811 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4812 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4814 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4815 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4816 for (i
= 0; i
< nargs
; ++i
)
4818 tpd
.current_arg
= i
;
4819 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4820 &mark_template_parm
,
4823 /*include_nondeduced_p=*/false);
4825 for (i
= 0; i
< ntparms
; ++i
)
4826 if (tpd
.parms
[i
] == 0)
4828 /* One of the template parms was not used in a deduced context in the
4830 if (!did_error_intro
)
4832 error ("template parameters not deducible in "
4833 "partial specialization:");
4834 did_error_intro
= true;
4837 inform (input_location
, " %qD",
4838 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4841 if (did_error_intro
)
4842 return error_mark_node
;
4844 /* [temp.class.spec]
4846 The argument list of the specialization shall not be identical to
4847 the implicit argument list of the primary template. */
4849 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl
)));
4850 if (comp_template_args (inner_args
, INNERMOST_TEMPLATE_ARGS (main_args
))
4852 || !strictly_subsumes (current_template_constraints (),
4853 get_constraints (maintmpl
))))
4856 error ("partial specialization %q+D does not specialize "
4857 "any template arguments; to define the primary template, "
4858 "remove the template argument list", decl
);
4860 error ("partial specialization %q+D does not specialize any "
4861 "template arguments and is not more constrained than "
4862 "the primary template; to define the primary template, "
4863 "remove the template argument list", decl
);
4864 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4867 /* A partial specialization that replaces multiple parameters of the
4868 primary template with a pack expansion is less specialized for those
4870 if (nargs
< DECL_NTPARMS (maintmpl
))
4872 error ("partial specialization is not more specialized than the "
4873 "primary template because it replaces multiple parameters "
4874 "with a pack expansion");
4875 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4876 /* Avoid crash in process_partial_specialization. */
4880 /* If we aren't in a dependent class, we can actually try deduction. */
4881 else if (tpd
.level
== 1
4882 /* FIXME we should be able to handle a partial specialization of a
4883 partial instantiation, but currently we can't (c++/41727). */
4884 && TMPL_ARGS_DEPTH (specargs
) == 1
4885 && !get_partial_spec_bindings (maintmpl
, maintmpl
, specargs
))
4887 auto_diagnostic_group d
;
4888 if (permerror (input_location
, "partial specialization %qD is not "
4889 "more specialized than", decl
))
4890 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template %qD",
4894 /* [temp.class.spec]
4896 A partially specialized non-type argument expression shall not
4897 involve template parameters of the partial specialization except
4898 when the argument expression is a simple identifier.
4900 The type of a template parameter corresponding to a specialized
4901 non-type argument shall not be dependent on a parameter of the
4904 Also, we verify that pack expansions only occur at the
4905 end of the argument list. */
4906 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4908 for (i
= 0; i
< nargs
; ++i
)
4910 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4911 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4912 tree packed_args
= NULL_TREE
;
4915 if (ARGUMENT_PACK_P (arg
))
4917 /* Extract the arguments from the argument pack. We'll be
4918 iterating over these in the following loop. */
4919 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4920 len
= TREE_VEC_LENGTH (packed_args
);
4923 for (j
= 0; j
< len
; j
++)
4926 /* Get the Jth argument in the parameter pack. */
4927 arg
= TREE_VEC_ELT (packed_args
, j
);
4929 if (PACK_EXPANSION_P (arg
))
4931 /* Pack expansions must come at the end of the
4933 if ((packed_args
&& j
< len
- 1)
4934 || (!packed_args
&& i
< nargs
- 1))
4936 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4937 error ("parameter pack argument %qE must be at the "
4938 "end of the template argument list", arg
);
4940 error ("parameter pack argument %qT must be at the "
4941 "end of the template argument list", arg
);
4945 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4946 /* We only care about the pattern. */
4947 arg
= PACK_EXPANSION_PATTERN (arg
);
4949 if (/* These first two lines are the `non-type' bit. */
4951 && TREE_CODE (arg
) != TEMPLATE_DECL
4952 /* This next two lines are the `argument expression is not just a
4953 simple identifier' condition and also the `specialized
4954 non-type argument' bit. */
4955 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4956 && !(REFERENCE_REF_P (arg
)
4957 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4959 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4960 || (packed_args
&& uses_template_parms (arg
)))
4961 error ("template argument %qE involves template parameter(s)",
4965 /* Look at the corresponding template parameter,
4966 marking which template parameters its type depends
4968 tree type
= TREE_TYPE (parm
);
4972 /* We haven't yet initialized TPD2. Do so now. */
4973 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4974 /* The number of parameters here is the number in the
4975 main template, which, as checked in the assertion
4977 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4979 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4982 /* Mark the template parameters. But this time, we're
4983 looking for the template parameters of the main
4984 template, not in the specialization. */
4985 tpd2
.current_arg
= i
;
4986 tpd2
.arg_uses_template_parms
[i
] = 0;
4987 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4988 for_each_template_parm (type
,
4989 &mark_template_parm
,
4992 /*include_nondeduced_p=*/false);
4994 if (tpd2
.arg_uses_template_parms
[i
])
4996 /* The type depended on some template parameters.
4997 If they are fully specialized in the
4998 specialization, that's OK. */
5001 for (j
= 0; j
< nargs
; ++j
)
5002 if (tpd2
.parms
[j
] != 0
5003 && tpd
.arg_uses_template_parms
[j
])
5006 error_n (input_location
, count
,
5007 "type %qT of template argument %qE depends "
5008 "on a template parameter",
5009 "type %qT of template argument %qE depends "
5010 "on template parameters",
5019 /* We should only get here once. */
5020 if (TREE_CODE (decl
) == TYPE_DECL
)
5021 gcc_assert (!COMPLETE_TYPE_P (type
));
5023 // Build the template decl.
5024 tree tmpl
= build_template_decl (decl
, current_template_parms
,
5025 DECL_MEMBER_TEMPLATE_P (maintmpl
));
5026 TREE_TYPE (tmpl
) = type
;
5027 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5028 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5029 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
5030 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
5032 /* Give template template parms a DECL_CONTEXT of the template
5033 for which they are a parameter. */
5034 for (i
= 0; i
< ntparms
; ++i
)
5036 tree parm
= TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
));
5037 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5038 DECL_CONTEXT (parm
) = tmpl
;
5042 /* We didn't register this in check_explicit_specialization so we could
5043 wait until the constraints were set. */
5044 decl
= register_specialization (decl
, maintmpl
, specargs
, false, 0);
5046 associate_classtype_constraints (type
);
5048 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
5049 = tree_cons (specargs
, tmpl
,
5050 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
5051 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
5053 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
5054 inst
= TREE_CHAIN (inst
))
5056 tree instance
= TREE_VALUE (inst
);
5057 if (TYPE_P (instance
)
5058 ? (COMPLETE_TYPE_P (instance
)
5059 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance
))
5060 : DECL_TEMPLATE_INSTANTIATION (instance
))
5062 tree spec
= most_specialized_partial_spec (instance
, tf_none
);
5063 tree inst_decl
= (DECL_P (instance
)
5064 ? instance
: TYPE_NAME (instance
));
5067 else if (spec
== error_mark_node
)
5068 permerror (input_location
,
5069 "declaration of %qD ambiguates earlier template "
5070 "instantiation for %qD", decl
, inst_decl
);
5071 else if (TREE_VALUE (spec
) == tmpl
)
5072 permerror (input_location
,
5073 "partial specialization of %qD after instantiation "
5074 "of %qD", decl
, inst_decl
);
5081 /* PARM is a template parameter of some form; return the corresponding
5082 TEMPLATE_PARM_INDEX. */
5085 get_template_parm_index (tree parm
)
5087 if (TREE_CODE (parm
) == PARM_DECL
5088 || TREE_CODE (parm
) == CONST_DECL
)
5089 parm
= DECL_INITIAL (parm
);
5090 else if (TREE_CODE (parm
) == TYPE_DECL
5091 || TREE_CODE (parm
) == TEMPLATE_DECL
)
5092 parm
= TREE_TYPE (parm
);
5093 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
5094 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
5095 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
5096 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
5097 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
5101 /* Subroutine of fixed_parameter_pack_p below. Look for any template
5102 parameter packs used by the template parameter PARM. */
5105 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
5107 /* A type parm can't refer to another parm. */
5108 if (TREE_CODE (parm
) == TYPE_DECL
|| parm
== error_mark_node
)
5110 else if (TREE_CODE (parm
) == PARM_DECL
)
5112 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
5117 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
5119 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
5120 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
5122 tree p
= TREE_VALUE (TREE_VEC_ELT (vec
, i
));
5123 if (template_parameter_pack_p (p
))
5124 /* Any packs in the type are expanded by this parameter. */;
5126 fixed_parameter_pack_p_1 (p
, ppd
);
5130 /* PARM is a template parameter pack. Return any parameter packs used in
5131 its type or the type of any of its template parameters. If there are
5132 any such packs, it will be instantiated into a fixed template parameter
5133 list by partial instantiation rather than be fully deduced. */
5136 fixed_parameter_pack_p (tree parm
)
5138 /* This can only be true in a member template. */
5139 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
5141 /* This can only be true for a parameter pack. */
5142 if (!template_parameter_pack_p (parm
))
5144 /* A type parm can't refer to another parm. */
5145 if (TREE_CODE (parm
) == TYPE_DECL
)
5148 tree parameter_packs
= NULL_TREE
;
5149 struct find_parameter_pack_data ppd
;
5150 ppd
.parameter_packs
= ¶meter_packs
;
5151 ppd
.visited
= new hash_set
<tree
>;
5152 ppd
.type_pack_expansion_p
= false;
5154 fixed_parameter_pack_p_1 (parm
, &ppd
);
5157 return parameter_packs
;
5160 /* Check that a template declaration's use of default arguments and
5161 parameter packs is not invalid. Here, PARMS are the template
5162 parameters. IS_PRIMARY is true if DECL is the thing declared by
5163 a primary template. IS_PARTIAL is true if DECL is a partial
5166 IS_FRIEND_DECL is nonzero if DECL is either a non-defining friend
5167 function template declaration or a friend class template
5168 declaration. In the function case, 1 indicates a declaration, 2
5169 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
5170 emitted for extraneous default arguments.
5172 Returns TRUE if there were no errors found, FALSE otherwise. */
5175 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
5176 bool is_partial
, int is_friend_decl
)
5179 int last_level_to_check
;
5181 bool no_errors
= true;
5185 A default template-argument shall not be specified in a
5186 function template declaration or a function template definition, nor
5187 in the template-parameter-list of the definition of a member of a
5190 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
5191 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
5192 /* You can't have a function template declaration in a local
5193 scope, nor you can you define a member of a class template in a
5197 if ((TREE_CODE (decl
) == TYPE_DECL
5199 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5200 || (TREE_CODE (decl
) == FUNCTION_DECL
5201 && LAMBDA_FUNCTION_P (decl
)))
5202 /* A lambda doesn't have an explicit declaration; don't complain
5203 about the parms of the enclosing class. */
5206 if (current_class_type
5207 && !TYPE_BEING_DEFINED (current_class_type
)
5208 && DECL_LANG_SPECIFIC (decl
)
5209 && DECL_DECLARES_FUNCTION_P (decl
)
5210 /* If this is either a friend defined in the scope of the class
5211 or a member function. */
5212 && (DECL_FUNCTION_MEMBER_P (decl
)
5213 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
5214 : DECL_FRIEND_CONTEXT (decl
)
5215 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
5217 /* And, if it was a member function, it really was defined in
5218 the scope of the class. */
5219 && (!DECL_FUNCTION_MEMBER_P (decl
)
5220 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
5221 /* We already checked these parameters when the template was
5222 declared, so there's no need to do it again now. This function
5223 was defined in class scope, but we're processing its body now
5224 that the class is complete. */
5227 /* Core issue 226 (C++0x only): the following only applies to class
5230 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
5234 If a template-parameter has a default template-argument, all
5235 subsequent template-parameters shall have a default
5236 template-argument supplied. */
5237 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
5239 tree inner_parms
= TREE_VALUE (parm_level
);
5240 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
5241 int seen_def_arg_p
= 0;
5244 for (i
= 0; i
< ntparms
; ++i
)
5246 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
5248 if (parm
== error_mark_node
)
5251 if (TREE_PURPOSE (parm
))
5253 else if (seen_def_arg_p
5254 && !template_parameter_pack_p (TREE_VALUE (parm
)))
5256 error ("no default argument for %qD", TREE_VALUE (parm
));
5257 /* For better subsequent error-recovery, we indicate that
5258 there should have been a default argument. */
5259 TREE_PURPOSE (parm
) = error_mark_node
;
5262 else if (!is_partial
5264 /* Don't complain about an enclosing partial
5266 && parm_level
== parms
5267 && TREE_CODE (decl
) == TYPE_DECL
5269 && template_parameter_pack_p (TREE_VALUE (parm
))
5270 /* A fixed parameter pack will be partially
5271 instantiated into a fixed length list. */
5272 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
5274 /* A primary class template can only have one
5275 parameter pack, at the end of the template
5278 error ("parameter pack %q+D must be at the end of the"
5279 " template parameter list", TREE_VALUE (parm
));
5281 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
5289 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
5293 /* For an ordinary class template, default template arguments are
5294 allowed at the innermost level, e.g.:
5295 template <class T = int>
5297 but, in a partial specialization, they're not allowed even
5298 there, as we have in [temp.class.spec]:
5300 The template parameter list of a specialization shall not
5301 contain default template argument values.
5303 So, for a partial specialization, or for a function template
5304 (in C++98/C++03), we look at all of them. */
5307 /* But, for a primary class template that is not a partial
5308 specialization we look at all template parameters except the
5310 parms
= TREE_CHAIN (parms
);
5312 /* Figure out what error message to issue. */
5313 if (is_friend_decl
== 2)
5314 msg
= G_("default template arguments may not be used in function template "
5315 "friend re-declaration");
5316 else if (is_friend_decl
)
5317 msg
= G_("default template arguments may not be used in template "
5318 "friend declarations");
5319 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
5320 msg
= G_("default template arguments may not be used in function templates "
5321 "without %<-std=c++11%> or %<-std=gnu++11%>");
5322 else if (is_partial
)
5323 msg
= G_("default template arguments may not be used in "
5324 "partial specializations");
5325 else if (current_class_type
&& CLASSTYPE_IS_TEMPLATE (current_class_type
))
5326 msg
= G_("default argument for template parameter for class enclosing %qD");
5328 /* Per [temp.param]/9, "A default template-argument shall not be
5329 specified in the template-parameter-lists of the definition of
5330 a member of a class template that appears outside of the member's
5331 class.", thus if we aren't handling a member of a class template
5332 there is no need to examine the parameters. */
5335 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
5336 /* If we're inside a class definition, there's no need to
5337 examine the parameters to the class itself. On the one
5338 hand, they will be checked when the class is defined, and,
5339 on the other, default arguments are valid in things like:
5340 template <class T = double>
5341 struct S { template <class U> void f(U); };
5342 Here the default argument for `S' has no bearing on the
5343 declaration of `f'. */
5344 last_level_to_check
= template_class_depth (current_class_type
) + 1;
5346 /* Check everything. */
5347 last_level_to_check
= 0;
5349 for (parm_level
= parms
;
5350 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
5351 parm_level
= TREE_CHAIN (parm_level
))
5353 tree inner_parms
= TREE_VALUE (parm_level
);
5357 ntparms
= TREE_VEC_LENGTH (inner_parms
);
5358 for (i
= 0; i
< ntparms
; ++i
)
5360 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
5363 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
5368 if (is_friend_decl
== 2)
5375 /* Clear out the default argument so that we are not
5377 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
5381 /* At this point, if we're still interested in issuing messages,
5382 they must apply to classes surrounding the object declared. */
5384 msg
= G_("default argument for template parameter for class "
5391 /* Worker for push_template_decl_real, called via
5392 for_each_template_parm. DATA is really an int, indicating the
5393 level of the parameters we are interested in. If T is a template
5394 parameter of that level, return nonzero. */
5397 template_parm_this_level_p (tree t
, void* data
)
5399 int this_level
= *(int *)data
;
5402 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5403 level
= TEMPLATE_PARM_LEVEL (t
);
5405 level
= TEMPLATE_TYPE_LEVEL (t
);
5406 return level
== this_level
;
5409 /* Worker for uses_outer_template_parms, called via for_each_template_parm.
5410 DATA is really an int, indicating the innermost outer level of parameters.
5411 If T is a template parameter of that level or further out, return
5415 template_parm_outer_level (tree t
, void *data
)
5417 int this_level
= *(int *)data
;
5420 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5421 level
= TEMPLATE_PARM_LEVEL (t
);
5423 level
= TEMPLATE_TYPE_LEVEL (t
);
5424 return level
<= this_level
;
5427 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5428 parameters given by current_template_args, or reuses a
5429 previously existing one, if appropriate. Returns the DECL, or an
5430 equivalent one, if it is replaced via a call to duplicate_decls.
5432 If IS_FRIEND is true, DECL is a friend declaration. */
5435 push_template_decl_real (tree decl
, bool is_friend
)
5443 int new_template_p
= 0;
5444 /* True if the template is a member template, in the sense of
5446 bool member_template_p
= false;
5448 if (decl
== error_mark_node
|| !current_template_parms
)
5449 return error_mark_node
;
5451 /* See if this is a partial specialization. */
5452 is_partial
= ((DECL_IMPLICIT_TYPEDEF_P (decl
)
5453 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
5454 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
5456 && DECL_LANG_SPECIFIC (decl
)
5457 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5458 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
))));
5460 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
5464 /* For a friend, we want the context of the friend, not
5465 the type of which it is a friend. */
5466 ctx
= CP_DECL_CONTEXT (decl
);
5467 else if (CP_DECL_CONTEXT (decl
)
5468 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
5469 /* In the case of a virtual function, we want the class in which
5471 ctx
= CP_DECL_CONTEXT (decl
);
5473 /* Otherwise, if we're currently defining some class, the DECL
5474 is assumed to be a member of the class. */
5475 ctx
= current_scope ();
5477 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5480 if (!DECL_CONTEXT (decl
))
5481 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
5483 /* See if this is a primary template. */
5484 if (is_friend
&& ctx
5485 && uses_template_parms_level (ctx
, processing_template_decl
))
5486 /* A friend template that specifies a class context, i.e.
5487 template <typename T> friend void A<T>::f();
5490 else if (TREE_CODE (decl
) == TYPE_DECL
5491 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5494 is_primary
= template_parm_scope_p ();
5498 warning (OPT_Wtemplates
, "template %qD declared", decl
);
5500 if (DECL_CLASS_SCOPE_P (decl
))
5501 member_template_p
= true;
5502 if (TREE_CODE (decl
) == TYPE_DECL
5503 && anon_aggrname_p (DECL_NAME (decl
)))
5505 error ("template class without a name");
5506 return error_mark_node
;
5508 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
5510 if (member_template_p
)
5512 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
5513 error ("member template %qD may not have virt-specifiers", decl
);
5515 if (DECL_DESTRUCTOR_P (decl
))
5519 A destructor shall not be a member template. */
5520 error ("destructor %qD declared as member template", decl
);
5521 return error_mark_node
;
5523 if (IDENTIFIER_NEWDEL_OP_P (DECL_NAME (decl
))
5524 && (!prototype_p (TREE_TYPE (decl
))
5525 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
5526 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5527 || (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5528 == void_list_node
)))
5530 /* [basic.stc.dynamic.allocation]
5532 An allocation function can be a function
5533 template. ... Template allocation functions shall
5534 have two or more parameters. */
5535 error ("invalid template declaration of %qD", decl
);
5536 return error_mark_node
;
5539 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5540 && CLASS_TYPE_P (TREE_TYPE (decl
)))
5542 /* Class template, set TEMPLATE_TYPE_PARM_FOR_CLASS. */
5543 tree parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
5544 for (int i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
5546 tree t
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5547 if (TREE_CODE (t
) == TYPE_DECL
)
5549 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
5550 TEMPLATE_TYPE_PARM_FOR_CLASS (t
) = true;
5553 else if (TREE_CODE (decl
) == TYPE_DECL
5554 && TYPE_DECL_ALIAS_P (decl
))
5555 /* alias-declaration */
5556 gcc_assert (!DECL_ARTIFICIAL (decl
));
5557 else if (VAR_P (decl
))
5558 /* C++14 variable template. */;
5561 error ("template declaration of %q#D", decl
);
5562 return error_mark_node
;
5566 /* Check to see that the rules regarding the use of default
5567 arguments are not being violated. We check args for a friend
5568 functions when we know whether it's a definition, introducing
5569 declaration or re-declaration. */
5570 if (!is_friend
|| TREE_CODE (decl
) != FUNCTION_DECL
)
5571 check_default_tmpl_args (decl
, current_template_parms
,
5572 is_primary
, is_partial
, is_friend
);
5574 /* Ensure that there are no parameter packs in the type of this
5575 declaration that have not been expanded. */
5576 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5578 /* Check each of the arguments individually to see if there are
5579 any bare parameter packs. */
5580 tree type
= TREE_TYPE (decl
);
5581 tree arg
= DECL_ARGUMENTS (decl
);
5582 tree argtype
= TYPE_ARG_TYPES (type
);
5584 while (arg
&& argtype
)
5586 if (!DECL_PACK_P (arg
)
5587 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
5589 /* This is a PARM_DECL that contains unexpanded parameter
5590 packs. We have already complained about this in the
5591 check_for_bare_parameter_packs call, so just replace
5592 these types with ERROR_MARK_NODE. */
5593 TREE_TYPE (arg
) = error_mark_node
;
5594 TREE_VALUE (argtype
) = error_mark_node
;
5597 arg
= DECL_CHAIN (arg
);
5598 argtype
= TREE_CHAIN (argtype
);
5601 /* Check for bare parameter packs in the return type and the
5602 exception specifiers. */
5603 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
5604 /* Errors were already issued, set return type to int
5605 as the frontend doesn't expect error_mark_node as
5607 TREE_TYPE (type
) = integer_type_node
;
5608 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
5609 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
5611 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
5612 && TYPE_DECL_ALIAS_P (decl
))
5613 ? DECL_ORIGINAL_TYPE (decl
)
5614 : TREE_TYPE (decl
)))
5616 TREE_TYPE (decl
) = error_mark_node
;
5617 return error_mark_node
;
5621 return process_partial_specialization (decl
);
5623 args
= current_template_args ();
5626 || TREE_CODE (ctx
) == FUNCTION_DECL
5627 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
5628 || (TREE_CODE (decl
) == TYPE_DECL
5629 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5630 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
5632 if (DECL_LANG_SPECIFIC (decl
)
5633 && DECL_TEMPLATE_INFO (decl
)
5634 && DECL_TI_TEMPLATE (decl
))
5635 tmpl
= DECL_TI_TEMPLATE (decl
);
5636 /* If DECL is a TYPE_DECL for a class-template, then there won't
5637 be DECL_LANG_SPECIFIC. The information equivalent to
5638 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5639 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5640 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
5641 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
5643 /* Since a template declaration already existed for this
5644 class-type, we must be redeclaring it here. Make sure
5645 that the redeclaration is valid. */
5646 redeclare_class_template (TREE_TYPE (decl
),
5647 current_template_parms
,
5648 current_template_constraints ());
5649 /* We don't need to create a new TEMPLATE_DECL; just use the
5650 one we already had. */
5651 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
5655 tmpl
= build_template_decl (decl
, current_template_parms
,
5659 if (DECL_LANG_SPECIFIC (decl
)
5660 && DECL_TEMPLATE_SPECIALIZATION (decl
))
5662 /* A specialization of a member template of a template
5664 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5665 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
5666 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
5672 tree a
, t
, current
, parms
;
5674 tree tinfo
= get_template_info (decl
);
5678 error ("template definition of non-template %q#D", decl
);
5679 return error_mark_node
;
5682 tmpl
= TI_TEMPLATE (tinfo
);
5684 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
5685 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
5686 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5687 && DECL_MEMBER_TEMPLATE_P (tmpl
))
5691 /* The declaration is a specialization of a member
5692 template, declared outside the class. Therefore, the
5693 innermost template arguments will be NULL, so we
5694 replace them with the arguments determined by the
5695 earlier call to check_explicit_specialization. */
5696 args
= DECL_TI_ARGS (decl
);
5699 = build_template_decl (decl
, current_template_parms
,
5701 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
5702 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
5703 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
5704 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
5705 DECL_TEMPLATE_INFO (new_tmpl
)
5706 = build_template_info (tmpl
, args
);
5708 register_specialization (new_tmpl
,
5709 most_general_template (tmpl
),
5715 /* Make sure the template headers we got make sense. */
5717 parms
= DECL_TEMPLATE_PARMS (tmpl
);
5718 i
= TMPL_PARMS_DEPTH (parms
);
5719 if (TMPL_ARGS_DEPTH (args
) != i
)
5721 error ("expected %d levels of template parms for %q#D, got %d",
5722 i
, decl
, TMPL_ARGS_DEPTH (args
));
5723 DECL_INTERFACE_KNOWN (decl
) = 1;
5724 return error_mark_node
;
5727 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
5729 a
= TMPL_ARGS_LEVEL (args
, i
);
5730 t
= INNERMOST_TEMPLATE_PARMS (parms
);
5732 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
5734 if (current
== decl
)
5735 error ("got %d template parameters for %q#D",
5736 TREE_VEC_LENGTH (a
), decl
);
5738 error ("got %d template parameters for %q#T",
5739 TREE_VEC_LENGTH (a
), current
);
5740 error (" but %d required", TREE_VEC_LENGTH (t
));
5741 /* Avoid crash in import_export_decl. */
5742 DECL_INTERFACE_KNOWN (decl
) = 1;
5743 return error_mark_node
;
5746 if (current
== decl
)
5748 else if (current
== NULL_TREE
)
5749 /* Can happen in erroneous input. */
5752 current
= get_containing_scope (current
);
5755 /* Check that the parms are used in the appropriate qualifying scopes
5756 in the declarator. */
5757 if (!comp_template_args
5759 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
5761 error ("template arguments to %qD do not match original "
5762 "template %qD", decl
, DECL_TEMPLATE_RESULT (tmpl
));
5763 if (!uses_template_parms (TI_ARGS (tinfo
)))
5764 inform (input_location
, "use %<template<>%> for"
5765 " an explicit specialization");
5766 /* Avoid crash in import_export_decl. */
5767 DECL_INTERFACE_KNOWN (decl
) = 1;
5768 return error_mark_node
;
5772 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5773 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5775 /* Push template declarations for global functions and types. Note
5776 that we do not try to push a global template friend declared in a
5777 template class; such a thing may well depend on the template
5778 parameters of the class. */
5779 if (new_template_p
&& !ctx
5780 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5782 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5783 if (tmpl
== error_mark_node
)
5784 return error_mark_node
;
5786 /* Hide template friend classes that haven't been declared yet. */
5787 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5789 DECL_ANTICIPATED (tmpl
) = 1;
5790 DECL_FRIEND_P (tmpl
) = 1;
5796 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5798 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5800 /* Give template template parms a DECL_CONTEXT of the template
5801 for which they are a parameter. */
5802 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5803 for (int i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5805 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5806 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5807 DECL_CONTEXT (parm
) = tmpl
;
5810 if (TREE_CODE (decl
) == TYPE_DECL
5811 && TYPE_DECL_ALIAS_P (decl
)
5812 && complex_alias_template_p (tmpl
))
5813 TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl
) = true;
5816 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5817 back to its most general template. If TMPL is a specialization,
5818 ARGS may only have the innermost set of arguments. Add the missing
5819 argument levels if necessary. */
5820 if (DECL_TEMPLATE_INFO (tmpl
))
5821 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5823 info
= build_template_info (tmpl
, args
);
5825 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5826 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5830 retrofit_lang_decl (decl
);
5831 if (DECL_LANG_SPECIFIC (decl
))
5832 DECL_TEMPLATE_INFO (decl
) = info
;
5835 if (flag_implicit_templates
5837 && TREE_PUBLIC (decl
)
5838 && VAR_OR_FUNCTION_DECL_P (decl
))
5839 /* Set DECL_COMDAT on template instantiations; if we force
5840 them to be emitted by explicit instantiation or -frepo,
5841 mark_needed will tell cgraph to do the right thing. */
5842 DECL_COMDAT (decl
) = true;
5844 return DECL_TEMPLATE_RESULT (tmpl
);
5848 push_template_decl (tree decl
)
5850 return push_template_decl_real (decl
, false);
5853 /* FN is an inheriting constructor that inherits from the constructor
5854 template INHERITED; turn FN into a constructor template with a matching
5858 add_inherited_template_parms (tree fn
, tree inherited
)
5861 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5862 inner_parms
= copy_node (inner_parms
);
5864 = tree_cons (size_int (processing_template_decl
+ 1),
5865 inner_parms
, current_template_parms
);
5866 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5867 tree args
= template_parms_to_args (parms
);
5868 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5869 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5870 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5871 DECL_ARTIFICIAL (tmpl
) = true;
5872 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5876 /* Called when a class template TYPE is redeclared with the indicated
5877 template PARMS, e.g.:
5879 template <class T> struct S;
5880 template <class T> struct S {}; */
5883 redeclare_class_template (tree type
, tree parms
, tree cons
)
5889 if (!TYPE_TEMPLATE_INFO (type
))
5891 error ("%qT is not a template type", type
);
5895 tmpl
= TYPE_TI_TEMPLATE (type
);
5896 if (!PRIMARY_TEMPLATE_P (tmpl
))
5897 /* The type is nested in some template class. Nothing to worry
5898 about here; there are no new template parameters for the nested
5904 error ("template specifiers not specified in declaration of %qD",
5909 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5910 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5912 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5914 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5915 "redeclared with %d template parameter",
5916 "redeclared with %d template parameters",
5917 TREE_VEC_LENGTH (parms
));
5918 inform_n (DECL_SOURCE_LOCATION (tmpl
), TREE_VEC_LENGTH (tmpl_parms
),
5919 "previous declaration %qD used %d template parameter",
5920 "previous declaration %qD used %d template parameters",
5921 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5925 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5932 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5933 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5936 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5937 if (error_operand_p (tmpl_parm
))
5940 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5941 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5942 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5944 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5946 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5947 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5948 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5949 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5950 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5951 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5952 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5953 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5954 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5956 error ("template parameter %q+#D", tmpl_parm
);
5957 error ("redeclared here as %q#D", parm
);
5961 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5963 /* We have in [temp.param]:
5965 A template-parameter may not be given default arguments
5966 by two different declarations in the same scope. */
5967 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5968 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5969 "original definition appeared here");
5973 if (parm_default
!= NULL_TREE
)
5974 /* Update the previous template parameters (which are the ones
5975 that will really count) with the new default value. */
5976 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5977 else if (tmpl_default
!= NULL_TREE
)
5978 /* Update the new parameters, too; they'll be used as the
5979 parameters for any members. */
5980 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5982 /* Give each template template parm in this redeclaration a
5983 DECL_CONTEXT of the template for which they are a parameter. */
5984 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5986 gcc_assert (DECL_CONTEXT (parm
) == NULL_TREE
);
5987 DECL_CONTEXT (parm
) = tmpl
;
5990 if (TREE_CODE (parm
) == TYPE_DECL
)
5991 TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (parm
)) = true;
5994 // Cannot redeclare a class template with a different set of constraints.
5995 if (!equivalent_constraints (get_constraints (tmpl
), cons
))
5997 error_at (input_location
, "redeclaration %q#D with different "
5998 "constraints", tmpl
);
5999 inform (DECL_SOURCE_LOCATION (tmpl
),
6000 "original declaration appeared here");
6006 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
6007 to be used when the caller has already checked
6008 (processing_template_decl
6009 && !instantiation_dependent_expression_p (expr)
6010 && potential_constant_expression (expr))
6011 and cleared processing_template_decl. */
6014 instantiate_non_dependent_expr_internal (tree expr
, tsubst_flags_t complain
)
6016 return tsubst_copy_and_build (expr
,
6019 /*in_decl=*/NULL_TREE
,
6020 /*function_p=*/false,
6021 /*integral_constant_expression_p=*/true);
6024 /* Simplify EXPR if it is a non-dependent expression. Returns the
6025 (possibly simplified) expression. */
6028 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
6030 if (expr
== NULL_TREE
)
6033 /* If we're in a template, but EXPR isn't value dependent, simplify
6034 it. We're supposed to treat:
6036 template <typename T> void f(T[1 + 1]);
6037 template <typename T> void f(T[2]);
6039 as two declarations of the same function, for example. */
6040 if (processing_template_decl
6041 && is_nondependent_constant_expression (expr
))
6043 processing_template_decl_sentinel s
;
6044 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6050 instantiate_non_dependent_expr (tree expr
)
6052 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
6055 /* Like instantiate_non_dependent_expr, but return NULL_TREE rather than
6056 an uninstantiated expression. */
6059 instantiate_non_dependent_or_null (tree expr
)
6061 if (expr
== NULL_TREE
)
6063 if (processing_template_decl
)
6065 if (!is_nondependent_constant_expression (expr
))
6069 processing_template_decl_sentinel s
;
6070 expr
= instantiate_non_dependent_expr_internal (expr
, tf_error
);
6076 /* True iff T is a specialization of a variable template. */
6079 variable_template_specialization_p (tree t
)
6081 if (!VAR_P (t
) || !DECL_LANG_SPECIFIC (t
) || !DECL_TEMPLATE_INFO (t
))
6083 tree tmpl
= DECL_TI_TEMPLATE (t
);
6084 return variable_template_p (tmpl
);
6087 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
6088 template declaration, or a TYPE_DECL for an alias declaration. */
6091 alias_type_or_template_p (tree t
)
6095 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
6098 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
6099 || DECL_ALIAS_TEMPLATE_P (t
));
6102 /* Return TRUE iff T is a specialization of an alias template. */
6105 alias_template_specialization_p (const_tree t
)
6107 /* It's an alias template specialization if it's an alias and its
6108 TYPE_NAME is a specialization of a primary template. */
6109 if (TYPE_ALIAS_P (t
))
6110 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
6111 return PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
));
6116 /* An alias template is complex from a SFINAE perspective if a template-id
6117 using that alias can be ill-formed when the expansion is not, as with
6118 the void_t template. We determine this by checking whether the
6119 expansion for the alias template uses all its template parameters. */
6121 struct uses_all_template_parms_data
6128 uses_all_template_parms_r (tree t
, void *data_
)
6130 struct uses_all_template_parms_data
&data
6131 = *(struct uses_all_template_parms_data
*)data_
;
6132 tree idx
= get_template_parm_index (t
);
6134 if (TEMPLATE_PARM_LEVEL (idx
) == data
.level
)
6135 data
.seen
[TEMPLATE_PARM_IDX (idx
)] = true;
6140 complex_alias_template_p (const_tree tmpl
)
6142 struct uses_all_template_parms_data data
;
6143 tree pat
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
6144 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
6145 data
.level
= TMPL_PARMS_DEPTH (parms
);
6146 int len
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms
));
6147 data
.seen
= XALLOCAVEC (bool, len
);
6148 for (int i
= 0; i
< len
; ++i
)
6149 data
.seen
[i
] = false;
6151 for_each_template_parm (pat
, uses_all_template_parms_r
, &data
, NULL
, true);
6152 for (int i
= 0; i
< len
; ++i
)
6158 /* Return TRUE iff T is a specialization of a complex alias template with
6159 dependent template-arguments. */
6162 dependent_alias_template_spec_p (const_tree t
)
6164 if (!alias_template_specialization_p (t
))
6167 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
);
6168 if (!TEMPLATE_DECL_COMPLEX_ALIAS_P (TI_TEMPLATE (tinfo
)))
6171 tree args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
));
6172 if (!any_dependent_template_arguments_p (args
))
6178 /* Return the number of innermost template parameters in TMPL. */
6181 num_innermost_template_parms (tree tmpl
)
6183 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
6184 return TREE_VEC_LENGTH (parms
);
6187 /* Return either TMPL or another template that it is equivalent to under DR
6188 1286: An alias that just changes the name of a template is equivalent to
6189 the other template. */
6192 get_underlying_template (tree tmpl
)
6194 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
6195 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
6197 /* Determine if the alias is equivalent to an underlying template. */
6198 tree orig_type
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
6199 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (orig_type
);
6203 tree underlying
= TI_TEMPLATE (tinfo
);
6204 if (!PRIMARY_TEMPLATE_P (underlying
)
6205 || (num_innermost_template_parms (tmpl
)
6206 != num_innermost_template_parms (underlying
)))
6209 tree alias_args
= INNERMOST_TEMPLATE_ARGS
6210 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
6211 if (!comp_template_args (TI_ARGS (tinfo
), alias_args
))
6214 /* Alias is equivalent. Strip it and repeat. */
6221 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
6222 must be a reference-to-function or a pointer-to-function type, as specified
6223 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
6224 and check that the resulting function has external linkage. */
6227 convert_nontype_argument_function (tree type
, tree expr
,
6228 tsubst_flags_t complain
)
6232 linkage_kind linkage
;
6234 fn
= instantiate_type (type
, fns
, tf_none
);
6235 if (fn
== error_mark_node
)
6236 return error_mark_node
;
6238 if (value_dependent_expression_p (fn
))
6241 fn_no_ptr
= strip_fnptr_conv (fn
);
6242 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
6243 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
6244 if (BASELINK_P (fn_no_ptr
))
6245 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
6247 /* [temp.arg.nontype]/1
6249 A template-argument for a non-type, non-template template-parameter
6252 -- the address of an object or function with external [C++11: or
6253 internal] linkage. */
6255 STRIP_ANY_LOCATION_WRAPPER (fn_no_ptr
);
6256 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
6258 if (complain
& tf_error
)
6260 error ("%qE is not a valid template argument for type %qT",
6262 if (TYPE_PTR_P (type
))
6263 inform (input_location
, "it must be the address of a function "
6264 "with external linkage");
6266 inform (input_location
, "it must be the name of a function with "
6267 "external linkage");
6272 linkage
= decl_linkage (fn_no_ptr
);
6273 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
6275 if (complain
& tf_error
)
6277 if (cxx_dialect
>= cxx11
)
6278 error ("%qE is not a valid template argument for type %qT "
6279 "because %qD has no linkage",
6280 expr
, type
, fn_no_ptr
);
6282 error ("%qE is not a valid template argument for type %qT "
6283 "because %qD does not have external linkage",
6284 expr
, type
, fn_no_ptr
);
6290 if (TYPE_REF_P (type
))
6292 if (REFERENCE_REF_P (fn
))
6293 fn
= TREE_OPERAND (fn
, 0);
6295 fn
= build_address (fn
);
6297 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (fn
)))
6298 fn
= build_nop (type
, fn
);
6303 /* Subroutine of convert_nontype_argument.
6304 Check if EXPR of type TYPE is a valid pointer-to-member constant.
6305 Emit an error otherwise. */
6308 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
6309 tsubst_flags_t complain
)
6311 location_t loc
= cp_expr_loc_or_loc (expr
, input_location
);
6312 tree orig_expr
= expr
;
6314 if (null_ptr_cst_p (expr
))
6316 if (TREE_CODE (expr
) == PTRMEM_CST
6317 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
6318 PTRMEM_CST_CLASS (expr
)))
6320 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
6322 if (processing_template_decl
6323 && TREE_CODE (expr
) == ADDR_EXPR
6324 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
6326 if (complain
& tf_error
)
6328 error_at (loc
, "%qE is not a valid template argument for type %qT",
6330 if (TREE_CODE (expr
) != PTRMEM_CST
)
6331 inform (loc
, "it must be a pointer-to-member of the form %<&X::Y%>");
6333 inform (loc
, "because it is a member of %qT", PTRMEM_CST_CLASS (expr
));
6338 /* Returns TRUE iff the address of OP is value-dependent.
6340 14.6.2.4 [temp.dep.temp]:
6341 A non-integral non-type template-argument is dependent if its type is
6342 dependent or it has either of the following forms
6345 and contains a nested-name-specifier which specifies a class-name that
6346 names a dependent type.
6348 We generalize this to just say that the address of a member of a
6349 dependent class is value-dependent; the above doesn't cover the
6350 address of a static data member named with an unqualified-id. */
6353 has_value_dependent_address (tree op
)
6355 /* We could use get_inner_reference here, but there's no need;
6356 this is only relevant for template non-type arguments, which
6357 can only be expressed as &id-expression. */
6360 tree ctx
= CP_DECL_CONTEXT (op
);
6361 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
6368 /* The next set of functions are used for providing helpful explanatory
6369 diagnostics for failed overload resolution. Their messages should be
6370 indented by two spaces for consistency with the messages in
6374 unify_success (bool /*explain_p*/)
6379 /* Other failure functions should call this one, to provide a single function
6380 for setting a breakpoint on. */
6383 unify_invalid (bool /*explain_p*/)
6389 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
6392 inform (input_location
,
6393 " couldn%'t deduce template parameter %qD", parm
);
6394 return unify_invalid (explain_p
);
6398 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
6401 inform (input_location
,
6402 " types %qT and %qT have incompatible cv-qualifiers",
6404 return unify_invalid (explain_p
);
6408 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
6411 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
6412 return unify_invalid (explain_p
);
6416 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
6419 inform (input_location
,
6420 " template parameter %qD is not a parameter pack, but "
6423 return unify_invalid (explain_p
);
6427 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
6430 inform (input_location
,
6431 " template argument %qE does not match "
6432 "pointer-to-member constant %qE",
6434 return unify_invalid (explain_p
);
6438 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
6441 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
6442 return unify_invalid (explain_p
);
6446 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
6449 inform (input_location
,
6450 " inconsistent parameter pack deduction with %qT and %qT",
6452 return unify_invalid (explain_p
);
6456 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
6461 inform (input_location
,
6462 " deduced conflicting types for parameter %qT (%qT and %qT)",
6463 parm
, first
, second
);
6465 inform (input_location
,
6466 " deduced conflicting values for non-type parameter "
6467 "%qE (%qE and %qE)", parm
, first
, second
);
6469 return unify_invalid (explain_p
);
6473 unify_vla_arg (bool explain_p
, tree arg
)
6476 inform (input_location
,
6477 " variable-sized array type %qT is not "
6478 "a valid template argument",
6480 return unify_invalid (explain_p
);
6484 unify_method_type_error (bool explain_p
, tree arg
)
6487 inform (input_location
,
6488 " member function type %qT is not a valid template argument",
6490 return unify_invalid (explain_p
);
6494 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
6499 inform_n (input_location
, wanted
,
6500 " candidate expects at least %d argument, %d provided",
6501 " candidate expects at least %d arguments, %d provided",
6504 inform_n (input_location
, wanted
,
6505 " candidate expects %d argument, %d provided",
6506 " candidate expects %d arguments, %d provided",
6509 return unify_invalid (explain_p
);
6513 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
6515 return unify_arity (explain_p
, have
, wanted
);
6519 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
6520 bool least_p
= false)
6522 return unify_arity (explain_p
, have
, wanted
, least_p
);
6526 unify_arg_conversion (bool explain_p
, tree to_type
,
6527 tree from_type
, tree arg
)
6530 inform (cp_expr_loc_or_loc (arg
, input_location
),
6531 " cannot convert %qE (type %qT) to type %qT",
6532 arg
, from_type
, to_type
);
6533 return unify_invalid (explain_p
);
6537 unify_no_common_base (bool explain_p
, enum template_base_result r
,
6538 tree parm
, tree arg
)
6543 case tbr_ambiguous_baseclass
:
6544 inform (input_location
, " %qT is an ambiguous base class of %qT",
6548 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
6551 return unify_invalid (explain_p
);
6555 unify_inconsistent_template_template_parameters (bool explain_p
)
6558 inform (input_location
,
6559 " template parameters of a template template argument are "
6560 "inconsistent with other deduced template arguments");
6561 return unify_invalid (explain_p
);
6565 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
6568 inform (input_location
,
6569 " can%'t deduce a template for %qT from non-template type %qT",
6571 return unify_invalid (explain_p
);
6575 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
6578 inform (input_location
,
6579 " template argument %qE does not match %qE", arg
, parm
);
6580 return unify_invalid (explain_p
);
6583 /* True if T is a C++20 template parameter object to store the argument for a
6584 template parameter of class type. */
6587 template_parm_object_p (const_tree t
)
6589 return (TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
) && DECL_NAME (t
)
6590 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (t
)), "_ZTA", 4));
6593 /* Subroutine of convert_nontype_argument, to check whether EXPR, as an
6594 argument for TYPE, points to an unsuitable object. */
6597 invalid_tparm_referent_p (tree type
, tree expr
, tsubst_flags_t complain
)
6599 switch (TREE_CODE (expr
))
6602 return invalid_tparm_referent_p (type
, TREE_OPERAND (expr
, 0),
6606 return invalid_tparm_referent_p (type
, TARGET_EXPR_INITIAL (expr
),
6611 unsigned i
; tree elt
;
6612 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), i
, elt
)
6613 if (invalid_tparm_referent_p (TREE_TYPE (elt
), elt
, complain
))
6620 tree decl
= TREE_OPERAND (expr
, 0);
6624 if (complain
& tf_error
)
6625 error ("%qE is not a valid template argument of type %qT "
6626 "because %qE is not a variable", expr
, type
, decl
);
6629 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
6631 if (complain
& tf_error
)
6632 error ("%qE is not a valid template argument of type %qT "
6633 "in C++98 because %qD does not have external linkage",
6637 else if ((cxx_dialect
>= cxx11
&& cxx_dialect
< cxx17
)
6638 && decl_linkage (decl
) == lk_none
)
6640 if (complain
& tf_error
)
6641 error ("%qE is not a valid template argument of type %qT "
6642 "because %qD has no linkage", expr
, type
, decl
);
6645 /* C++17: For a non-type template-parameter of reference or pointer
6646 type, the value of the constant expression shall not refer to (or
6647 for a pointer type, shall not be the address of):
6648 * a subobject (4.5),
6649 * a temporary object (15.2),
6650 * a string literal (5.13.5),
6651 * the result of a typeid expression (8.2.8), or
6652 * a predefined __func__ variable (11.4.1). */
6653 else if (DECL_ARTIFICIAL (decl
))
6655 if (complain
& tf_error
)
6656 error ("the address of %qD is not a valid template argument",
6660 else if (!same_type_ignoring_top_level_qualifiers_p
6661 (strip_array_types (TREE_TYPE (type
)),
6662 strip_array_types (TREE_TYPE (decl
))))
6664 if (complain
& tf_error
)
6665 error ("the address of the %qT subobject of %qD is not a "
6666 "valid template argument", TREE_TYPE (type
), decl
);
6669 else if (!TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
6671 if (complain
& tf_error
)
6672 error ("the address of %qD is not a valid template argument "
6673 "because it does not have static storage duration",
6681 if (!INDIRECT_TYPE_P (type
))
6682 /* We're only concerned about pointers and references here. */;
6683 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6684 /* Null pointer values are OK in C++11. */;
6689 if (complain
& tf_error
)
6690 error ("%qD is not a valid template argument "
6691 "because %qD is a variable, not the address of "
6692 "a variable", expr
, expr
);
6697 if (complain
& tf_error
)
6698 error ("%qE is not a valid template argument for %qT "
6699 "because it is not the address of a variable",
6709 /* Return a VAR_DECL for the C++20 template parameter object corresponding to
6710 template argument EXPR. */
6713 get_template_parm_object (tree expr
, tsubst_flags_t complain
)
6715 if (TREE_CODE (expr
) == TARGET_EXPR
)
6716 expr
= TARGET_EXPR_INITIAL (expr
);
6718 if (!TREE_CONSTANT (expr
))
6720 if ((complain
& tf_error
)
6721 && require_rvalue_constant_expression (expr
))
6722 cxx_constant_value (expr
);
6723 return error_mark_node
;
6725 if (invalid_tparm_referent_p (TREE_TYPE (expr
), expr
, complain
))
6726 return error_mark_node
;
6728 tree name
= mangle_template_parm_object (expr
);
6729 tree decl
= get_global_binding (name
);
6733 tree type
= cp_build_qualified_type (TREE_TYPE (expr
), TYPE_QUAL_CONST
);
6734 decl
= create_temporary_var (type
);
6735 TREE_STATIC (decl
) = true;
6736 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
6737 TREE_READONLY (decl
) = true;
6738 DECL_NAME (decl
) = name
;
6739 SET_DECL_ASSEMBLER_NAME (decl
, name
);
6740 DECL_CONTEXT (decl
) = global_namespace
;
6741 comdat_linkage (decl
);
6742 pushdecl_top_level_and_finish (decl
, expr
);
6746 /* Attempt to convert the non-type template parameter EXPR to the
6747 indicated TYPE. If the conversion is successful, return the
6748 converted value. If the conversion is unsuccessful, return
6749 NULL_TREE if we issued an error message, or error_mark_node if we
6750 did not. We issue error messages for out-and-out bad template
6751 parameters, but not simply because the conversion failed, since we
6752 might be just trying to do argument deduction. Both TYPE and EXPR
6753 must be non-dependent.
6755 The conversion follows the special rules described in
6756 [temp.arg.nontype], and it is much more strict than an implicit
6759 This function is called twice for each template argument (see
6760 lookup_template_class for a more accurate description of this
6761 problem). This means that we need to handle expressions which
6762 are not valid in a C++ source, but can be created from the
6763 first call (for instance, casts to perform conversions). These
6764 hacks can go away after we fix the double coercion problem. */
6767 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
6770 location_t loc
= cp_expr_loc_or_loc (expr
, input_location
);
6772 /* Detect immediately string literals as invalid non-type argument.
6773 This special-case is not needed for correctness (we would easily
6774 catch this later), but only to provide better diagnostic for this
6775 common user mistake. As suggested by DR 100, we do not mention
6776 linkage issues in the diagnostic as this is not the point. */
6777 if (TREE_CODE (expr
) == STRING_CST
&& !CLASS_TYPE_P (type
))
6779 if (complain
& tf_error
)
6780 error ("%qE is not a valid template argument for type %qT "
6781 "because string literals can never be used in this context",
6786 /* Add the ADDR_EXPR now for the benefit of
6787 value_dependent_expression_p. */
6788 if (TYPE_PTROBV_P (type
)
6789 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
6791 expr
= decay_conversion (expr
, complain
);
6792 if (expr
== error_mark_node
)
6793 return error_mark_node
;
6796 /* If we are in a template, EXPR may be non-dependent, but still
6797 have a syntactic, rather than semantic, form. For example, EXPR
6798 might be a SCOPE_REF, rather than the VAR_DECL to which the
6799 SCOPE_REF refers. Preserving the qualifying scope is necessary
6800 so that access checking can be performed when the template is
6801 instantiated -- but here we need the resolved form so that we can
6802 convert the argument. */
6803 bool non_dep
= false;
6804 if (TYPE_REF_OBJ_P (type
)
6805 && has_value_dependent_address (expr
))
6806 /* If we want the address and it's value-dependent, don't fold. */;
6807 else if (processing_template_decl
6808 && is_nondependent_constant_expression (expr
))
6810 if (error_operand_p (expr
))
6811 return error_mark_node
;
6812 expr_type
= TREE_TYPE (expr
);
6814 /* If the argument is non-dependent, perform any conversions in
6815 non-dependent context as well. */
6816 processing_template_decl_sentinel
s (non_dep
);
6818 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6820 if (value_dependent_expression_p (expr
))
6821 expr
= canonicalize_expr_argument (expr
, complain
);
6823 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
6824 to a non-type argument of "nullptr". */
6825 if (NULLPTR_TYPE_P (expr_type
) && TYPE_PTR_OR_PTRMEM_P (type
))
6826 expr
= fold_simple (convert (type
, expr
));
6828 /* In C++11, integral or enumeration non-type template arguments can be
6829 arbitrary constant expressions. Pointer and pointer to
6830 member arguments can be general constant expressions that evaluate
6831 to a null value, but otherwise still need to be of a specific form. */
6832 if (cxx_dialect
>= cxx11
)
6834 if (TREE_CODE (expr
) == PTRMEM_CST
&& TYPE_PTRMEM_P (type
))
6835 /* A PTRMEM_CST is already constant, and a valid template
6836 argument for a parameter of pointer to member type, we just want
6837 to leave it in that form rather than lower it to a
6839 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
6840 || cxx_dialect
>= cxx17
)
6842 /* Calling build_converted_constant_expr might create a call to
6843 a conversion function with a value-dependent argument, which
6844 could invoke taking the address of a temporary representing
6845 the result of the conversion. */
6846 if (COMPOUND_LITERAL_P (expr
)
6847 && CONSTRUCTOR_IS_DEPENDENT (expr
)
6848 && MAYBE_CLASS_TYPE_P (expr_type
)
6849 && TYPE_HAS_CONVERSION (expr_type
))
6851 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
6852 IMPLICIT_CONV_EXPR_NONTYPE_ARG (expr
) = true;
6855 /* C++17: A template-argument for a non-type template-parameter shall
6856 be a converted constant expression (8.20) of the type of the
6857 template-parameter. */
6858 expr
= build_converted_constant_expr (type
, expr
, complain
);
6859 if (expr
== error_mark_node
)
6860 /* Make sure we return NULL_TREE only if we have really issued
6861 an error, as described above. */
6862 return (complain
& tf_error
) ? NULL_TREE
: error_mark_node
;
6863 expr
= maybe_constant_value (expr
, NULL_TREE
,
6864 /*manifestly_const_eval=*/true);
6865 expr
= convert_from_reference (expr
);
6867 else if (TYPE_PTR_OR_PTRMEM_P (type
))
6869 tree folded
= maybe_constant_value (expr
, NULL_TREE
,
6870 /*manifestly_const_eval=*/true);
6871 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
6872 : null_member_pointer_value_p (folded
))
6877 if (TYPE_REF_P (type
))
6878 expr
= mark_lvalue_use (expr
);
6880 expr
= mark_rvalue_use (expr
);
6882 /* HACK: Due to double coercion, we can get a
6883 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
6884 which is the tree that we built on the first call (see
6885 below when coercing to reference to object or to reference to
6886 function). We just strip everything and get to the arg.
6887 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
6889 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
6891 tree probe_type
, probe
= expr
;
6892 if (REFERENCE_REF_P (probe
))
6893 probe
= TREE_OPERAND (probe
, 0);
6894 probe_type
= TREE_TYPE (probe
);
6895 if (TREE_CODE (probe
) == NOP_EXPR
)
6897 /* ??? Maybe we could use convert_from_reference here, but we
6898 would need to relax its constraints because the NOP_EXPR
6899 could actually change the type to something more cv-qualified,
6900 and this is not folded by convert_from_reference. */
6901 tree addr
= TREE_OPERAND (probe
, 0);
6902 if (TYPE_REF_P (probe_type
)
6903 && TREE_CODE (addr
) == ADDR_EXPR
6904 && TYPE_PTR_P (TREE_TYPE (addr
))
6905 && (same_type_ignoring_top_level_qualifiers_p
6906 (TREE_TYPE (probe_type
),
6907 TREE_TYPE (TREE_TYPE (addr
)))))
6909 expr
= TREE_OPERAND (addr
, 0);
6910 expr_type
= TREE_TYPE (probe_type
);
6915 /* [temp.arg.nontype]/5, bullet 1
6917 For a non-type template-parameter of integral or enumeration type,
6918 integral promotions (_conv.prom_) and integral conversions
6919 (_conv.integral_) are applied. */
6920 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6922 if (cxx_dialect
< cxx11
)
6924 tree t
= build_converted_constant_expr (type
, expr
, complain
);
6925 t
= maybe_constant_value (t
);
6926 if (t
!= error_mark_node
)
6930 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
6931 return error_mark_node
;
6933 /* Notice that there are constant expressions like '4 % 0' which
6934 do not fold into integer constants. */
6935 if (TREE_CODE (expr
) != INTEGER_CST
6936 && !value_dependent_expression_p (expr
))
6938 if (complain
& tf_error
)
6940 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
6941 if (!require_potential_constant_expression (expr
))
6942 expr
= error_mark_node
;
6944 expr
= cxx_constant_value (expr
);
6945 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
6946 inform (loc
, "in template argument for type %qT", type
);
6947 if (expr
== error_mark_node
)
6949 /* else cxx_constant_value complained but gave us
6950 a real constant, so go ahead. */
6951 if (TREE_CODE (expr
) != INTEGER_CST
)
6953 /* Some assemble time constant expressions like
6954 (intptr_t)&&lab1 - (intptr_t)&&lab2 or
6955 4 + (intptr_t)&&var satisfy reduced_constant_expression_p
6956 as we can emit them into .rodata initializers of
6957 variables, yet they can't fold into an INTEGER_CST at
6958 compile time. Refuse them here. */
6959 gcc_checking_assert (reduced_constant_expression_p (expr
));
6960 error_at (loc
, "template argument %qE for type %qT not "
6961 "a constant integer", expr
, type
);
6969 /* Avoid typedef problems. */
6970 if (TREE_TYPE (expr
) != type
)
6971 expr
= fold_convert (type
, expr
);
6973 /* [temp.arg.nontype]/5, bullet 2
6975 For a non-type template-parameter of type pointer to object,
6976 qualification conversions (_conv.qual_) and the array-to-pointer
6977 conversion (_conv.array_) are applied. */
6978 else if (TYPE_PTROBV_P (type
))
6980 tree decayed
= expr
;
6982 /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
6983 decay_conversion or an explicit cast. If it's a problematic cast,
6984 we'll complain about it below. */
6985 if (TREE_CODE (expr
) == NOP_EXPR
)
6989 if (TREE_CODE (probe
) == ADDR_EXPR
6990 && TYPE_PTR_P (TREE_TYPE (probe
)))
6993 expr_type
= TREE_TYPE (expr
);
6997 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6999 A template-argument for a non-type, non-template template-parameter
7000 shall be one of: [...]
7002 -- the name of a non-type template-parameter;
7003 -- the address of an object or function with external linkage, [...]
7004 expressed as "& id-expression" where the & is optional if the name
7005 refers to a function or array, or if the corresponding
7006 template-parameter is a reference.
7008 Here, we do not care about functions, as they are invalid anyway
7009 for a parameter of type pointer-to-object. */
7011 if (value_dependent_expression_p (expr
))
7012 /* Non-type template parameters are OK. */
7014 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
7015 /* Null pointer values are OK in C++11. */;
7016 else if (TREE_CODE (expr
) != ADDR_EXPR
7017 && !INDIRECT_TYPE_P (expr_type
))
7018 /* Other values, like integer constants, might be valid
7019 non-type arguments of some other type. */
7020 return error_mark_node
;
7021 else if (invalid_tparm_referent_p (type
, expr
, complain
))
7026 expr
= perform_qualification_conversions (type
, expr
);
7027 if (expr
== error_mark_node
)
7028 return error_mark_node
;
7030 /* [temp.arg.nontype]/5, bullet 3
7032 For a non-type template-parameter of type reference to object, no
7033 conversions apply. The type referred to by the reference may be more
7034 cv-qualified than the (otherwise identical) type of the
7035 template-argument. The template-parameter is bound directly to the
7036 template-argument, which must be an lvalue. */
7037 else if (TYPE_REF_OBJ_P (type
))
7039 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
7041 return error_mark_node
;
7043 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
7045 if (complain
& tf_error
)
7046 error ("%qE is not a valid template argument for type %qT "
7047 "because of conflicts in cv-qualification", expr
, type
);
7051 if (!lvalue_p (expr
))
7053 if (complain
& tf_error
)
7054 error ("%qE is not a valid template argument for type %qT "
7055 "because it is not an lvalue", expr
, type
);
7059 /* [temp.arg.nontype]/1
7061 A template-argument for a non-type, non-template template-parameter
7062 shall be one of: [...]
7064 -- the address of an object or function with external linkage. */
7065 if (INDIRECT_REF_P (expr
)
7066 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
7068 expr
= TREE_OPERAND (expr
, 0);
7071 if (complain
& tf_error
)
7072 error ("%q#D is not a valid template argument for type %qT "
7073 "because a reference variable does not have a constant "
7074 "address", expr
, type
);
7079 if (TYPE_REF_OBJ_P (TREE_TYPE (expr
))
7080 && value_dependent_expression_p (expr
))
7081 /* OK, dependent reference. We don't want to ask whether a DECL is
7082 itself value-dependent, since what we want here is its address. */;
7085 expr
= build_address (expr
);
7087 if (invalid_tparm_referent_p (type
, expr
, complain
))
7091 if (!same_type_p (type
, TREE_TYPE (expr
)))
7092 expr
= build_nop (type
, expr
);
7094 /* [temp.arg.nontype]/5, bullet 4
7096 For a non-type template-parameter of type pointer to function, only
7097 the function-to-pointer conversion (_conv.func_) is applied. If the
7098 template-argument represents a set of overloaded functions (or a
7099 pointer to such), the matching function is selected from the set
7101 else if (TYPE_PTRFN_P (type
))
7103 /* If the argument is a template-id, we might not have enough
7104 context information to decay the pointer. */
7105 if (!type_unknown_p (expr_type
))
7107 expr
= decay_conversion (expr
, complain
);
7108 if (expr
== error_mark_node
)
7109 return error_mark_node
;
7112 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
7113 /* Null pointer values are OK in C++11. */
7114 return perform_qualification_conversions (type
, expr
);
7116 expr
= convert_nontype_argument_function (type
, expr
, complain
);
7117 if (!expr
|| expr
== error_mark_node
)
7120 /* [temp.arg.nontype]/5, bullet 5
7122 For a non-type template-parameter of type reference to function, no
7123 conversions apply. If the template-argument represents a set of
7124 overloaded functions, the matching function is selected from the set
7126 else if (TYPE_REFFN_P (type
))
7128 if (TREE_CODE (expr
) == ADDR_EXPR
)
7130 if (complain
& tf_error
)
7132 error ("%qE is not a valid template argument for type %qT "
7133 "because it is a pointer", expr
, type
);
7134 inform (input_location
, "try using %qE instead",
7135 TREE_OPERAND (expr
, 0));
7140 expr
= convert_nontype_argument_function (type
, expr
, complain
);
7141 if (!expr
|| expr
== error_mark_node
)
7144 /* [temp.arg.nontype]/5, bullet 6
7146 For a non-type template-parameter of type pointer to member function,
7147 no conversions apply. If the template-argument represents a set of
7148 overloaded member functions, the matching member function is selected
7149 from the set (_over.over_). */
7150 else if (TYPE_PTRMEMFUNC_P (type
))
7152 expr
= instantiate_type (type
, expr
, tf_none
);
7153 if (expr
== error_mark_node
)
7154 return error_mark_node
;
7156 /* [temp.arg.nontype] bullet 1 says the pointer to member
7157 expression must be a pointer-to-member constant. */
7158 if (!value_dependent_expression_p (expr
)
7159 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
7162 /* Repeated conversion can't deal with a conversion that turns PTRMEM_CST
7163 into a CONSTRUCTOR, so build up a new PTRMEM_CST instead. */
7164 if (fnptr_conv_p (type
, TREE_TYPE (expr
)))
7165 expr
= make_ptrmem_cst (type
, PTRMEM_CST_MEMBER (expr
));
7167 /* [temp.arg.nontype]/5, bullet 7
7169 For a non-type template-parameter of type pointer to data member,
7170 qualification conversions (_conv.qual_) are applied. */
7171 else if (TYPE_PTRDATAMEM_P (type
))
7173 /* [temp.arg.nontype] bullet 1 says the pointer to member
7174 expression must be a pointer-to-member constant. */
7175 if (!value_dependent_expression_p (expr
)
7176 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
7179 expr
= perform_qualification_conversions (type
, expr
);
7180 if (expr
== error_mark_node
)
7183 else if (NULLPTR_TYPE_P (type
))
7185 if (!NULLPTR_TYPE_P (TREE_TYPE (expr
)))
7187 if (complain
& tf_error
)
7188 error ("%qE is not a valid template argument for type %qT "
7189 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
7194 else if (CLASS_TYPE_P (type
))
7196 /* Replace the argument with a reference to the corresponding template
7197 parameter object. */
7198 if (!value_dependent_expression_p (expr
))
7199 expr
= get_template_parm_object (expr
, complain
);
7200 if (expr
== error_mark_node
)
7203 /* A template non-type parameter must be one of the above. */
7207 /* Sanity check: did we actually convert the argument to the
7209 gcc_assert (same_type_ignoring_top_level_qualifiers_p
7210 (type
, TREE_TYPE (expr
)));
7211 return convert_from_reference (expr
);
7214 /* Subroutine of coerce_template_template_parms, which returns 1 if
7215 PARM_PARM and ARG_PARM match using the rule for the template
7216 parameters of template template parameters. Both PARM and ARG are
7217 template parameters; the rest of the arguments are the same as for
7218 coerce_template_template_parms.
7221 coerce_template_template_parm (tree parm
,
7223 tsubst_flags_t complain
,
7227 if (arg
== NULL_TREE
|| error_operand_p (arg
)
7228 || parm
== NULL_TREE
|| error_operand_p (parm
))
7231 if (TREE_CODE (arg
) != TREE_CODE (parm
))
7234 switch (TREE_CODE (parm
))
7237 /* We encounter instantiations of templates like
7238 template <template <template <class> class> class TT>
7241 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
7242 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
7244 if (!coerce_template_template_parms
7245 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
7251 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
7252 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
7253 /* Argument is a parameter pack but parameter is not. */
7258 /* The tsubst call is used to handle cases such as
7260 template <int> class C {};
7261 template <class T, template <T> class TT> class D {};
7264 i.e. the parameter list of TT depends on earlier parameters. */
7265 if (!uses_template_parms (TREE_TYPE (arg
)))
7267 tree t
= tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
);
7268 if (!uses_template_parms (t
)
7269 && !same_type_p (t
, TREE_TYPE (arg
)))
7273 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
7274 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
7275 /* Argument is a parameter pack but parameter is not. */
7287 /* Coerce template argument list ARGLIST for use with template
7288 template-parameter TEMPL. */
7291 coerce_template_args_for_ttp (tree templ
, tree arglist
,
7292 tsubst_flags_t complain
)
7294 /* Consider an example where a template template parameter declared as
7296 template <class T, class U = std::allocator<T> > class TT
7298 The template parameter level of T and U are one level larger than
7299 of TT. To proper process the default argument of U, say when an
7300 instantiation `TT<int>' is seen, we need to build the full
7301 arguments containing {int} as the innermost level. Outer levels,
7302 available when not appearing as default template argument, can be
7303 obtained from the arguments of the enclosing template.
7305 Suppose that TT is later substituted with std::vector. The above
7306 instantiation is `TT<int, std::allocator<T> >' with TT at
7307 level 1, and T at level 2, while the template arguments at level 1
7308 becomes {std::vector} and the inner level 2 is {int}. */
7310 tree outer
= DECL_CONTEXT (templ
);
7313 if (DECL_TEMPLATE_SPECIALIZATION (outer
))
7314 /* We want arguments for the partial specialization, not arguments for
7315 the primary template. */
7316 outer
= template_parms_to_args (DECL_TEMPLATE_PARMS (outer
));
7318 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7320 else if (current_template_parms
)
7322 /* This is an argument of the current template, so we haven't set
7323 DECL_CONTEXT yet. */
7324 tree relevant_template_parms
;
7326 /* Parameter levels that are greater than the level of the given
7327 template template parm are irrelevant. */
7328 relevant_template_parms
= current_template_parms
;
7329 while (TMPL_PARMS_DEPTH (relevant_template_parms
)
7330 != TEMPLATE_TYPE_LEVEL (TREE_TYPE (templ
)))
7331 relevant_template_parms
= TREE_CHAIN (relevant_template_parms
);
7333 outer
= template_parms_to_args (relevant_template_parms
);
7337 arglist
= add_to_template_args (outer
, arglist
);
7339 tree parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7340 return coerce_template_parms (parmlist
, arglist
, templ
,
7342 /*require_all_args=*/true,
7343 /*use_default_args=*/true);
7346 /* A cache of template template parameters with match-all default
7348 static GTY((deletable
)) hash_map
<tree
,tree
> *defaulted_ttp_cache
;
7350 store_defaulted_ttp (tree v
, tree t
)
7352 if (!defaulted_ttp_cache
)
7353 defaulted_ttp_cache
= hash_map
<tree
,tree
>::create_ggc (13);
7354 defaulted_ttp_cache
->put (v
, t
);
7357 lookup_defaulted_ttp (tree v
)
7359 if (defaulted_ttp_cache
)
7360 if (tree
*p
= defaulted_ttp_cache
->get (v
))
7365 /* T is a bound template template-parameter. Copy its arguments into default
7366 arguments of the template template-parameter's template parameters. */
7369 add_defaults_to_ttp (tree otmpl
)
7371 if (tree c
= lookup_defaulted_ttp (otmpl
))
7374 tree ntmpl
= copy_node (otmpl
);
7376 tree ntype
= copy_node (TREE_TYPE (otmpl
));
7377 TYPE_STUB_DECL (ntype
) = TYPE_NAME (ntype
) = ntmpl
;
7378 TYPE_MAIN_VARIANT (ntype
) = ntype
;
7379 TYPE_POINTER_TO (ntype
) = TYPE_REFERENCE_TO (ntype
) = NULL_TREE
;
7380 TYPE_NAME (ntype
) = ntmpl
;
7381 SET_TYPE_STRUCTURAL_EQUALITY (ntype
);
7383 tree idx
= TEMPLATE_TYPE_PARM_INDEX (ntype
)
7384 = copy_node (TEMPLATE_TYPE_PARM_INDEX (ntype
));
7385 TEMPLATE_PARM_DECL (idx
) = ntmpl
;
7386 TREE_TYPE (ntmpl
) = TREE_TYPE (idx
) = ntype
;
7388 tree oparms
= DECL_TEMPLATE_PARMS (otmpl
);
7389 tree parms
= DECL_TEMPLATE_PARMS (ntmpl
) = copy_node (oparms
);
7390 TREE_CHAIN (parms
) = TREE_CHAIN (oparms
);
7391 tree vec
= TREE_VALUE (parms
) = copy_node (TREE_VALUE (parms
));
7392 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
7394 tree o
= TREE_VEC_ELT (vec
, i
);
7395 if (!template_parameter_pack_p (TREE_VALUE (o
)))
7397 tree n
= TREE_VEC_ELT (vec
, i
) = copy_node (o
);
7398 TREE_PURPOSE (n
) = any_targ_node
;
7402 store_defaulted_ttp (otmpl
, ntmpl
);
7406 /* ARG is a bound potential template template-argument, and PARGS is a list
7407 of arguments for the corresponding template template-parameter. Adjust
7408 PARGS as appropriate for application to ARG's template, and if ARG is a
7409 BOUND_TEMPLATE_TEMPLATE_PARM, possibly adjust it to add default template
7410 arguments to the template template parameter. */
7413 coerce_ttp_args_for_tta (tree
& arg
, tree pargs
, tsubst_flags_t complain
)
7415 ++processing_template_decl
;
7416 tree arg_tmpl
= TYPE_TI_TEMPLATE (arg
);
7417 if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg_tmpl
))
7419 /* When comparing two template template-parameters in partial ordering,
7420 rewrite the one currently being used as an argument to have default
7421 arguments for all parameters. */
7422 arg_tmpl
= add_defaults_to_ttp (arg_tmpl
);
7423 pargs
= coerce_template_args_for_ttp (arg_tmpl
, pargs
, complain
);
7424 if (pargs
!= error_mark_node
)
7425 arg
= bind_template_template_parm (TREE_TYPE (arg_tmpl
),
7426 TYPE_TI_ARGS (arg
));
7431 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (arg_tmpl
));
7432 pargs
= coerce_template_parms (aparms
, pargs
, arg_tmpl
, complain
,
7433 /*require_all*/true,
7434 /*use_default*/true);
7436 --processing_template_decl
;
7440 /* Subroutine of unify for the case when PARM is a
7441 BOUND_TEMPLATE_TEMPLATE_PARM. */
7444 unify_bound_ttp_args (tree tparms
, tree targs
, tree parm
, tree
& arg
,
7447 tree parmvec
= TYPE_TI_ARGS (parm
);
7448 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
7450 /* The template template parm might be variadic and the argument
7451 not, so flatten both argument lists. */
7452 parmvec
= expand_template_argument_pack (parmvec
);
7453 argvec
= expand_template_argument_pack (argvec
);
7457 /* In keeping with P0522R0, adjust P's template arguments
7458 to apply to A's template; then flatten it again. */
7459 tree nparmvec
= parmvec
;
7460 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 orig_arg
= TREE_VALUE (arg
);
7888 TREE_TYPE (arg
) = unknown_type_node
;
7893 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
7894 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
7895 || requires_tmpl_type
);
7897 /* When determining whether an argument pack expansion is a template,
7898 look at the pattern. */
7899 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
7900 arg
= PACK_EXPANSION_PATTERN (arg
);
7902 /* Deal with an injected-class-name used as a template template arg. */
7903 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
7905 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
7906 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7908 if (cxx_dialect
>= cxx11
)
7909 /* OK under DR 1004. */;
7910 else if (complain
& tf_warning_or_error
)
7911 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
7912 " used as template template argument", TYPE_NAME (arg
));
7913 else if (flag_pedantic_errors
)
7921 ((TREE_CODE (arg
) == TEMPLATE_DECL
7922 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
7923 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
7924 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7925 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
7928 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7929 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
7930 arg
= TYPE_STUB_DECL (arg
);
7932 is_type
= TYPE_P (arg
) || is_tmpl_type
;
7934 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
7935 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
7937 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
7939 if (complain
& tf_error
)
7940 error ("invalid use of destructor %qE as a type", orig_arg
);
7941 return error_mark_node
;
7944 permerror (input_location
,
7945 "to refer to a type member of a template parameter, "
7946 "use %<typename %E%>", orig_arg
);
7948 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
7949 TREE_OPERAND (arg
, 1),
7955 if (is_type
!= requires_type
)
7959 if (complain
& tf_error
)
7961 error ("type/value mismatch at argument %d in template "
7962 "parameter list for %qD",
7965 inform (input_location
,
7966 " expected a constant of type %qT, got %qT",
7968 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
7969 else if (requires_tmpl_type
)
7970 inform (input_location
,
7971 " expected a class template, got %qE", orig_arg
);
7973 inform (input_location
,
7974 " expected a type, got %qE", orig_arg
);
7977 return error_mark_node
;
7979 if (is_tmpl_type
^ requires_tmpl_type
)
7981 if (in_decl
&& (complain
& tf_error
))
7983 error ("type/value mismatch at argument %d in template "
7984 "parameter list for %qD",
7987 inform (input_location
,
7988 " expected a type, got %qT", DECL_NAME (arg
));
7990 inform (input_location
,
7991 " expected a class template, got %qT", orig_arg
);
7993 return error_mark_node
;
7996 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
7997 /* We already did the appropriate conversion when packing args. */
8001 if (requires_tmpl_type
)
8003 if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
8004 /* The number of argument required is not known yet.
8005 Just accept it for now. */
8009 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
8012 /* Strip alias templates that are equivalent to another
8014 arg
= get_underlying_template (arg
);
8015 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
8017 if (coerce_template_template_parms (parmparm
, argparm
,
8023 /* TEMPLATE_TEMPLATE_PARM node is preferred over
8025 if (val
!= error_mark_node
)
8027 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
8028 val
= TREE_TYPE (val
);
8029 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
8030 val
= make_pack_expansion (val
, complain
);
8035 if (in_decl
&& (complain
& tf_error
))
8037 error ("type/value mismatch at argument %d in "
8038 "template parameter list for %qD",
8040 inform (input_location
,
8041 " expected a template of type %qD, got %qT",
8045 val
= error_mark_node
;
8048 // Check that the constraints are compatible before allowing the
8050 if (val
!= error_mark_node
)
8051 if (!is_compatible_template_arg (parm
, arg
))
8053 if (in_decl
&& (complain
& tf_error
))
8055 error ("constraint mismatch at argument %d in "
8056 "template parameter list for %qD",
8058 inform (input_location
, " expected %qD but got %qD",
8061 val
= error_mark_node
;
8067 /* We only form one instance of each template specialization.
8068 Therefore, if we use a non-canonical variant (i.e., a
8069 typedef), any future messages referring to the type will use
8070 the typedef, which is confusing if those future uses do not
8071 themselves also use the typedef. */
8073 val
= canonicalize_type_argument (val
, complain
);
8077 tree t
= TREE_TYPE (parm
);
8079 if (TEMPLATE_PARM_LEVEL (get_template_parm_index (parm
))
8080 > TMPL_ARGS_DEPTH (args
))
8081 /* We don't have enough levels of args to do any substitution. This
8082 can happen in the context of -fnew-ttp-matching. */;
8083 else if (tree a
= type_uses_auto (t
))
8085 t
= do_auto_deduction (t
, arg
, a
, complain
, adc_unify
, args
);
8086 if (t
== error_mark_node
)
8087 return error_mark_node
;
8090 t
= tsubst (t
, args
, complain
, in_decl
);
8092 if (invalid_nontype_parm_type_p (t
, complain
))
8093 return error_mark_node
;
8095 if (t
!= TREE_TYPE (parm
))
8096 t
= canonicalize_type_argument (t
, complain
);
8098 if (!type_dependent_expression_p (orig_arg
)
8099 && !uses_template_parms (t
))
8100 /* We used to call digest_init here. However, digest_init
8101 will report errors, which we don't want when complain
8102 is zero. More importantly, digest_init will try too
8103 hard to convert things: for example, `0' should not be
8104 converted to pointer type at this point according to
8105 the standard. Accepting this is not merely an
8106 extension, since deciding whether or not these
8107 conversions can occur is part of determining which
8108 function template to call, or whether a given explicit
8109 argument specification is valid. */
8110 val
= convert_nontype_argument (t
, orig_arg
, complain
);
8113 val
= canonicalize_expr_argument (orig_arg
, complain
);
8114 val
= maybe_convert_nontype_argument (t
, val
);
8118 if (val
== NULL_TREE
)
8119 val
= error_mark_node
;
8120 else if (val
== error_mark_node
&& (complain
& tf_error
))
8121 error ("could not convert template argument %qE from %qT to %qT",
8122 orig_arg
, TREE_TYPE (orig_arg
), t
);
8124 if (INDIRECT_REF_P (val
))
8126 /* Reject template arguments that are references to built-in
8127 functions with no library fallbacks. */
8128 const_tree inner
= TREE_OPERAND (val
, 0);
8129 const_tree innertype
= TREE_TYPE (inner
);
8131 && TYPE_REF_P (innertype
)
8132 && TREE_CODE (TREE_TYPE (innertype
)) == FUNCTION_TYPE
8133 && TREE_OPERAND_LENGTH (inner
) > 0
8134 && reject_gcc_builtin (TREE_OPERAND (inner
, 0)))
8135 return error_mark_node
;
8138 if (TREE_CODE (val
) == SCOPE_REF
)
8140 /* Strip typedefs from the SCOPE_REF. */
8141 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
8142 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
8144 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
8145 QUALIFIED_NAME_IS_TEMPLATE (val
));
8152 /* Coerces the remaining template arguments in INNER_ARGS (from
8153 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
8154 Returns the coerced argument pack. PARM_IDX is the position of this
8155 parameter in the template parameter list. ARGS is the original
8156 template argument list. */
8158 coerce_template_parameter_pack (tree parms
,
8166 tsubst_flags_t complain
)
8168 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
8169 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
8172 tree packed_parms
= NULL_TREE
;
8174 if (arg_idx
> nargs
)
8177 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
8179 /* When the template parameter is a non-type template parameter pack
8180 or template template parameter pack whose type or template
8181 parameters use parameter packs, we know exactly how many arguments
8182 we are looking for. Build a vector of the instantiated decls for
8183 these template parameters in PACKED_PARMS. */
8184 /* We can't use make_pack_expansion here because it would interpret a
8185 _DECL as a use rather than a declaration. */
8186 tree decl
= TREE_VALUE (parm
);
8187 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
8188 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
8189 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
8190 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
8192 TREE_VEC_LENGTH (args
)--;
8193 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
8194 TREE_VEC_LENGTH (args
)++;
8196 if (packed_parms
== error_mark_node
)
8197 return error_mark_node
;
8199 /* If we're doing a partial instantiation of a member template,
8200 verify that all of the types used for the non-type
8201 template parameter pack are, in fact, valid for non-type
8202 template parameters. */
8204 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
8206 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
8207 for (j
= 0; j
< len
; ++j
)
8209 tree t
= TREE_VEC_ELT (packed_parms
, j
);
8210 if (TREE_CODE (t
) == PARM_DECL
8211 && invalid_nontype_parm_type_p (TREE_TYPE (t
), complain
))
8212 return error_mark_node
;
8214 /* We don't know how many args we have yet, just
8215 use the unconverted ones for now. */
8219 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
8221 /* Check if we have a placeholder pack, which indicates we're
8222 in the context of a introduction list. In that case we want
8223 to match this pack to the single placeholder. */
8224 else if (arg_idx
< nargs
8225 && TREE_CODE (TREE_VEC_ELT (inner_args
, arg_idx
)) == WILDCARD_DECL
8226 && WILDCARD_PACK_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
8228 nargs
= arg_idx
+ 1;
8229 packed_args
= make_tree_vec (1);
8232 packed_args
= make_tree_vec (nargs
- arg_idx
);
8234 /* Convert the remaining arguments, which will be a part of the
8235 parameter pack "parm". */
8236 int first_pack_arg
= arg_idx
;
8237 for (; arg_idx
< nargs
; ++arg_idx
)
8239 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
8240 tree actual_parm
= TREE_VALUE (parm
);
8241 int pack_idx
= arg_idx
- first_pack_arg
;
8245 /* Once we've packed as many args as we have types, stop. */
8246 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
8248 else if (PACK_EXPANSION_P (arg
))
8249 /* We don't know how many args we have yet, just
8250 use the unconverted ones for now. */
8253 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
8256 if (arg
== error_mark_node
)
8258 if (complain
& tf_error
)
8259 error ("template argument %d is invalid", arg_idx
+ 1);
8262 arg
= convert_template_argument (actual_parm
,
8263 arg
, new_args
, complain
, parm_idx
,
8265 if (arg
== error_mark_node
)
8267 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
8270 if (arg_idx
- first_pack_arg
< TREE_VEC_LENGTH (packed_args
)
8271 && TREE_VEC_LENGTH (packed_args
) > 0)
8273 if (complain
& tf_error
)
8274 error ("wrong number of template arguments (%d, should be %d)",
8275 arg_idx
- first_pack_arg
, TREE_VEC_LENGTH (packed_args
));
8276 return error_mark_node
;
8279 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
8280 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
8281 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
8284 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
8285 TREE_CONSTANT (argument_pack
) = 1;
8288 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
8290 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
8291 TREE_VEC_LENGTH (packed_args
));
8292 return argument_pack
;
8295 /* Returns the number of pack expansions in the template argument vector
8299 pack_expansion_args_count (tree args
)
8304 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
8306 tree elt
= TREE_VEC_ELT (args
, i
);
8307 if (elt
&& PACK_EXPANSION_P (elt
))
8313 /* Convert all template arguments to their appropriate types, and
8314 return a vector containing the innermost resulting template
8315 arguments. If any error occurs, return error_mark_node. Error and
8316 warning messages are issued under control of COMPLAIN.
8318 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
8319 for arguments not specified in ARGS. Otherwise, if
8320 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
8321 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
8322 USE_DEFAULT_ARGS is false, then all arguments must be specified in
8326 coerce_template_parms (tree parms
,
8329 tsubst_flags_t complain
,
8330 bool require_all_args
,
8331 bool use_default_args
)
8333 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
8334 tree orig_inner_args
;
8337 tree new_inner_args
;
8339 /* When used as a boolean value, indicates whether this is a
8340 variadic template parameter list. Since it's an int, we can also
8341 subtract it from nparms to get the number of non-variadic
8344 int variadic_args_p
= 0;
8345 int post_variadic_parms
= 0;
8347 /* Adjustment to nparms for fixed parameter packs. */
8348 int fixed_pack_adjust
= 0;
8349 int fixed_packs
= 0;
8352 /* Likewise for parameters with default arguments. */
8355 if (args
== error_mark_node
)
8356 return error_mark_node
;
8358 nparms
= TREE_VEC_LENGTH (parms
);
8360 /* Determine if there are any parameter packs or default arguments. */
8361 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
8363 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
8365 ++post_variadic_parms
;
8366 if (template_parameter_pack_p (TREE_VALUE (parm
)))
8368 if (TREE_PURPOSE (parm
))
8372 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
8373 /* If there are no parameters that follow a parameter pack, we need to
8374 expand any argument packs so that we can deduce a parameter pack from
8375 some non-packed args followed by an argument pack, as in variadic85.C.
8376 If there are such parameters, we need to leave argument packs intact
8377 so the arguments are assigned properly. This can happen when dealing
8378 with a nested class inside a partial specialization of a class
8379 template, as in variadic92.C, or when deducing a template parameter pack
8380 from a sub-declarator, as in variadic114.C. */
8381 if (!post_variadic_parms
)
8382 inner_args
= expand_template_argument_pack (inner_args
);
8384 /* Count any pack expansion args. */
8385 variadic_args_p
= pack_expansion_args_count (inner_args
);
8387 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
8388 if ((nargs
- variadic_args_p
> nparms
&& !variadic_p
)
8389 || (nargs
< nparms
- variadic_p
8392 && (!use_default_args
8393 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
8394 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
8397 if (complain
& tf_error
)
8399 if (variadic_p
|| default_p
)
8401 nparms
-= variadic_p
+ default_p
;
8402 error ("wrong number of template arguments "
8403 "(%d, should be at least %d)", nargs
, nparms
);
8406 error ("wrong number of template arguments "
8407 "(%d, should be %d)", nargs
, nparms
);
8410 inform (DECL_SOURCE_LOCATION (in_decl
),
8411 "provided for %qD", in_decl
);
8414 return error_mark_node
;
8416 /* We can't pass a pack expansion to a non-pack parameter of an alias
8417 template (DR 1430). */
8419 && (DECL_ALIAS_TEMPLATE_P (in_decl
)
8420 || concept_template_p (in_decl
))
8422 && nargs
- variadic_args_p
< nparms
- variadic_p
)
8424 if (complain
& tf_error
)
8426 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
8428 tree arg
= TREE_VEC_ELT (inner_args
, i
);
8429 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
8431 if (PACK_EXPANSION_P (arg
)
8432 && !template_parameter_pack_p (parm
))
8434 if (DECL_ALIAS_TEMPLATE_P (in_decl
))
8435 error_at (location_of (arg
),
8436 "pack expansion argument for non-pack parameter "
8437 "%qD of alias template %qD", parm
, in_decl
);
8439 error_at (location_of (arg
),
8440 "pack expansion argument for non-pack parameter "
8441 "%qD of concept %qD", parm
, in_decl
);
8442 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
8449 return error_mark_node
;
8452 /* We need to evaluate the template arguments, even though this
8453 template-id may be nested within a "sizeof". */
8456 new_inner_args
= make_tree_vec (nparms
);
8457 new_args
= add_outermost_template_args (args
, new_inner_args
);
8458 int pack_adjust
= 0;
8459 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
8464 /* Get the Ith template parameter. */
8465 parm
= TREE_VEC_ELT (parms
, parm_idx
);
8467 if (parm
== error_mark_node
)
8469 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
8473 /* Calculate the next argument. */
8474 if (arg_idx
< nargs
)
8475 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
8479 if (template_parameter_pack_p (TREE_VALUE (parm
))
8480 && (arg
|| !(complain
& tf_partial
))
8481 && !(arg
&& ARGUMENT_PACK_P (arg
)))
8483 /* Some arguments will be placed in the
8484 template parameter pack PARM. */
8485 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
8486 inner_args
, arg_idx
,
8490 if (arg
== NULL_TREE
)
8492 /* We don't know how many args we have yet, just use the
8493 unconverted (and still packed) ones for now. */
8494 new_inner_args
= orig_inner_args
;
8499 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
8501 /* Store this argument. */
8502 if (arg
== error_mark_node
)
8505 /* We are done with all of the arguments. */
8511 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
8512 arg_idx
+= pack_adjust
;
8513 if (fixed_parameter_pack_p (TREE_VALUE (parm
)))
8516 fixed_pack_adjust
+= pack_adjust
;
8524 if (PACK_EXPANSION_P (arg
))
8526 /* "If every valid specialization of a variadic template
8527 requires an empty template parameter pack, the template is
8528 ill-formed, no diagnostic required." So check that the
8529 pattern works with this parameter. */
8530 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
8531 tree conv
= convert_template_argument (TREE_VALUE (parm
),
8535 if (conv
== error_mark_node
)
8537 if (complain
& tf_error
)
8538 inform (input_location
, "so any instantiation with a "
8539 "non-empty parameter pack would be ill-formed");
8542 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
8543 /* Recover from missing typename. */
8544 TREE_VEC_ELT (inner_args
, arg_idx
)
8545 = make_pack_expansion (conv
, complain
);
8547 /* We don't know how many args we have yet, just
8548 use the unconverted ones for now. */
8549 new_inner_args
= inner_args
;
8554 else if (require_all_args
)
8556 /* There must be a default arg in this case. */
8557 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
8559 /* The position of the first default template argument,
8560 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
8562 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8563 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8564 arg_idx
- pack_adjust
);
8569 if (arg
== error_mark_node
)
8571 if (complain
& tf_error
)
8572 error ("template argument %d is invalid", arg_idx
+ 1);
8576 /* This can occur if there was an error in the template
8577 parameter list itself (which we would already have
8578 reported) that we are trying to recover from, e.g., a class
8579 template with a parameter list such as
8580 template<typename..., typename> (cpp0x/variadic150.C). */
8583 /* This can also happen with a fixed parameter pack (71834). */
8584 if (arg_idx
>= nargs
)
8588 arg
= convert_template_argument (TREE_VALUE (parm
),
8589 arg
, new_args
, complain
,
8592 if (arg
== error_mark_node
)
8594 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
8597 if (missing
|| arg_idx
< nargs
- variadic_args_p
)
8599 /* If we had fixed parameter packs, we didn't know how many arguments we
8600 actually needed earlier; now we do. */
8601 nparms
+= fixed_pack_adjust
;
8602 variadic_p
-= fixed_packs
;
8606 if (arg_idx
< nargs
)
8608 /* We had some pack expansion arguments that will only work if the packs
8609 are empty, but wait until instantiation time to complain.
8610 See variadic-ttp3.C. */
8611 int len
= nparms
+ (nargs
- arg_idx
);
8612 tree args
= make_tree_vec (len
);
8614 for (; i
< nparms
; ++i
)
8615 TREE_VEC_ELT (args
, i
) = TREE_VEC_ELT (new_inner_args
, i
);
8616 for (; i
< len
; ++i
, ++arg_idx
)
8617 TREE_VEC_ELT (args
, i
) = TREE_VEC_ELT (inner_args
,
8618 arg_idx
- pack_adjust
);
8619 new_inner_args
= args
;
8624 gcc_assert (!(complain
& tf_error
) || seen_error ());
8625 return error_mark_node
;
8628 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8629 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8630 TREE_VEC_LENGTH (new_inner_args
));
8632 return new_inner_args
;
8635 /* Convert all template arguments to their appropriate types, and
8636 return a vector containing the innermost resulting template
8637 arguments. If any error occurs, return error_mark_node. Error and
8638 warning messages are not issued.
8640 Note that no function argument deduction is performed, and default
8641 arguments are used to fill in unspecified arguments. */
8643 coerce_template_parms (tree parms
, tree args
, tree in_decl
)
8645 return coerce_template_parms (parms
, args
, in_decl
, tf_none
, true, true);
8648 /* Convert all template arguments to their appropriate type, and
8649 instantiate default arguments as needed. This returns a vector
8650 containing the innermost resulting template arguments, or
8651 error_mark_node if unsuccessful. */
8653 coerce_template_parms (tree parms
, tree args
, tree in_decl
,
8654 tsubst_flags_t complain
)
8656 return coerce_template_parms (parms
, args
, in_decl
, complain
, true, true);
8659 /* Like coerce_template_parms. If PARMS represents all template
8660 parameters levels, this function returns a vector of vectors
8661 representing all the resulting argument levels. Note that in this
8662 case, only the innermost arguments are coerced because the
8663 outermost ones are supposed to have been coerced already.
8665 Otherwise, if PARMS represents only (the innermost) vector of
8666 parameters, this function returns a vector containing just the
8667 innermost resulting arguments. */
8670 coerce_innermost_template_parms (tree parms
,
8673 tsubst_flags_t complain
,
8674 bool require_all_args
,
8675 bool use_default_args
)
8677 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
8678 int args_depth
= TMPL_ARGS_DEPTH (args
);
8681 if (parms_depth
> 1)
8683 coerced_args
= make_tree_vec (parms_depth
);
8687 for (level
= parms
, cur_depth
= parms_depth
;
8688 parms_depth
> 0 && level
!= NULL_TREE
;
8689 level
= TREE_CHAIN (level
), --cur_depth
)
8692 if (cur_depth
== args_depth
)
8693 l
= coerce_template_parms (TREE_VALUE (level
),
8694 args
, in_decl
, complain
,
8698 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
8700 if (l
== error_mark_node
)
8701 return error_mark_node
;
8703 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
8707 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
8708 args
, in_decl
, complain
,
8711 return coerced_args
;
8714 /* Returns 1 if template args OT and NT are equivalent. */
8717 template_args_equal (tree ot
, tree nt
, bool partial_order
/* = false */)
8721 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
8723 if (nt
== any_targ_node
|| ot
== any_targ_node
)
8726 if (TREE_CODE (nt
) == TREE_VEC
)
8727 /* For member templates */
8728 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
8729 else if (PACK_EXPANSION_P (ot
))
8730 return (PACK_EXPANSION_P (nt
)
8731 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
8732 PACK_EXPANSION_PATTERN (nt
))
8733 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
8734 PACK_EXPANSION_EXTRA_ARGS (nt
)));
8735 else if (ARGUMENT_PACK_P (ot
))
8740 if (!ARGUMENT_PACK_P (nt
))
8743 opack
= ARGUMENT_PACK_ARGS (ot
);
8744 npack
= ARGUMENT_PACK_ARGS (nt
);
8745 len
= TREE_VEC_LENGTH (opack
);
8746 if (TREE_VEC_LENGTH (npack
) != len
)
8748 for (i
= 0; i
< len
; ++i
)
8749 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
8750 TREE_VEC_ELT (npack
, i
)))
8754 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
8756 else if (TYPE_P (nt
))
8760 /* Don't treat an alias template specialization with dependent
8761 arguments as equivalent to its underlying type when used as a
8762 template argument; we need them to be distinct so that we
8763 substitute into the specialization arguments at instantiation
8764 time. And aliases can't be equivalent without being ==, so
8765 we don't need to look any deeper.
8767 During partial ordering, however, we need to treat them normally so
8768 that we can order uses of the same alias with different
8769 cv-qualification (79960). */
8771 && (TYPE_ALIAS_P (nt
) || TYPE_ALIAS_P (ot
)))
8774 return same_type_p (ot
, nt
);
8776 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
8780 /* Try to treat a template non-type argument that has been converted
8781 to the parameter type as equivalent to one that hasn't yet. */
8782 for (enum tree_code code1
= TREE_CODE (ot
);
8783 CONVERT_EXPR_CODE_P (code1
)
8784 || code1
== NON_LVALUE_EXPR
;
8785 code1
= TREE_CODE (ot
))
8786 ot
= TREE_OPERAND (ot
, 0);
8787 for (enum tree_code code2
= TREE_CODE (nt
);
8788 CONVERT_EXPR_CODE_P (code2
)
8789 || code2
== NON_LVALUE_EXPR
;
8790 code2
= TREE_CODE (nt
))
8791 nt
= TREE_OPERAND (nt
, 0);
8793 return cp_tree_equal (ot
, nt
);
8797 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
8798 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
8799 NEWARG_PTR with the offending arguments if they are non-NULL. */
8802 comp_template_args (tree oldargs
, tree newargs
,
8803 tree
*oldarg_ptr
, tree
*newarg_ptr
,
8808 if (oldargs
== newargs
)
8811 if (!oldargs
|| !newargs
)
8814 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
8817 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
8819 tree nt
= TREE_VEC_ELT (newargs
, i
);
8820 tree ot
= TREE_VEC_ELT (oldargs
, i
);
8822 if (! template_args_equal (ot
, nt
, partial_order
))
8824 if (oldarg_ptr
!= NULL
)
8826 if (newarg_ptr
!= NULL
)
8835 comp_template_args_porder (tree oargs
, tree nargs
)
8837 return comp_template_args (oargs
, nargs
, NULL
, NULL
, true);
8840 /* Implement a freelist interface for objects of type T.
8842 Head is a separate object, rather than a regular member, so that we
8843 can define it as a GTY deletable pointer, which is highly
8844 desirable. A data member could be declared that way, but then the
8845 containing object would implicitly get GTY((user)), which would
8846 prevent us from instantiating freelists as global objects.
8847 Although this way we can create freelist global objects, they're
8848 such thin wrappers that instantiating temporaries at every use
8849 loses nothing and saves permanent storage for the freelist object.
8851 Member functions next, anew, poison and reinit have default
8852 implementations that work for most of the types we're interested
8853 in, but if they don't work for some type, they should be explicitly
8854 specialized. See the comments before them for requirements, and
8855 the example specializations for the tree_list_freelist. */
8856 template <typename T
>
8859 /* Return the next object in a chain. We could just do type
8860 punning, but if we access the object with its underlying type, we
8861 avoid strict-aliasing trouble. This needs only work between
8862 poison and reinit. */
8863 static T
*&next (T
*obj
) { return obj
->next
; }
8865 /* Return a newly allocated, uninitialized or minimally-initialized
8866 object of type T. Any initialization performed by anew should
8867 either remain across the life of the object and the execution of
8868 poison, or be redone by reinit. */
8869 static T
*anew () { return ggc_alloc
<T
> (); }
8871 /* Optionally scribble all over the bits holding the object, so that
8872 they become (mostly?) uninitialized memory. This is called while
8873 preparing to make the object part of the free list. */
8874 static void poison (T
*obj
) {
8875 T
*p ATTRIBUTE_UNUSED
= obj
;
8876 T
**q ATTRIBUTE_UNUSED
= &next (obj
);
8878 #ifdef ENABLE_GC_CHECKING
8879 /* Poison the data, to indicate the data is garbage. */
8880 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (p
, sizeof (*p
)));
8881 memset (p
, 0xa5, sizeof (*p
));
8883 /* Let valgrind know the object is free. */
8884 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (p
, sizeof (*p
)));
8886 /* Let valgrind know the next portion of the object is available,
8887 but uninitialized. */
8888 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (q
, sizeof (*q
)));
8891 /* Bring an object that underwent at least one lifecycle after anew
8892 and before the most recent free and poison, back to a usable
8893 state, reinitializing whatever is needed for it to be
8894 functionally equivalent to an object just allocated and returned
8895 by anew. This may poison or clear the next field, used by
8896 freelist housekeeping after poison was called. */
8897 static void reinit (T
*obj
) {
8898 T
**q ATTRIBUTE_UNUSED
= &next (obj
);
8900 #ifdef ENABLE_GC_CHECKING
8901 memset (q
, 0xa5, sizeof (*q
));
8903 /* Let valgrind know the entire object is available, but
8905 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (*obj
)));
8908 /* Reference a GTY-deletable pointer that points to the first object
8909 in the free list proper. */
8912 /* Construct a freelist object chaining objects off of HEAD. */
8913 freelist (T
*&head
) : head(head
) {}
8915 /* Add OBJ to the free object list. The former head becomes OBJ's
8924 /* Take an object from the free list, if one is available, or
8925 allocate a new one. Objects taken from the free list should be
8926 regarded as filled with garbage, except for bits that are
8927 configured to be preserved across free and alloc. */
8942 /* Explicitly specialize the interfaces for freelist<tree_node>: we
8943 want to allocate a TREE_LIST using the usual interface, and ensure
8944 TREE_CHAIN remains functional. Alas, we have to duplicate a bit of
8945 build_tree_list logic in reinit, so this could go out of sync. */
8948 freelist
<tree_node
>::next (tree obj
)
8950 return TREE_CHAIN (obj
);
8954 freelist
<tree_node
>::anew ()
8956 return build_tree_list (NULL
, NULL
);
8960 freelist
<tree_node
>::poison (tree obj ATTRIBUTE_UNUSED
)
8962 int size ATTRIBUTE_UNUSED
= sizeof (tree_list
);
8963 tree p ATTRIBUTE_UNUSED
= obj
;
8964 tree_base
*b ATTRIBUTE_UNUSED
= &obj
->base
;
8965 tree
*q ATTRIBUTE_UNUSED
= &next (obj
);
8967 #ifdef ENABLE_GC_CHECKING
8968 gcc_checking_assert (TREE_CODE (obj
) == TREE_LIST
);
8970 /* Poison the data, to indicate the data is garbage. */
8971 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (p
, size
));
8972 memset (p
, 0xa5, size
);
8974 /* Let valgrind know the object is free. */
8975 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (p
, size
));
8976 /* But we still want to use the TREE_CODE and TREE_CHAIN parts. */
8977 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
8978 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (q
, sizeof (*q
)));
8980 #ifdef ENABLE_GC_CHECKING
8981 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (b
, sizeof (*b
)));
8982 /* Keep TREE_CHAIN functional. */
8983 TREE_SET_CODE (obj
, TREE_LIST
);
8985 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
8990 freelist
<tree_node
>::reinit (tree obj ATTRIBUTE_UNUSED
)
8992 tree_base
*b ATTRIBUTE_UNUSED
= &obj
->base
;
8994 #ifdef ENABLE_GC_CHECKING
8995 gcc_checking_assert (TREE_CODE (obj
) == TREE_LIST
);
8996 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (tree_list
)));
8997 memset (obj
, 0, sizeof (tree_list
));
9000 /* Let valgrind know the entire object is available, but
9002 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (tree_list
)));
9004 #ifdef ENABLE_GC_CHECKING
9005 TREE_SET_CODE (obj
, TREE_LIST
);
9007 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
9011 /* Point to the first object in the TREE_LIST freelist. */
9012 static GTY((deletable
)) tree tree_list_freelist_head
;
9013 /* Return the/an actual TREE_LIST freelist. */
9014 static inline freelist
<tree_node
>
9015 tree_list_freelist ()
9017 return tree_list_freelist_head
;
9020 /* Point to the first object in the tinst_level freelist. */
9021 static GTY((deletable
)) tinst_level
*tinst_level_freelist_head
;
9022 /* Return the/an actual tinst_level freelist. */
9023 static inline freelist
<tinst_level
>
9024 tinst_level_freelist ()
9026 return tinst_level_freelist_head
;
9029 /* Point to the first object in the pending_template freelist. */
9030 static GTY((deletable
)) pending_template
*pending_template_freelist_head
;
9031 /* Return the/an actual pending_template freelist. */
9032 static inline freelist
<pending_template
>
9033 pending_template_freelist ()
9035 return pending_template_freelist_head
;
9038 /* Build the TREE_LIST object out of a split list, store it
9039 permanently, and return it. */
9041 tinst_level::to_list ()
9043 gcc_assert (split_list_p ());
9044 tree ret
= tree_list_freelist ().alloc ();
9045 TREE_PURPOSE (ret
) = tldcl
;
9046 TREE_VALUE (ret
) = targs
;
9049 gcc_assert (tree_list_p ());
9053 const unsigned short tinst_level::refcount_infinity
;
9055 /* Increment OBJ's refcount unless it is already infinite. */
9056 static tinst_level
*
9057 inc_refcount_use (tinst_level
*obj
)
9059 if (obj
&& obj
->refcount
!= tinst_level::refcount_infinity
)
9064 /* Release storage for OBJ and node, if it's a TREE_LIST. */
9066 tinst_level::free (tinst_level
*obj
)
9068 if (obj
->tree_list_p ())
9069 tree_list_freelist ().free (obj
->get_node ());
9070 tinst_level_freelist ().free (obj
);
9073 /* Decrement OBJ's refcount if not infinite. If it reaches zero, release
9074 OBJ's DECL and OBJ, and start over with the tinst_level object that
9075 used to be referenced by OBJ's NEXT. */
9077 dec_refcount_use (tinst_level
*obj
)
9080 && obj
->refcount
!= tinst_level::refcount_infinity
9081 && !--obj
->refcount
)
9083 tinst_level
*next
= obj
->next
;
9084 tinst_level::free (obj
);
9089 /* Modify PTR so that it points to OBJ, adjusting the refcounts of OBJ
9090 and of the former PTR. Omitting the second argument is equivalent
9091 to passing (T*)NULL; this is allowed because passing the
9092 zero-valued integral constant NULL confuses type deduction and/or
9093 overload resolution. */
9094 template <typename T
>
9096 set_refcount_ptr (T
*& ptr
, T
*obj
= NULL
)
9099 ptr
= inc_refcount_use (obj
);
9100 dec_refcount_use (save
);
9104 add_pending_template (tree d
)
9106 tree ti
= (TYPE_P (d
)
9107 ? CLASSTYPE_TEMPLATE_INFO (d
)
9108 : DECL_TEMPLATE_INFO (d
));
9109 struct pending_template
*pt
;
9112 if (TI_PENDING_TEMPLATE_FLAG (ti
))
9115 /* We are called both from instantiate_decl, where we've already had a
9116 tinst_level pushed, and instantiate_template, where we haven't.
9118 gcc_assert (TREE_CODE (d
) != TREE_LIST
);
9119 level
= !current_tinst_level
9120 || current_tinst_level
->maybe_get_node () != d
;
9123 push_tinst_level (d
);
9125 pt
= pending_template_freelist ().alloc ();
9128 set_refcount_ptr (pt
->tinst
, current_tinst_level
);
9129 if (last_pending_template
)
9130 last_pending_template
->next
= pt
;
9132 pending_templates
= pt
;
9134 last_pending_template
= pt
;
9136 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
9143 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
9144 ARGLIST. Valid choices for FNS are given in the cp-tree.def
9145 documentation for TEMPLATE_ID_EXPR. */
9148 lookup_template_function (tree fns
, tree arglist
)
9150 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
9151 return error_mark_node
;
9153 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
9155 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
9157 error ("%q#D is not a function template", fns
);
9158 return error_mark_node
;
9161 if (BASELINK_P (fns
))
9163 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
9165 BASELINK_FUNCTIONS (fns
),
9170 return build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fns
, arglist
);
9173 /* Within the scope of a template class S<T>, the name S gets bound
9174 (in build_self_reference) to a TYPE_DECL for the class, not a
9175 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
9176 or one of its enclosing classes, and that type is a template,
9177 return the associated TEMPLATE_DECL. Otherwise, the original
9180 Also handle the case when DECL is a TREE_LIST of ambiguous
9181 injected-class-names from different bases. */
9184 maybe_get_template_decl_from_type_decl (tree decl
)
9186 if (decl
== NULL_TREE
)
9189 /* DR 176: A lookup that finds an injected-class-name (10.2
9190 [class.member.lookup]) can result in an ambiguity in certain cases
9191 (for example, if it is found in more than one base class). If all of
9192 the injected-class-names that are found refer to specializations of
9193 the same class template, and if the name is followed by a
9194 template-argument-list, the reference refers to the class template
9195 itself and not a specialization thereof, and is not ambiguous. */
9196 if (TREE_CODE (decl
) == TREE_LIST
)
9198 tree t
, tmpl
= NULL_TREE
;
9199 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
9201 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
9204 else if (tmpl
!= elt
)
9207 if (tmpl
&& t
== NULL_TREE
)
9213 return (decl
!= NULL_TREE
9214 && DECL_SELF_REFERENCE_P (decl
)
9215 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
9216 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
9219 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
9220 parameters, find the desired type.
9222 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
9224 IN_DECL, if non-NULL, is the template declaration we are trying to
9227 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
9228 the class we are looking up.
9230 Issue error and warning messages under control of COMPLAIN.
9232 If the template class is really a local class in a template
9233 function, then the FUNCTION_CONTEXT is the function in which it is
9236 ??? Note that this function is currently called *twice* for each
9237 template-id: the first time from the parser, while creating the
9238 incomplete type (finish_template_type), and the second type during the
9239 real instantiation (instantiate_template_class). This is surely something
9240 that we want to avoid. It also causes some problems with argument
9241 coercion (see convert_nontype_argument for more information on this). */
9244 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
9245 int entering_scope
, tsubst_flags_t complain
)
9247 tree templ
= NULL_TREE
, parmlist
;
9254 if (identifier_p (d1
))
9256 tree value
= innermost_non_namespace_value (d1
);
9257 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
9262 push_decl_namespace (context
);
9263 templ
= lookup_name (d1
);
9264 templ
= maybe_get_template_decl_from_type_decl (templ
);
9266 pop_decl_namespace ();
9269 context
= DECL_CONTEXT (templ
);
9271 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
9273 tree type
= TREE_TYPE (d1
);
9275 /* If we are declaring a constructor, say A<T>::A<T>, we will get
9276 an implicit typename for the second A. Deal with it. */
9277 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
9278 type
= TREE_TYPE (type
);
9280 if (CLASSTYPE_TEMPLATE_INFO (type
))
9282 templ
= CLASSTYPE_TI_TEMPLATE (type
);
9283 d1
= DECL_NAME (templ
);
9286 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
9287 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
9289 templ
= TYPE_TI_TEMPLATE (d1
);
9290 d1
= DECL_NAME (templ
);
9292 else if (DECL_TYPE_TEMPLATE_P (d1
))
9295 d1
= DECL_NAME (templ
);
9296 context
= DECL_CONTEXT (templ
);
9298 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
9301 d1
= DECL_NAME (templ
);
9304 /* Issue an error message if we didn't find a template. */
9307 if (complain
& tf_error
)
9308 error ("%qT is not a template", d1
);
9309 return error_mark_node
;
9312 if (TREE_CODE (templ
) != TEMPLATE_DECL
9313 /* Make sure it's a user visible template, if it was named by
9315 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
9316 && !PRIMARY_TEMPLATE_P (templ
)))
9318 if (complain
& tf_error
)
9320 error ("non-template type %qT used as a template", d1
);
9322 error ("for template declaration %q+D", in_decl
);
9324 return error_mark_node
;
9327 complain
&= ~tf_user
;
9329 /* An alias that just changes the name of a template is equivalent to the
9330 other template, so if any of the arguments are pack expansions, strip
9331 the alias to avoid problems with a pack expansion passed to a non-pack
9332 alias template parameter (DR 1430). */
9333 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
9334 templ
= get_underlying_template (templ
);
9336 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
9339 tree arglist2
= coerce_template_args_for_ttp (templ
, arglist
, complain
);
9340 if (arglist2
== error_mark_node
9341 || (!uses_template_parms (arglist2
)
9342 && check_instantiated_args (templ
, arglist2
, complain
)))
9343 return error_mark_node
;
9345 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
9350 tree template_type
= TREE_TYPE (templ
);
9353 tree found
= NULL_TREE
;
9356 int is_dependent_type
;
9357 int use_partial_inst_tmpl
= false;
9359 if (template_type
== error_mark_node
)
9360 /* An error occurred while building the template TEMPL, and a
9361 diagnostic has most certainly been emitted for that
9362 already. Let's propagate that error. */
9363 return error_mark_node
;
9365 gen_tmpl
= most_general_template (templ
);
9366 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
9367 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
9368 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
9370 if (arg_depth
== 1 && parm_depth
> 1)
9372 /* We've been given an incomplete set of template arguments.
9375 template <class T> struct S1 {
9376 template <class U> struct S2 {};
9377 template <class U> struct S2<U*> {};
9380 we will be called with an ARGLIST of `U*', but the
9381 TEMPLATE will be `template <class T> template
9382 <class U> struct S1<T>::S2'. We must fill in the missing
9384 tree ti
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (templ
));
9385 arglist
= add_outermost_template_args (TI_ARGS (ti
), arglist
);
9386 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
9389 /* Now we should have enough arguments. */
9390 gcc_assert (parm_depth
== arg_depth
);
9392 /* From here on, we're only interested in the most general
9395 /* Calculate the BOUND_ARGS. These will be the args that are
9396 actually tsubst'd into the definition to create the
9398 arglist
= coerce_innermost_template_parms (parmlist
, arglist
, gen_tmpl
,
9400 /*require_all_args=*/true,
9401 /*use_default_args=*/true);
9403 if (arglist
== error_mark_node
)
9404 /* We were unable to bind the arguments. */
9405 return error_mark_node
;
9407 /* In the scope of a template class, explicit references to the
9408 template class refer to the type of the template, not any
9409 instantiation of it. For example, in:
9411 template <class T> class C { void f(C<T>); }
9413 the `C<T>' is just the same as `C'. Outside of the
9414 class, however, such a reference is an instantiation. */
9416 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
9417 || currently_open_class (template_type
))
9419 tree tinfo
= TYPE_TEMPLATE_INFO (template_type
);
9421 if (tinfo
&& comp_template_args (TI_ARGS (tinfo
), arglist
))
9422 return template_type
;
9425 /* If we already have this specialization, return it. */
9426 elt
.tmpl
= gen_tmpl
;
9428 elt
.spec
= NULL_TREE
;
9429 hash
= spec_hasher::hash (&elt
);
9430 entry
= type_specializations
->find_with_hash (&elt
, hash
);
9435 /* If the the template's constraints are not satisfied,
9436 then we cannot form a valid type.
9438 Note that the check is deferred until after the hash
9439 lookup. This prevents redundant checks on previously
9440 instantiated specializations. */
9441 if (flag_concepts
&& !constraints_satisfied_p (gen_tmpl
, arglist
))
9443 if (complain
& tf_error
)
9445 auto_diagnostic_group d
;
9446 error ("template constraint failure");
9447 diagnose_constraints (input_location
, gen_tmpl
, arglist
);
9449 return error_mark_node
;
9452 is_dependent_type
= uses_template_parms (arglist
);
9454 /* If the deduced arguments are invalid, then the binding
9456 if (!is_dependent_type
9457 && check_instantiated_args (gen_tmpl
,
9458 INNERMOST_TEMPLATE_ARGS (arglist
),
9460 return error_mark_node
;
9462 if (!is_dependent_type
9463 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
9464 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
9465 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
9467 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
9468 DECL_NAME (gen_tmpl
),
9469 /*tag_scope=*/ts_global
);
9473 context
= DECL_CONTEXT (gen_tmpl
);
9474 if (context
&& TYPE_P (context
))
9476 context
= tsubst_aggr_type (context
, arglist
, complain
, in_decl
, true);
9477 context
= complete_type (context
);
9480 context
= tsubst (context
, arglist
, complain
, in_decl
);
9482 if (context
== error_mark_node
)
9483 return error_mark_node
;
9486 context
= global_namespace
;
9488 /* Create the type. */
9489 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9491 /* The user referred to a specialization of an alias
9492 template represented by GEN_TMPL.
9494 [temp.alias]/2 says:
9496 When a template-id refers to the specialization of an
9497 alias template, it is equivalent to the associated
9498 type obtained by substitution of its
9499 template-arguments for the template-parameters in the
9500 type-id of the alias template. */
9502 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
9503 /* Note that the call above (by indirectly calling
9504 register_specialization in tsubst_decl) registers the
9505 TYPE_DECL representing the specialization of the alias
9506 template. So next time someone substitutes ARGLIST for
9507 the template parms into the alias template (GEN_TMPL),
9508 she'll get that TYPE_DECL back. */
9510 if (t
== error_mark_node
)
9513 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
9515 if (!is_dependent_type
)
9517 set_current_access_from_decl (TYPE_NAME (template_type
));
9518 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
9519 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
9520 arglist
, complain
, in_decl
),
9521 tsubst_attributes (TYPE_ATTRIBUTES (template_type
),
9522 arglist
, complain
, in_decl
),
9523 SCOPED_ENUM_P (template_type
), NULL
);
9525 if (t
== error_mark_node
)
9530 /* We don't want to call start_enum for this type, since
9531 the values for the enumeration constants may involve
9532 template parameters. And, no one should be interested
9533 in the enumeration constants for such a type. */
9534 t
= cxx_make_type (ENUMERAL_TYPE
);
9535 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
9537 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
9538 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
9539 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
9541 else if (CLASS_TYPE_P (template_type
))
9543 /* Lambda closures are regenerated in tsubst_lambda_expr, not
9544 instantiated here. */
9545 gcc_assert (!LAMBDA_TYPE_P (template_type
));
9547 t
= make_class_type (TREE_CODE (template_type
));
9548 CLASSTYPE_DECLARED_CLASS (t
)
9549 = CLASSTYPE_DECLARED_CLASS (template_type
);
9550 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
9552 /* A local class. Make sure the decl gets registered properly. */
9553 if (context
== current_function_decl
)
9554 if (pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
)
9556 return error_mark_node
;
9558 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
9559 /* This instantiation is another name for the primary
9560 template type. Set the TYPE_CANONICAL field
9562 TYPE_CANONICAL (t
) = template_type
;
9563 else if (any_template_arguments_need_structural_equality_p (arglist
))
9564 /* Some of the template arguments require structural
9565 equality testing, so this template class requires
9566 structural equality testing. */
9567 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9572 /* If we called start_enum or pushtag above, this information
9573 will already be set up. */
9576 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
9578 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
9579 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
9580 DECL_SOURCE_LOCATION (type_decl
)
9581 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
9584 type_decl
= TYPE_NAME (t
);
9586 if (CLASS_TYPE_P (template_type
))
9588 TREE_PRIVATE (type_decl
)
9589 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
9590 TREE_PROTECTED (type_decl
)
9591 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
9592 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
9594 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
9595 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
9599 if (OVERLOAD_TYPE_P (t
)
9600 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9602 static const char *tags
[] = {"abi_tag", "may_alias"};
9604 for (unsigned ix
= 0; ix
!= 2; ix
++)
9607 = lookup_attribute (tags
[ix
], TYPE_ATTRIBUTES (template_type
));
9611 = tree_cons (TREE_PURPOSE (attributes
),
9612 TREE_VALUE (attributes
),
9613 TYPE_ATTRIBUTES (t
));
9617 /* Let's consider the explicit specialization of a member
9618 of a class template specialization that is implicitly instantiated,
9623 template<class U> struct M {}; //#0
9628 struct S<int>::M<char> //#1
9632 [temp.expl.spec]/4 says this is valid.
9634 In this case, when we write:
9637 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
9640 When we encounter #1, we want to store the partial instantiation
9641 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
9643 For all cases other than this "explicit specialization of member of a
9644 class template", we just want to store the most general template into
9645 the CLASSTYPE_TI_TEMPLATE of M.
9647 This case of "explicit specialization of member of a class template"
9649 1/ the enclosing class is an instantiation of, and therefore not
9650 the same as, the context of the most general template, and
9651 2/ we aren't looking at the partial instantiation itself, i.e.
9652 the innermost arguments are not the same as the innermost parms of
9653 the most general template.
9655 So it's only when 1/ and 2/ happens that we want to use the partial
9656 instantiation of the member template in lieu of its most general
9659 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
9660 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
9661 /* the enclosing class must be an instantiation... */
9662 && CLASS_TYPE_P (context
)
9663 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
9665 TREE_VEC_LENGTH (arglist
)--;
9666 ++processing_template_decl
;
9667 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (gen_tmpl
));
9668 tree partial_inst_args
=
9669 tsubst (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
)),
9670 arglist
, complain
, NULL_TREE
);
9671 --processing_template_decl
;
9672 TREE_VEC_LENGTH (arglist
)++;
9673 if (partial_inst_args
== error_mark_node
)
9674 return error_mark_node
;
9675 use_partial_inst_tmpl
=
9676 /*...and we must not be looking at the partial instantiation
9678 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
9682 if (!use_partial_inst_tmpl
)
9683 /* This case is easy; there are no member templates involved. */
9687 /* This is a full instantiation of a member template. Find
9688 the partial instantiation of which this is an instance. */
9690 /* Temporarily reduce by one the number of levels in the ARGLIST
9691 so as to avoid comparing the last set of arguments. */
9692 TREE_VEC_LENGTH (arglist
)--;
9693 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
9694 TREE_VEC_LENGTH (arglist
)++;
9695 /* FOUND is either a proper class type, or an alias
9696 template specialization. In the later case, it's a
9697 TYPE_DECL, resulting from the substituting of arguments
9698 for parameters in the TYPE_DECL of the alias template
9699 done earlier. So be careful while getting the template
9701 found
= (TREE_CODE (found
) == TEMPLATE_DECL
9703 : (TREE_CODE (found
) == TYPE_DECL
9704 ? DECL_TI_TEMPLATE (found
)
9705 : CLASSTYPE_TI_TEMPLATE (found
)));
9707 if (DECL_CLASS_TEMPLATE_P (found
)
9708 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (found
)))
9710 /* If this partial instantiation is specialized, we want to
9711 use it for hash table lookup. */
9713 elt
.args
= arglist
= INNERMOST_TEMPLATE_ARGS (arglist
);
9714 hash
= spec_hasher::hash (&elt
);
9718 // Build template info for the new specialization.
9719 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
9722 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
9723 gcc_checking_assert (*slot
== NULL
);
9724 entry
= ggc_alloc
<spec_entry
> ();
9728 /* Note this use of the partial instantiation so we can check it
9729 later in maybe_process_partial_specialization. */
9730 DECL_TEMPLATE_INSTANTIATIONS (found
)
9731 = tree_cons (arglist
, t
,
9732 DECL_TEMPLATE_INSTANTIATIONS (found
));
9734 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
9735 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9736 /* Now that the type has been registered on the instantiations
9737 list, we set up the enumerators. Because the enumeration
9738 constants may involve the enumeration type itself, we make
9739 sure to register the type first, and then create the
9740 constants. That way, doing tsubst_expr for the enumeration
9741 constants won't result in recursive calls here; we'll find
9742 the instantiation and exit above. */
9743 tsubst_enum (template_type
, t
, arglist
);
9745 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
9746 /* If the type makes use of template parameters, the
9747 code that generates debugging information will crash. */
9748 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
9750 /* Possibly limit visibility based on template args. */
9751 TREE_PUBLIC (type_decl
) = 1;
9752 determine_visibility (type_decl
);
9754 inherit_targ_abi_tags (t
);
9760 /* Wrapper for lookup_template_class_1. */
9763 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
9764 int entering_scope
, tsubst_flags_t complain
)
9767 timevar_push (TV_TEMPLATE_INST
);
9768 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
9769 entering_scope
, complain
);
9770 timevar_pop (TV_TEMPLATE_INST
);
9774 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
9777 lookup_template_variable (tree templ
, tree arglist
)
9779 /* The type of the expression is NULL_TREE since the template-id could refer
9780 to an explicit or partial specialization. */
9781 tree type
= NULL_TREE
;
9782 if (flag_concepts
&& variable_concept_p (templ
))
9783 /* Except that concepts are always bool. */
9784 type
= boolean_type_node
;
9785 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
9788 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
9791 finish_template_variable (tree var
, tsubst_flags_t complain
)
9793 tree templ
= TREE_OPERAND (var
, 0);
9794 tree arglist
= TREE_OPERAND (var
, 1);
9796 /* We never want to return a VAR_DECL for a variable concept, since they
9797 aren't instantiated. In a template, leave the TEMPLATE_ID_EXPR alone. */
9798 bool concept_p
= flag_concepts
&& variable_concept_p (templ
);
9799 if (concept_p
&& processing_template_decl
)
9802 tree tmpl_args
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ
));
9803 arglist
= add_outermost_template_args (tmpl_args
, arglist
);
9805 templ
= most_general_template (templ
);
9806 tree parms
= DECL_TEMPLATE_PARMS (templ
);
9807 arglist
= coerce_innermost_template_parms (parms
, arglist
, templ
, complain
,
9809 /*use_default*/true);
9811 if (flag_concepts
&& !constraints_satisfied_p (templ
, arglist
))
9813 if (complain
& tf_error
)
9815 auto_diagnostic_group d
;
9816 error ("use of invalid variable template %qE", var
);
9817 diagnose_constraints (location_of (var
), templ
, arglist
);
9819 return error_mark_node
;
9822 /* If a template-id refers to a specialization of a variable
9823 concept, then the expression is true if and only if the
9824 concept's constraints are satisfied by the given template
9827 NOTE: This is an extension of Concepts Lite TS that
9828 allows constraints to be used in expressions. */
9831 tree decl
= DECL_TEMPLATE_RESULT (templ
);
9832 return evaluate_variable_concept (decl
, arglist
);
9835 return instantiate_template (templ
, arglist
, complain
);
9838 /* Construct a TEMPLATE_ID_EXPR for the given variable template TEMPL having
9839 TARGS template args, and instantiate it if it's not dependent. */
9842 lookup_and_finish_template_variable (tree templ
, tree targs
,
9843 tsubst_flags_t complain
)
9845 templ
= lookup_template_variable (templ
, targs
);
9846 if (!any_dependent_template_arguments_p (targs
))
9848 templ
= finish_template_variable (templ
, complain
);
9852 return convert_from_reference (templ
);
9861 /* True when we should also visit template parameters that occur in
9862 non-deduced contexts. */
9863 bool include_nondeduced_p
;
9864 hash_set
<tree
> *visited
;
9867 /* Called from for_each_template_parm via walk_tree. */
9870 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
9873 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
9874 tree_fn_t fn
= pfd
->fn
;
9875 void *data
= pfd
->data
;
9876 tree result
= NULL_TREE
;
9878 #define WALK_SUBTREE(NODE) \
9881 result = for_each_template_parm (NODE, fn, data, pfd->visited, \
9882 pfd->include_nondeduced_p, \
9884 if (result) goto out; \
9888 if (pfd
->any_fn
&& (*pfd
->any_fn
)(t
, data
))
9892 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
))
9893 WALK_SUBTREE (TYPE_CONTEXT (t
));
9895 switch (TREE_CODE (t
))
9898 if (TYPE_PTRMEMFUNC_P (t
))
9904 if (!TYPE_TEMPLATE_INFO (t
))
9907 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9911 WALK_SUBTREE (TYPE_MIN_VALUE (t
));
9912 WALK_SUBTREE (TYPE_MAX_VALUE (t
));
9916 /* Since we're not going to walk subtrees, we have to do this
9918 WALK_SUBTREE (TYPE_METHOD_BASETYPE (t
));
9922 /* Check the return type. */
9923 WALK_SUBTREE (TREE_TYPE (t
));
9925 /* Check the parameter types. Since default arguments are not
9926 instantiated until they are needed, the TYPE_ARG_TYPES may
9927 contain expressions that involve template parameters. But,
9928 no-one should be looking at them yet. And, once they're
9929 instantiated, they don't contain template parameters, so
9930 there's no point in looking at them then, either. */
9934 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
9935 WALK_SUBTREE (TREE_VALUE (parm
));
9937 /* Since we've already handled the TYPE_ARG_TYPES, we don't
9938 want walk_tree walking into them itself. */
9942 if (flag_noexcept_type
)
9944 tree spec
= TYPE_RAISES_EXCEPTIONS (t
);
9946 WALK_SUBTREE (TREE_PURPOSE (spec
));
9952 case UNDERLYING_TYPE
:
9953 if (pfd
->include_nondeduced_p
9954 && for_each_template_parm (TYPE_VALUES_RAW (t
), fn
, data
,
9956 pfd
->include_nondeduced_p
,
9958 return error_mark_node
;
9959 *walk_subtrees
= false;
9964 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
9965 WALK_SUBTREE (DECL_TI_ARGS (t
));
9970 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
))
9971 WALK_SUBTREE (DECL_INITIAL (t
));
9972 if (DECL_CONTEXT (t
)
9973 && pfd
->include_nondeduced_p
)
9974 WALK_SUBTREE (DECL_CONTEXT (t
));
9977 case BOUND_TEMPLATE_TEMPLATE_PARM
:
9978 /* Record template parameters such as `T' inside `TT<T>'. */
9979 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9982 case TEMPLATE_TEMPLATE_PARM
:
9983 case TEMPLATE_TYPE_PARM
:
9984 case TEMPLATE_PARM_INDEX
:
9985 if (fn
&& (*fn
)(t
, data
))
9992 /* A template template parameter is encountered. */
9993 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9994 WALK_SUBTREE (TREE_TYPE (t
));
9996 /* Already substituted template template parameter */
10000 case TYPENAME_TYPE
:
10001 /* A template-id in a TYPENAME_TYPE might be a deduced context after
10002 partial instantiation. */
10003 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t
));
10007 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
10008 && pfd
->include_nondeduced_p
)
10009 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
10013 case COMPONENT_REF
:
10014 /* If there's no type, then this thing must be some expression
10015 involving template parameters. */
10016 if (!fn
&& !TREE_TYPE (t
))
10017 return error_mark_node
;
10022 case IMPLICIT_CONV_EXPR
:
10023 case REINTERPRET_CAST_EXPR
:
10024 case CONST_CAST_EXPR
:
10025 case STATIC_CAST_EXPR
:
10026 case DYNAMIC_CAST_EXPR
:
10030 case PSEUDO_DTOR_EXPR
:
10032 return error_mark_node
;
10039 #undef WALK_SUBTREE
10041 /* We didn't find any template parameters we liked. */
10046 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
10047 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
10048 call FN with the parameter and the DATA.
10049 If FN returns nonzero, the iteration is terminated, and
10050 for_each_template_parm returns 1. Otherwise, the iteration
10051 continues. If FN never returns a nonzero value, the value
10052 returned by for_each_template_parm is 0. If FN is NULL, it is
10053 considered to be the function which always returns 1.
10055 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
10056 parameters that occur in non-deduced contexts. When false, only
10057 visits those template parameters that can be deduced. */
10060 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
10061 hash_set
<tree
> *visited
,
10062 bool include_nondeduced_p
,
10065 struct pair_fn_data pfd
;
10070 pfd
.any_fn
= any_fn
;
10072 pfd
.include_nondeduced_p
= include_nondeduced_p
;
10074 /* Walk the tree. (Conceptually, we would like to walk without
10075 duplicates, but for_each_template_parm_r recursively calls
10076 for_each_template_parm, so we would need to reorganize a fair
10077 bit to use walk_tree_without_duplicates, so we keep our own
10080 pfd
.visited
= visited
;
10082 pfd
.visited
= new hash_set
<tree
>;
10083 result
= cp_walk_tree (&t
,
10084 for_each_template_parm_r
,
10091 delete pfd
.visited
;
10098 /* Returns true if T depends on any template parameter. */
10101 uses_template_parms (tree t
)
10103 if (t
== NULL_TREE
)
10107 int saved_processing_template_decl
;
10109 saved_processing_template_decl
= processing_template_decl
;
10110 if (!saved_processing_template_decl
)
10111 processing_template_decl
= 1;
10113 dependent_p
= dependent_type_p (t
);
10114 else if (TREE_CODE (t
) == TREE_VEC
)
10115 dependent_p
= any_dependent_template_arguments_p (t
);
10116 else if (TREE_CODE (t
) == TREE_LIST
)
10117 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
10118 || uses_template_parms (TREE_CHAIN (t
)));
10119 else if (TREE_CODE (t
) == TYPE_DECL
)
10120 dependent_p
= dependent_type_p (TREE_TYPE (t
));
10121 else if (DECL_P (t
)
10123 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
10124 || TREE_CODE (t
) == OVERLOAD
10126 || identifier_p (t
)
10127 || TREE_CODE (t
) == TRAIT_EXPR
10128 || TREE_CODE (t
) == CONSTRUCTOR
10129 || CONSTANT_CLASS_P (t
))
10130 dependent_p
= (type_dependent_expression_p (t
)
10131 || value_dependent_expression_p (t
));
10134 gcc_assert (t
== error_mark_node
);
10135 dependent_p
= false;
10138 processing_template_decl
= saved_processing_template_decl
;
10140 return dependent_p
;
10143 /* Returns true iff current_function_decl is an incompletely instantiated
10144 template. Useful instead of processing_template_decl because the latter
10145 is set to 0 during instantiate_non_dependent_expr. */
10148 in_template_function (void)
10150 tree fn
= current_function_decl
;
10152 ++processing_template_decl
;
10153 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
10154 && DECL_TEMPLATE_INFO (fn
)
10155 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
10156 --processing_template_decl
;
10160 /* Returns true if T depends on any template parameter with level LEVEL. */
10163 uses_template_parms_level (tree t
, int level
)
10165 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
10166 /*include_nondeduced_p=*/true);
10169 /* Returns true if the signature of DECL depends on any template parameter from
10170 its enclosing class. */
10173 uses_outer_template_parms (tree decl
)
10175 int depth
= template_class_depth (CP_DECL_CONTEXT (decl
));
10178 if (for_each_template_parm (TREE_TYPE (decl
), template_parm_outer_level
,
10179 &depth
, NULL
, /*include_nondeduced_p=*/true))
10181 if (PRIMARY_TEMPLATE_P (decl
)
10182 && for_each_template_parm (INNERMOST_TEMPLATE_PARMS
10183 (DECL_TEMPLATE_PARMS (decl
)),
10184 template_parm_outer_level
,
10185 &depth
, NULL
, /*include_nondeduced_p=*/true))
10187 tree ci
= get_constraints (decl
);
10189 ci
= CI_ASSOCIATED_CONSTRAINTS (ci
);
10190 if (ci
&& for_each_template_parm (ci
, template_parm_outer_level
,
10191 &depth
, NULL
, /*nondeduced*/true))
10196 /* Returns TRUE iff INST is an instantiation we don't need to do in an
10197 ill-formed translation unit, i.e. a variable or function that isn't
10198 usable in a constant expression. */
10201 neglectable_inst_p (tree d
)
10203 return (d
&& DECL_P (d
)
10204 && !undeduced_auto_decl (d
)
10205 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
10206 : decl_maybe_constant_var_p (d
)));
10209 /* Returns TRUE iff we should refuse to instantiate DECL because it's
10210 neglectable and instantiated from within an erroneous instantiation. */
10213 limit_bad_template_recursion (tree decl
)
10215 struct tinst_level
*lev
= current_tinst_level
;
10216 int errs
= errorcount
+ sorrycount
;
10217 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
10220 for (; lev
; lev
= lev
->next
)
10221 if (neglectable_inst_p (lev
->maybe_get_node ()))
10224 return (lev
&& errs
> lev
->errors
);
10227 static int tinst_depth
;
10228 extern int max_tinst_depth
;
10231 static GTY(()) struct tinst_level
*last_error_tinst_level
;
10233 /* We're starting to instantiate D; record the template instantiation context
10234 at LOC for diagnostics and to restore it later. */
10237 push_tinst_level_loc (tree tldcl
, tree targs
, location_t loc
)
10239 struct tinst_level
*new_level
;
10241 if (tinst_depth
>= max_tinst_depth
)
10243 /* Tell error.c not to try to instantiate any templates. */
10245 fatal_error (input_location
,
10246 "template instantiation depth exceeds maximum of %d"
10247 " (use %<-ftemplate-depth=%> to increase the maximum)",
10252 /* If the current instantiation caused problems, don't let it instantiate
10253 anything else. Do allow deduction substitution and decls usable in
10254 constant expressions. */
10255 if (!targs
&& limit_bad_template_recursion (tldcl
))
10258 /* When not -quiet, dump template instantiations other than functions, since
10259 announce_function will take care of those. */
10260 if (!quiet_flag
&& !targs
10261 && TREE_CODE (tldcl
) != TREE_LIST
10262 && TREE_CODE (tldcl
) != FUNCTION_DECL
)
10263 fprintf (stderr
, " %s", decl_as_string (tldcl
, TFF_DECL_SPECIFIERS
));
10265 new_level
= tinst_level_freelist ().alloc ();
10266 new_level
->tldcl
= tldcl
;
10267 new_level
->targs
= targs
;
10268 new_level
->locus
= loc
;
10269 new_level
->errors
= errorcount
+ sorrycount
;
10270 new_level
->next
= NULL
;
10271 new_level
->refcount
= 0;
10272 set_refcount_ptr (new_level
->next
, current_tinst_level
);
10273 set_refcount_ptr (current_tinst_level
, new_level
);
10276 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
10277 depth_reached
= tinst_depth
;
10282 /* We're starting substitution of TMPL<ARGS>; record the template
10283 substitution context for diagnostics and to restore it later. */
10286 push_tinst_level (tree tmpl
, tree args
)
10288 return push_tinst_level_loc (tmpl
, args
, input_location
);
10291 /* We're starting to instantiate D; record INPUT_LOCATION and the
10292 template instantiation context for diagnostics and to restore it
10296 push_tinst_level (tree d
)
10298 return push_tinst_level_loc (d
, input_location
);
10301 /* Likewise, but record LOC as the program location. */
10304 push_tinst_level_loc (tree d
, location_t loc
)
10306 gcc_assert (TREE_CODE (d
) != TREE_LIST
);
10307 return push_tinst_level_loc (d
, NULL
, loc
);
10310 /* We're done instantiating this template; return to the instantiation
10314 pop_tinst_level (void)
10316 /* Restore the filename and line number stashed away when we started
10317 this instantiation. */
10318 input_location
= current_tinst_level
->locus
;
10319 set_refcount_ptr (current_tinst_level
, current_tinst_level
->next
);
10323 /* We're instantiating a deferred template; restore the template
10324 instantiation context in which the instantiation was requested, which
10325 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
10328 reopen_tinst_level (struct tinst_level
*level
)
10330 struct tinst_level
*t
;
10333 for (t
= level
; t
; t
= t
->next
)
10336 set_refcount_ptr (current_tinst_level
, level
);
10337 pop_tinst_level ();
10338 if (current_tinst_level
)
10339 current_tinst_level
->errors
= errorcount
+sorrycount
;
10340 return level
->maybe_get_node ();
10343 /* Returns the TINST_LEVEL which gives the original instantiation
10346 struct tinst_level
*
10347 outermost_tinst_level (void)
10349 struct tinst_level
*level
= current_tinst_level
;
10351 while (level
->next
)
10352 level
= level
->next
;
10356 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
10357 vector of template arguments, as for tsubst.
10359 Returns an appropriate tsubst'd friend declaration. */
10362 tsubst_friend_function (tree decl
, tree args
)
10366 if (TREE_CODE (decl
) == FUNCTION_DECL
10367 && DECL_TEMPLATE_INSTANTIATION (decl
)
10368 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
10369 /* This was a friend declared with an explicit template
10370 argument list, e.g.:
10372 friend void f<>(T);
10374 to indicate that f was a template instantiation, not a new
10375 function declaration. Now, we have to figure out what
10376 instantiation of what template. */
10378 tree template_id
, arglist
, fns
;
10381 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
10383 /* Friend functions are looked up in the containing namespace scope.
10384 We must enter that scope, to avoid finding member functions of the
10385 current class with same name. */
10386 push_nested_namespace (ns
);
10387 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
10388 tf_warning_or_error
, NULL_TREE
,
10389 /*integral_constant_expression_p=*/false);
10390 pop_nested_namespace (ns
);
10391 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
10392 tf_warning_or_error
, NULL_TREE
);
10393 template_id
= lookup_template_function (fns
, arglist
);
10395 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
10396 tmpl
= determine_specialization (template_id
, new_friend
,
10398 /*need_member_template=*/0,
10399 TREE_VEC_LENGTH (args
),
10401 return instantiate_template (tmpl
, new_args
, tf_error
);
10404 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
10406 /* The NEW_FRIEND will look like an instantiation, to the
10407 compiler, but is not an instantiation from the point of view of
10408 the language. For example, we might have had:
10410 template <class T> struct S {
10411 template <class U> friend void f(T, U);
10414 Then, in S<int>, template <class U> void f(int, U) is not an
10415 instantiation of anything. */
10416 if (new_friend
== error_mark_node
)
10417 return error_mark_node
;
10419 DECL_USE_TEMPLATE (new_friend
) = 0;
10420 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
10422 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
10423 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
10424 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
10427 /* The mangled name for the NEW_FRIEND is incorrect. The function
10428 is not a template instantiation and should not be mangled like
10429 one. Therefore, we forget the mangling here; we'll recompute it
10430 later if we need it. */
10431 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
10433 SET_DECL_RTL (new_friend
, NULL
);
10434 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
10437 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
10440 tree new_friend_template_info
;
10441 tree new_friend_result_template_info
;
10443 int new_friend_is_defn
;
10445 /* We must save some information from NEW_FRIEND before calling
10446 duplicate decls since that function will free NEW_FRIEND if
10448 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
10449 new_friend_is_defn
=
10450 (DECL_INITIAL (DECL_TEMPLATE_RESULT
10451 (template_for_substitution (new_friend
)))
10453 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
10455 /* This declaration is a `primary' template. */
10456 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
10458 new_friend_result_template_info
10459 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
10462 new_friend_result_template_info
= NULL_TREE
;
10464 /* Inside pushdecl_namespace_level, we will push into the
10465 current namespace. However, the friend function should go
10466 into the namespace of the template. */
10467 ns
= decl_namespace_context (new_friend
);
10468 push_nested_namespace (ns
);
10469 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
10470 pop_nested_namespace (ns
);
10472 if (old_decl
== error_mark_node
)
10473 return error_mark_node
;
10475 if (old_decl
!= new_friend
)
10477 /* This new friend declaration matched an existing
10478 declaration. For example, given:
10480 template <class T> void f(T);
10481 template <class U> class C {
10482 template <class T> friend void f(T) {}
10485 the friend declaration actually provides the definition
10486 of `f', once C has been instantiated for some type. So,
10487 old_decl will be the out-of-class template declaration,
10488 while new_friend is the in-class definition.
10490 But, if `f' was called before this point, the
10491 instantiation of `f' will have DECL_TI_ARGS corresponding
10492 to `T' but not to `U', references to which might appear
10493 in the definition of `f'. Previously, the most general
10494 template for an instantiation of `f' was the out-of-class
10495 version; now it is the in-class version. Therefore, we
10496 run through all specialization of `f', adding to their
10497 DECL_TI_ARGS appropriately. In particular, they need a
10498 new set of outer arguments, corresponding to the
10499 arguments for this class instantiation.
10501 The same situation can arise with something like this:
10503 friend void f(int);
10504 template <class T> class C {
10505 friend void f(T) {}
10508 when `C<int>' is instantiated. Now, `f(int)' is defined
10511 if (!new_friend_is_defn
)
10512 /* On the other hand, if the in-class declaration does
10513 *not* provide a definition, then we don't want to alter
10514 existing definitions. We can just leave everything
10519 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
10520 tree new_args
= TI_ARGS (new_friend_template_info
);
10522 /* Overwrite whatever template info was there before, if
10523 any, with the new template information pertaining to
10524 the declaration. */
10525 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
10527 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
10529 /* We should have called reregister_specialization in
10530 duplicate_decls. */
10531 gcc_assert (retrieve_specialization (new_template
,
10535 /* Instantiate it if the global has already been used. */
10536 if (DECL_ODR_USED (old_decl
))
10537 instantiate_decl (old_decl
, /*defer_ok=*/true,
10538 /*expl_inst_class_mem_p=*/false);
10544 /* Indicate that the old function template is a partial
10546 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
10547 = new_friend_result_template_info
;
10549 gcc_assert (new_template
10550 == most_general_template (new_template
));
10551 gcc_assert (new_template
!= old_decl
);
10553 /* Reassign any specializations already in the hash table
10554 to the new more general template, and add the
10555 additional template args. */
10556 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
10558 t
= TREE_CHAIN (t
))
10560 tree spec
= TREE_VALUE (t
);
10563 elt
.tmpl
= old_decl
;
10564 elt
.args
= DECL_TI_ARGS (spec
);
10565 elt
.spec
= NULL_TREE
;
10567 decl_specializations
->remove_elt (&elt
);
10569 DECL_TI_ARGS (spec
)
10570 = add_outermost_template_args (new_args
,
10571 DECL_TI_ARGS (spec
));
10573 register_specialization
10574 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
10577 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
10581 /* The information from NEW_FRIEND has been merged into OLD_DECL
10582 by duplicate_decls. */
10583 new_friend
= old_decl
;
10588 tree context
= DECL_CONTEXT (new_friend
);
10592 template <class T> class C {
10593 template <class U> friend void C1<U>::f (); // case 1
10594 friend void C2<T>::f (); // case 2
10596 we only need to make sure CONTEXT is a complete type for
10597 case 2. To distinguish between the two cases, we note that
10598 CONTEXT of case 1 remains dependent type after tsubst while
10599 this isn't true for case 2. */
10600 ++processing_template_decl
;
10601 dependent_p
= dependent_type_p (context
);
10602 --processing_template_decl
;
10605 && !complete_type_or_else (context
, NULL_TREE
))
10606 return error_mark_node
;
10608 if (COMPLETE_TYPE_P (context
))
10610 tree fn
= new_friend
;
10611 /* do_friend adds the TEMPLATE_DECL for any member friend
10612 template even if it isn't a member template, i.e.
10613 template <class T> friend A<T>::f();
10614 Look through it in that case. */
10615 if (TREE_CODE (fn
) == TEMPLATE_DECL
10616 && !PRIMARY_TEMPLATE_P (fn
))
10617 fn
= DECL_TEMPLATE_RESULT (fn
);
10618 /* Check to see that the declaration is really present, and,
10619 possibly obtain an improved declaration. */
10620 fn
= check_classfn (context
, fn
, NULL_TREE
);
10630 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
10631 template arguments, as for tsubst.
10633 Returns an appropriate tsubst'd friend type or error_mark_node on
10637 tsubst_friend_class (tree friend_tmpl
, tree args
)
10641 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
10643 tmpl
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
10644 return TREE_TYPE (tmpl
);
10647 tree context
= CP_DECL_CONTEXT (friend_tmpl
);
10648 if (TREE_CODE (context
) == NAMESPACE_DECL
)
10649 push_nested_namespace (context
);
10652 context
= tsubst (context
, args
, tf_error
, NULL_TREE
);
10653 push_nested_class (context
);
10656 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), /*prefer_type=*/false,
10657 /*non_class=*/false, /*block_p=*/false,
10658 /*namespaces_only=*/false, LOOKUP_HIDDEN
);
10660 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
10662 /* The friend template has already been declared. Just
10663 check to see that the declarations match, and install any new
10664 default parameters. We must tsubst the default parameters,
10665 of course. We only need the innermost template parameters
10666 because that is all that redeclare_class_template will look
10668 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
10669 > TMPL_ARGS_DEPTH (args
))
10671 tree parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
10672 args
, tf_warning_or_error
);
10673 location_t saved_input_location
= input_location
;
10674 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
10675 tree cons
= get_constraints (tmpl
);
10676 redeclare_class_template (TREE_TYPE (tmpl
), parms
, cons
);
10677 input_location
= saved_input_location
;
10682 /* The friend template has not already been declared. In this
10683 case, the instantiation of the template class will cause the
10684 injection of this template into the namespace scope. */
10685 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
10687 if (tmpl
!= error_mark_node
)
10689 /* The new TMPL is not an instantiation of anything, so we
10690 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE
10691 for the new type because that is supposed to be the
10692 corresponding template decl, i.e., TMPL. */
10693 DECL_USE_TEMPLATE (tmpl
) = 0;
10694 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
10695 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
10696 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
10697 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
10699 /* It is hidden. */
10700 retrofit_lang_decl (DECL_TEMPLATE_RESULT (tmpl
));
10701 DECL_ANTICIPATED (tmpl
)
10702 = DECL_ANTICIPATED (DECL_TEMPLATE_RESULT (tmpl
)) = true;
10704 /* Inject this template into the enclosing namspace scope. */
10705 tmpl
= pushdecl_namespace_level (tmpl
, true);
10709 if (TREE_CODE (context
) == NAMESPACE_DECL
)
10710 pop_nested_namespace (context
);
10712 pop_nested_class ();
10714 return TREE_TYPE (tmpl
);
10717 /* Returns zero if TYPE cannot be completed later due to circularity.
10718 Otherwise returns one. */
10721 can_complete_type_without_circularity (tree type
)
10723 if (type
== NULL_TREE
|| type
== error_mark_node
)
10725 else if (COMPLETE_TYPE_P (type
))
10727 else if (TREE_CODE (type
) == ARRAY_TYPE
)
10728 return can_complete_type_without_circularity (TREE_TYPE (type
));
10729 else if (CLASS_TYPE_P (type
)
10730 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
10736 static tree
tsubst_omp_clauses (tree
, enum c_omp_region_type
, tree
,
10737 tsubst_flags_t
, tree
);
10739 /* Instantiate a single dependent attribute T (a TREE_LIST), and return either
10740 T or a new TREE_LIST, possibly a chain in the case of a pack expansion. */
10743 tsubst_attribute (tree t
, tree
*decl_p
, tree args
,
10744 tsubst_flags_t complain
, tree in_decl
)
10746 gcc_assert (ATTR_IS_DEPENDENT (t
));
10748 tree val
= TREE_VALUE (t
);
10749 if (val
== NULL_TREE
)
10750 /* Nothing to do. */;
10751 else if ((flag_openmp
|| flag_openmp_simd
)
10752 && is_attribute_p ("omp declare simd",
10753 get_attribute_name (t
)))
10755 tree clauses
= TREE_VALUE (val
);
10756 clauses
= tsubst_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
, args
,
10757 complain
, in_decl
);
10758 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
10759 clauses
= finish_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
);
10760 tree parms
= DECL_ARGUMENTS (*decl_p
);
10762 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
10764 val
= build_tree_list (NULL_TREE
, clauses
);
10768 /* If the first attribute argument is an identifier, don't
10769 pass it through tsubst. Attributes like mode, format,
10770 cleanup and several target specific attributes expect it
10772 else if (attribute_takes_identifier_p (get_attribute_name (t
)))
10775 = tsubst_expr (TREE_CHAIN (val
), args
, complain
, in_decl
,
10776 /*integral_constant_expression_p=*/false);
10777 if (chain
!= TREE_CHAIN (val
))
10778 val
= tree_cons (NULL_TREE
, TREE_VALUE (val
), chain
);
10780 else if (PACK_EXPANSION_P (val
))
10782 /* An attribute pack expansion. */
10783 tree purp
= TREE_PURPOSE (t
);
10784 tree pack
= tsubst_pack_expansion (val
, args
, complain
, in_decl
);
10785 if (pack
== error_mark_node
)
10786 return error_mark_node
;
10787 int len
= TREE_VEC_LENGTH (pack
);
10788 tree list
= NULL_TREE
;
10790 for (int i
= 0; i
< len
; ++i
)
10792 tree elt
= TREE_VEC_ELT (pack
, i
);
10793 *q
= build_tree_list (purp
, elt
);
10794 q
= &TREE_CHAIN (*q
);
10799 val
= tsubst_expr (val
, args
, complain
, in_decl
,
10800 /*integral_constant_expression_p=*/false);
10802 if (val
!= TREE_VALUE (t
))
10803 return build_tree_list (TREE_PURPOSE (t
), val
);
10807 /* Instantiate any dependent attributes in ATTRIBUTES, returning either it
10808 unchanged or a new TREE_LIST chain. */
10811 tsubst_attributes (tree attributes
, tree args
,
10812 tsubst_flags_t complain
, tree in_decl
)
10814 tree last_dep
= NULL_TREE
;
10816 for (tree t
= attributes
; t
; t
= TREE_CHAIN (t
))
10817 if (ATTR_IS_DEPENDENT (t
))
10820 attributes
= copy_list (attributes
);
10825 for (tree
*p
= &attributes
; *p
; )
10828 if (ATTR_IS_DEPENDENT (t
))
10830 tree subst
= tsubst_attribute (t
, NULL
, args
, complain
, in_decl
);
10835 p
= &TREE_CHAIN (*p
);
10836 *p
= TREE_CHAIN (t
);
10840 p
= &TREE_CHAIN (*p
);
10846 /* Apply any attributes which had to be deferred until instantiation
10847 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
10848 ARGS, COMPLAIN, IN_DECL are as tsubst. */
10851 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
10852 tree args
, tsubst_flags_t complain
, tree in_decl
)
10854 tree last_dep
= NULL_TREE
;
10858 if (attributes
== NULL_TREE
)
10861 if (DECL_P (*decl_p
))
10863 if (TREE_TYPE (*decl_p
) == error_mark_node
)
10865 p
= &DECL_ATTRIBUTES (*decl_p
);
10866 /* DECL_ATTRIBUTES comes from copy_node in tsubst_decl, and is identical
10867 to our attributes parameter. */
10868 gcc_assert (*p
== attributes
);
10872 p
= &TYPE_ATTRIBUTES (*decl_p
);
10873 /* TYPE_ATTRIBUTES was set up (with abi_tag and may_alias) in
10874 lookup_template_class_1, and should be preserved. */
10875 gcc_assert (*p
!= attributes
);
10877 p
= &TREE_CHAIN (*p
);
10880 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
10881 if (ATTR_IS_DEPENDENT (t
))
10884 attributes
= copy_list (attributes
);
10891 tree late_attrs
= NULL_TREE
;
10892 tree
*q
= &late_attrs
;
10897 if (ATTR_IS_DEPENDENT (t
))
10899 *p
= TREE_CHAIN (t
);
10900 TREE_CHAIN (t
) = NULL_TREE
;
10901 *q
= tsubst_attribute (t
, decl_p
, args
, complain
, in_decl
);
10903 q
= &TREE_CHAIN (*q
);
10906 p
= &TREE_CHAIN (t
);
10909 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
10913 /* Perform (or defer) access check for typedefs that were referenced
10914 from within the template TMPL code.
10915 This is a subroutine of instantiate_decl and instantiate_class_template.
10916 TMPL is the template to consider and TARGS is the list of arguments of
10920 perform_typedefs_access_check (tree tmpl
, tree targs
)
10922 location_t saved_location
;
10924 qualified_typedef_usage_t
*iter
;
10927 || (!CLASS_TYPE_P (tmpl
)
10928 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
10931 saved_location
= input_location
;
10932 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
10934 tree type_decl
= iter
->typedef_decl
;
10935 tree type_scope
= iter
->context
;
10937 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
10940 if (uses_template_parms (type_decl
))
10941 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
10942 if (uses_template_parms (type_scope
))
10943 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
10945 /* Make access check error messages point to the location
10946 of the use of the typedef. */
10947 input_location
= iter
->locus
;
10948 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
10949 type_decl
, type_decl
,
10950 tf_warning_or_error
);
10952 input_location
= saved_location
;
10956 instantiate_class_template_1 (tree type
)
10958 tree templ
, args
, pattern
, t
, member
;
10962 unsigned int saved_maximum_field_alignment
;
10965 if (type
== error_mark_node
)
10966 return error_mark_node
;
10968 if (COMPLETE_OR_OPEN_TYPE_P (type
)
10969 || uses_template_parms (type
))
10972 /* Figure out which template is being instantiated. */
10973 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
10974 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
10976 /* Mark the type as in the process of being defined. */
10977 TYPE_BEING_DEFINED (type
) = 1;
10979 /* We may be in the middle of deferred access check. Disable
10981 deferring_access_check_sentinel
acs (dk_no_deferred
);
10983 /* Determine what specialization of the original template to
10985 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
10986 if (t
== error_mark_node
)
10987 return error_mark_node
;
10990 /* This TYPE is actually an instantiation of a partial
10991 specialization. We replace the innermost set of ARGS with
10992 the arguments appropriate for substitution. For example,
10995 template <class T> struct S {};
10996 template <class T> struct S<T*> {};
10998 and supposing that we are instantiating S<int*>, ARGS will
10999 presently be {int*} -- but we need {int}. */
11000 pattern
= TREE_TYPE (t
);
11001 args
= TREE_PURPOSE (t
);
11005 pattern
= TREE_TYPE (templ
);
11006 args
= CLASSTYPE_TI_ARGS (type
);
11009 /* If the template we're instantiating is incomplete, then clearly
11010 there's nothing we can do. */
11011 if (!COMPLETE_TYPE_P (pattern
))
11013 /* We can try again later. */
11014 TYPE_BEING_DEFINED (type
) = 0;
11018 /* If we've recursively instantiated too many templates, stop. */
11019 if (! push_tinst_level (type
))
11022 int saved_unevaluated_operand
= cp_unevaluated_operand
;
11023 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
11025 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
11026 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
11027 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
11028 fn_context
= error_mark_node
;
11030 push_to_top_level ();
11033 cp_unevaluated_operand
= 0;
11034 c_inhibit_evaluation_warnings
= 0;
11036 /* Use #pragma pack from the template context. */
11037 saved_maximum_field_alignment
= maximum_field_alignment
;
11038 maximum_field_alignment
= TYPE_PRECISION (pattern
);
11040 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
11042 /* Set the input location to the most specialized template definition.
11043 This is needed if tsubsting causes an error. */
11044 typedecl
= TYPE_MAIN_DECL (pattern
);
11045 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
11046 DECL_SOURCE_LOCATION (typedecl
);
11048 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
11049 SET_TYPE_ALIGN (type
, TYPE_ALIGN (pattern
));
11050 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
11051 CLASSTYPE_NON_AGGREGATE (type
) = CLASSTYPE_NON_AGGREGATE (pattern
);
11052 if (ANON_AGGR_TYPE_P (pattern
))
11053 SET_ANON_AGGR_TYPE_P (type
);
11054 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
11056 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
11057 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
11058 /* Adjust visibility for template arguments. */
11059 determine_visibility (TYPE_MAIN_DECL (type
));
11061 if (CLASS_TYPE_P (type
))
11062 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
11064 pbinfo
= TYPE_BINFO (pattern
);
11066 /* We should never instantiate a nested class before its enclosing
11067 class; we need to look up the nested class by name before we can
11068 instantiate it, and that lookup should instantiate the enclosing
11070 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
11071 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
11073 base_list
= NULL_TREE
;
11074 if (BINFO_N_BASE_BINFOS (pbinfo
))
11080 /* We must enter the scope containing the type, as that is where
11081 the accessibility of types named in dependent bases are
11083 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
11085 /* Substitute into each of the bases to determine the actual
11087 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
11090 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
11091 tree expanded_bases
= NULL_TREE
;
11094 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
11097 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
11098 args
, tf_error
, NULL_TREE
);
11099 if (expanded_bases
== error_mark_node
)
11102 len
= TREE_VEC_LENGTH (expanded_bases
);
11105 for (idx
= 0; idx
< len
; idx
++)
11107 if (expanded_bases
)
11108 /* Extract the already-expanded base class. */
11109 base
= TREE_VEC_ELT (expanded_bases
, idx
);
11111 /* Substitute to figure out the base class. */
11112 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
11115 if (base
== error_mark_node
)
11118 base_list
= tree_cons (access
, base
, base_list
);
11119 if (BINFO_VIRTUAL_P (pbase_binfo
))
11120 TREE_TYPE (base_list
) = integer_type_node
;
11124 /* The list is now in reverse order; correct that. */
11125 base_list
= nreverse (base_list
);
11128 pop_scope (pushed_scope
);
11130 /* Now call xref_basetypes to set up all the base-class
11132 xref_basetypes (type
, base_list
);
11134 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
11135 (int) ATTR_FLAG_TYPE_IN_PLACE
,
11136 args
, tf_error
, NULL_TREE
);
11137 fixup_attribute_variants (type
);
11139 /* Now that our base classes are set up, enter the scope of the
11140 class, so that name lookups into base classes, etc. will work
11141 correctly. This is precisely analogous to what we do in
11142 begin_class_definition when defining an ordinary non-template
11143 class, except we also need to push the enclosing classes. */
11144 push_nested_class (type
);
11146 /* Now members are processed in the order of declaration. */
11147 for (member
= CLASSTYPE_DECL_LIST (pattern
);
11148 member
; member
= TREE_CHAIN (member
))
11150 tree t
= TREE_VALUE (member
);
11152 if (TREE_PURPOSE (member
))
11156 if (LAMBDA_TYPE_P (t
))
11157 /* A closure type for a lambda in an NSDMI or default argument.
11158 Ignore it; it will be regenerated when needed. */
11161 /* Build new CLASSTYPE_NESTED_UTDS. */
11164 bool class_template_p
;
11166 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
11167 && TYPE_LANG_SPECIFIC (t
)
11168 && CLASSTYPE_IS_TEMPLATE (t
));
11169 /* If the member is a class template, then -- even after
11170 substitution -- there may be dependent types in the
11171 template argument list for the class. We increment
11172 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
11173 that function will assume that no types are dependent
11174 when outside of a template. */
11175 if (class_template_p
)
11176 ++processing_template_decl
;
11177 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
11178 if (class_template_p
)
11179 --processing_template_decl
;
11180 if (newtag
== error_mark_node
)
11183 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
11185 tree name
= TYPE_IDENTIFIER (t
);
11187 if (class_template_p
)
11188 /* Unfortunately, lookup_template_class sets
11189 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
11190 instantiation (i.e., for the type of a member
11191 template class nested within a template class.)
11192 This behavior is required for
11193 maybe_process_partial_specialization to work
11194 correctly, but is not accurate in this case;
11195 the TAG is not an instantiation of anything.
11196 (The corresponding TEMPLATE_DECL is an
11197 instantiation, but the TYPE is not.) */
11198 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
11200 /* Now, we call pushtag to put this NEWTAG into the scope of
11201 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
11202 pushtag calling push_template_decl. We don't have to do
11203 this for enums because it will already have been done in
11206 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
11207 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
11210 else if (DECL_DECLARES_FUNCTION_P (t
))
11214 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11215 ++processing_template_decl
;
11216 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
11217 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11218 --processing_template_decl
;
11219 set_current_access_from_decl (r
);
11220 finish_member_declaration (r
);
11221 /* Instantiate members marked with attribute used. */
11222 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
11224 if (TREE_CODE (r
) == FUNCTION_DECL
11225 && DECL_OMP_DECLARE_REDUCTION_P (r
))
11226 cp_check_omp_declare_reduction (r
);
11228 else if ((DECL_CLASS_TEMPLATE_P (t
) || DECL_IMPLICIT_TYPEDEF_P (t
))
11229 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
11230 /* A closure type for a lambda in an NSDMI or default argument.
11231 Ignore it; it will be regenerated when needed. */;
11234 /* Build new TYPE_FIELDS. */
11235 if (TREE_CODE (t
) == STATIC_ASSERT
)
11239 ++c_inhibit_evaluation_warnings
;
11241 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
11242 tf_warning_or_error
, NULL_TREE
,
11243 /*integral_constant_expression_p=*/true);
11244 --c_inhibit_evaluation_warnings
;
11246 finish_static_assert (condition
,
11247 STATIC_ASSERT_MESSAGE (t
),
11248 STATIC_ASSERT_SOURCE_LOCATION (t
),
11249 /*member_p=*/true);
11251 else if (TREE_CODE (t
) != CONST_DECL
)
11254 tree vec
= NULL_TREE
;
11257 /* The file and line for this declaration, to
11258 assist in error message reporting. Since we
11259 called push_tinst_level above, we don't need to
11261 input_location
= DECL_SOURCE_LOCATION (t
);
11263 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11264 ++processing_template_decl
;
11265 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
11266 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11267 --processing_template_decl
;
11269 if (TREE_CODE (r
) == TREE_VEC
)
11271 /* A capture pack became multiple fields. */
11273 len
= TREE_VEC_LENGTH (vec
);
11276 for (int i
= 0; i
< len
; ++i
)
11279 r
= TREE_VEC_ELT (vec
, i
);
11284 [t]he initialization (and any associated
11285 side-effects) of a static data member does
11286 not occur unless the static data member is
11287 itself used in a way that requires the
11288 definition of the static data member to
11291 Therefore, we do not substitute into the
11292 initialized for the static data member here. */
11293 finish_static_data_member_decl
11295 /*init=*/NULL_TREE
,
11296 /*init_const_expr_p=*/false,
11297 /*asmspec_tree=*/NULL_TREE
,
11299 /* Instantiate members marked with attribute used. */
11300 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
11303 else if (TREE_CODE (r
) == FIELD_DECL
)
11305 /* Determine whether R has a valid type and can be
11306 completed later. If R is invalid, then its type
11307 is replaced by error_mark_node. */
11308 tree rtype
= TREE_TYPE (r
);
11309 if (can_complete_type_without_circularity (rtype
))
11310 complete_type (rtype
);
11312 if (!complete_or_array_type_p (rtype
))
11314 /* If R's type couldn't be completed and
11315 it isn't a flexible array member (whose
11316 type is incomplete by definition) give
11318 cxx_incomplete_type_error (r
, rtype
);
11319 TREE_TYPE (r
) = error_mark_node
;
11321 else if (TREE_CODE (rtype
) == ARRAY_TYPE
11322 && TYPE_DOMAIN (rtype
) == NULL_TREE
11323 && (TREE_CODE (type
) == UNION_TYPE
11324 || TREE_CODE (type
) == QUAL_UNION_TYPE
))
11326 error ("flexible array member %qD in union", r
);
11327 TREE_TYPE (r
) = error_mark_node
;
11331 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
11332 such a thing will already have been added to the field
11333 list by tsubst_enum in finish_member_declaration in the
11334 CLASSTYPE_NESTED_UTDS case above. */
11335 if (!(TREE_CODE (r
) == TYPE_DECL
11336 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
11337 && DECL_ARTIFICIAL (r
)))
11339 set_current_access_from_decl (r
);
11340 finish_member_declaration (r
);
11348 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
11349 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
11351 /* Build new CLASSTYPE_FRIEND_CLASSES. */
11353 tree friend_type
= t
;
11354 bool adjust_processing_template_decl
= false;
11356 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
11358 /* template <class T> friend class C; */
11359 friend_type
= tsubst_friend_class (friend_type
, args
);
11360 adjust_processing_template_decl
= true;
11362 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
11364 /* template <class T> friend class C::D; */
11365 friend_type
= tsubst (friend_type
, args
,
11366 tf_warning_or_error
, NULL_TREE
);
11367 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
11368 friend_type
= TREE_TYPE (friend_type
);
11369 adjust_processing_template_decl
= true;
11371 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
11372 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
11374 /* This could be either
11378 when dependent_type_p is false or
11380 template <class U> friend class T::C;
11383 /* Bump processing_template_decl in case this is something like
11384 template <class T> friend struct A<T>::B. */
11385 ++processing_template_decl
;
11386 friend_type
= tsubst (friend_type
, args
,
11387 tf_warning_or_error
, NULL_TREE
);
11388 if (dependent_type_p (friend_type
))
11389 adjust_processing_template_decl
= true;
11390 --processing_template_decl
;
11392 else if (TREE_CODE (friend_type
) != BOUND_TEMPLATE_TEMPLATE_PARM
11393 && !CLASSTYPE_USE_TEMPLATE (friend_type
)
11394 && TYPE_HIDDEN_P (friend_type
))
11398 where C hasn't been declared yet. Let's lookup name
11399 from namespace scope directly, bypassing any name that
11400 come from dependent base class. */
11401 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
11403 /* The call to xref_tag_from_type does injection for friend
11405 push_nested_namespace (ns
);
11407 xref_tag_from_type (friend_type
, NULL_TREE
,
11408 /*tag_scope=*/ts_current
);
11409 pop_nested_namespace (ns
);
11411 else if (uses_template_parms (friend_type
))
11412 /* friend class C<T>; */
11413 friend_type
= tsubst (friend_type
, args
,
11414 tf_warning_or_error
, NULL_TREE
);
11419 where C is already declared or
11421 friend class C<int>;
11423 We don't have to do anything in these cases. */
11425 if (adjust_processing_template_decl
)
11426 /* Trick make_friend_class into realizing that the friend
11427 we're adding is a template, not an ordinary class. It's
11428 important that we use make_friend_class since it will
11429 perform some error-checking and output cross-reference
11431 ++processing_template_decl
;
11433 if (friend_type
!= error_mark_node
)
11434 make_friend_class (type
, friend_type
, /*complain=*/false);
11436 if (adjust_processing_template_decl
)
11437 --processing_template_decl
;
11441 /* Build new DECL_FRIENDLIST. */
11444 /* The file and line for this declaration, to
11445 assist in error message reporting. Since we
11446 called push_tinst_level above, we don't need to
11448 input_location
= DECL_SOURCE_LOCATION (t
);
11450 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11452 ++processing_template_decl
;
11453 push_deferring_access_checks (dk_no_check
);
11456 r
= tsubst_friend_function (t
, args
);
11457 add_friend (type
, r
, /*complain=*/false);
11458 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11460 pop_deferring_access_checks ();
11461 --processing_template_decl
;
11469 /* Restore these before substituting into the lambda capture
11471 cp_unevaluated_operand
= saved_unevaluated_operand
;
11472 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
11475 /* Set the file and line number information to whatever is given for
11476 the class itself. This puts error messages involving generated
11477 implicit functions at a predictable point, and the same point
11478 that would be used for non-template classes. */
11479 input_location
= DECL_SOURCE_LOCATION (typedecl
);
11481 unreverse_member_declarations (type
);
11482 finish_struct_1 (type
);
11483 TYPE_BEING_DEFINED (type
) = 0;
11485 /* We don't instantiate default arguments for member functions. 14.7.1:
11487 The implicit instantiation of a class template specialization causes
11488 the implicit instantiation of the declarations, but not of the
11489 definitions or default arguments, of the class member functions,
11490 member classes, static data members and member templates.... */
11492 /* Some typedefs referenced from within the template code need to be access
11493 checked at template instantiation time, i.e now. These types were
11494 added to the template at parsing time. Let's get those and perform
11495 the access checks then. */
11496 perform_typedefs_access_check (pattern
, args
);
11497 perform_deferred_access_checks (tf_warning_or_error
);
11498 pop_nested_class ();
11499 maximum_field_alignment
= saved_maximum_field_alignment
;
11501 pop_from_top_level ();
11502 pop_tinst_level ();
11504 /* The vtable for a template class can be emitted in any translation
11505 unit in which the class is instantiated. When there is no key
11506 method, however, finish_struct_1 will already have added TYPE to
11507 the keyed_classes. */
11508 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
11509 vec_safe_push (keyed_classes
, type
);
11514 /* Wrapper for instantiate_class_template_1. */
11517 instantiate_class_template (tree type
)
11520 timevar_push (TV_TEMPLATE_INST
);
11521 ret
= instantiate_class_template_1 (type
);
11522 timevar_pop (TV_TEMPLATE_INST
);
11527 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11533 else if (TYPE_P (t
))
11534 r
= tsubst (t
, args
, complain
, in_decl
);
11537 if (!(complain
& tf_warning
))
11538 ++c_inhibit_evaluation_warnings
;
11539 r
= tsubst_expr (t
, args
, complain
, in_decl
,
11540 /*integral_constant_expression_p=*/true);
11541 if (!(complain
& tf_warning
))
11542 --c_inhibit_evaluation_warnings
;
11547 /* Given a function parameter pack TMPL_PARM and some function parameters
11548 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
11549 and set *SPEC_P to point at the next point in the list. */
11552 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
11554 /* Collect all of the extra "packed" parameters into an
11557 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
11558 tree spec_parm
= *spec_p
;
11561 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
11563 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
11566 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
11567 parmvec
= make_tree_vec (len
);
11568 spec_parm
= *spec_p
;
11569 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
11571 tree elt
= spec_parm
;
11572 if (DECL_PACK_P (elt
))
11573 elt
= make_pack_expansion (elt
);
11574 TREE_VEC_ELT (parmvec
, i
) = elt
;
11577 /* Build the argument packs. */
11578 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
11579 *spec_p
= spec_parm
;
11584 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
11585 NONTYPE_ARGUMENT_PACK. */
11588 make_fnparm_pack (tree spec_parm
)
11590 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
11593 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
11594 pack expansion with no extra args, 2 if it has extra args, or 0
11595 if it is not a pack expansion. */
11598 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
11600 if (TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
11601 /* We're being called before this happens in tsubst_pack_expansion. */
11602 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
11603 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
11604 if (i
>= TREE_VEC_LENGTH (vec
))
11606 tree elt
= TREE_VEC_ELT (vec
, i
);
11608 /* A decl pack is itself an expansion. */
11609 elt
= TREE_TYPE (elt
);
11610 if (!PACK_EXPANSION_P (elt
))
11612 if (PACK_EXPANSION_EXTRA_ARGS (elt
))
11618 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
11621 make_argument_pack_select (tree arg_pack
, unsigned index
)
11623 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
11625 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
11626 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
11631 /* This is a subroutine of tsubst_pack_expansion.
11633 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
11634 mechanism to store the (non complete list of) arguments of the
11635 substitution and return a non substituted pack expansion, in order
11636 to wait for when we have enough arguments to really perform the
11640 use_pack_expansion_extra_args_p (tree parm_packs
,
11642 bool has_empty_arg
)
11644 /* If one pack has an expansion and another pack has a normal
11645 argument or if one pack has an empty argument and an another
11646 one hasn't then tsubst_pack_expansion cannot perform the
11647 substitution and need to fall back on the
11648 PACK_EXPANSION_EXTRA mechanism. */
11649 if (parm_packs
== NULL_TREE
)
11651 else if (has_empty_arg
)
11654 bool has_expansion_arg
= false;
11655 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
11657 bool has_non_expansion_arg
= false;
11658 for (tree parm_pack
= parm_packs
;
11660 parm_pack
= TREE_CHAIN (parm_pack
))
11662 tree arg
= TREE_VALUE (parm_pack
);
11664 int exp
= argument_pack_element_is_expansion_p (arg
, i
);
11666 /* We can't substitute a pack expansion with extra args into
11670 has_expansion_arg
= true;
11672 has_non_expansion_arg
= true;
11675 if (has_expansion_arg
&& has_non_expansion_arg
)
11681 /* [temp.variadic]/6 says that:
11683 The instantiation of a pack expansion [...]
11684 produces a list E1,E2, ..., En, where N is the number of elements
11685 in the pack expansion parameters.
11687 This subroutine of tsubst_pack_expansion produces one of these Ei.
11689 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
11690 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
11691 PATTERN, and each TREE_VALUE is its corresponding argument pack.
11692 INDEX is the index 'i' of the element Ei to produce. ARGS,
11693 COMPLAIN, and IN_DECL are the same parameters as for the
11694 tsubst_pack_expansion function.
11696 The function returns the resulting Ei upon successful completion,
11697 or error_mark_node.
11699 Note that this function possibly modifies the ARGS parameter, so
11700 it's the responsibility of the caller to restore it. */
11703 gen_elem_of_pack_expansion_instantiation (tree pattern
,
11706 tree args
/* This parm gets
11708 tsubst_flags_t complain
,
11712 bool ith_elem_is_expansion
= false;
11714 /* For each parameter pack, change the substitution of the parameter
11715 pack to the ith argument in its argument pack, then expand the
11717 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
11719 tree parm
= TREE_PURPOSE (pack
);
11720 tree arg_pack
= TREE_VALUE (pack
);
11721 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
11723 ith_elem_is_expansion
|=
11724 argument_pack_element_is_expansion_p (arg_pack
, index
);
11726 /* Select the Ith argument from the pack. */
11727 if (TREE_CODE (parm
) == PARM_DECL
11729 || TREE_CODE (parm
) == FIELD_DECL
)
11733 aps
= make_argument_pack_select (arg_pack
, index
);
11734 if (!mark_used (parm
, complain
) && !(complain
& tf_error
))
11735 return error_mark_node
;
11736 register_local_specialization (aps
, parm
);
11739 aps
= retrieve_local_specialization (parm
);
11744 template_parm_level_and_index (parm
, &level
, &idx
);
11748 aps
= make_argument_pack_select (arg_pack
, index
);
11749 /* Update the corresponding argument. */
11750 TMPL_ARG (args
, level
, idx
) = aps
;
11753 /* Re-use the ARGUMENT_PACK_SELECT. */
11754 aps
= TMPL_ARG (args
, level
, idx
);
11756 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
11759 // Any local specialization bindings arising from this substitution
11760 // cannot be reused for a different INDEX.
11761 local_specialization_stack
lss (lss_copy
);
11763 /* Substitute into the PATTERN with the (possibly altered)
11765 if (pattern
== in_decl
)
11766 /* Expanding a fixed parameter pack from
11767 coerce_template_parameter_pack. */
11768 t
= tsubst_decl (pattern
, args
, complain
);
11769 else if (pattern
== error_mark_node
)
11770 t
= error_mark_node
;
11771 else if (constraint_p (pattern
))
11773 if (processing_template_decl
)
11774 t
= tsubst_constraint (pattern
, args
, complain
, in_decl
);
11776 t
= (constraints_satisfied_p (pattern
, args
)
11777 ? boolean_true_node
: boolean_false_node
);
11779 else if (!TYPE_P (pattern
))
11780 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
11781 /*integral_constant_expression_p=*/false);
11783 t
= tsubst (pattern
, args
, complain
, in_decl
);
11785 /* If the Ith argument pack element is a pack expansion, then
11786 the Ith element resulting from the substituting is going to
11787 be a pack expansion as well. */
11788 if (ith_elem_is_expansion
)
11789 t
= make_pack_expansion (t
, complain
);
11794 /* When the unexpanded parameter pack in a fold expression expands to an empty
11795 sequence, the value of the expression is as follows; the program is
11796 ill-formed if the operator is not listed in this table.
11803 expand_empty_fold (tree t
, tsubst_flags_t complain
)
11805 tree_code code
= (tree_code
)TREE_INT_CST_LOW (TREE_OPERAND (t
, 0));
11806 if (!FOLD_EXPR_MODIFY_P (t
))
11809 case TRUTH_ANDIF_EXPR
:
11810 return boolean_true_node
;
11811 case TRUTH_ORIF_EXPR
:
11812 return boolean_false_node
;
11813 case COMPOUND_EXPR
:
11819 if (complain
& tf_error
)
11820 error_at (location_of (t
),
11821 "fold of empty expansion over %O", code
);
11822 return error_mark_node
;
11825 /* Given a fold-expression T and a current LEFT and RIGHT operand,
11826 form an expression that combines the two terms using the
11830 fold_expression (tree t
, tree left
, tree right
, tsubst_flags_t complain
)
11832 tree op
= FOLD_EXPR_OP (t
);
11833 tree_code code
= (tree_code
)TREE_INT_CST_LOW (op
);
11835 // Handle compound assignment operators.
11836 if (FOLD_EXPR_MODIFY_P (t
))
11837 return build_x_modify_expr (input_location
, left
, code
, right
, complain
);
11841 case COMPOUND_EXPR
:
11842 return build_x_compound_expr (input_location
, left
, right
, complain
);
11844 return build_x_binary_op (input_location
, code
,
11845 left
, TREE_CODE (left
),
11846 right
, TREE_CODE (right
),
11852 /* Substitute ARGS into the pack of a fold expression T. */
11855 tsubst_fold_expr_pack (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11857 return tsubst_pack_expansion (FOLD_EXPR_PACK (t
), args
, complain
, in_decl
);
11860 /* Substitute ARGS into the pack of a fold expression T. */
11863 tsubst_fold_expr_init (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11865 return tsubst_expr (FOLD_EXPR_INIT (t
), args
, complain
, in_decl
, false);
11868 /* Expand a PACK of arguments into a grouped as left fold.
11869 Given a pack containing elements A0, A1, ..., An and an
11870 operator @, this builds the expression:
11872 ((A0 @ A1) @ A2) ... @ An
11874 Note that PACK must not be empty.
11876 The operator is defined by the original fold expression T. */
11879 expand_left_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11881 tree left
= TREE_VEC_ELT (pack
, 0);
11882 for (int i
= 1; i
< TREE_VEC_LENGTH (pack
); ++i
)
11884 tree right
= TREE_VEC_ELT (pack
, i
);
11885 left
= fold_expression (t
, left
, right
, complain
);
11890 /* Substitute into a unary left fold expression. */
11893 tsubst_unary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11896 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11897 if (pack
== error_mark_node
)
11898 return error_mark_node
;
11899 if (PACK_EXPANSION_P (pack
))
11901 tree r
= copy_node (t
);
11902 FOLD_EXPR_PACK (r
) = pack
;
11905 if (TREE_VEC_LENGTH (pack
) == 0)
11906 return expand_empty_fold (t
, complain
);
11908 return expand_left_fold (t
, pack
, complain
);
11911 /* Substitute into a binary left fold expression.
11913 Do ths by building a single (non-empty) vector of argumnts and
11914 building the expression from those elements. */
11917 tsubst_binary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11920 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11921 if (pack
== error_mark_node
)
11922 return error_mark_node
;
11923 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
11924 if (init
== error_mark_node
)
11925 return error_mark_node
;
11927 if (PACK_EXPANSION_P (pack
))
11929 tree r
= copy_node (t
);
11930 FOLD_EXPR_PACK (r
) = pack
;
11931 FOLD_EXPR_INIT (r
) = init
;
11935 tree vec
= make_tree_vec (TREE_VEC_LENGTH (pack
) + 1);
11936 TREE_VEC_ELT (vec
, 0) = init
;
11937 for (int i
= 0; i
< TREE_VEC_LENGTH (pack
); ++i
)
11938 TREE_VEC_ELT (vec
, i
+ 1) = TREE_VEC_ELT (pack
, i
);
11940 return expand_left_fold (t
, vec
, complain
);
11943 /* Expand a PACK of arguments into a grouped as right fold.
11944 Given a pack containing elementns A0, A1, ..., and an
11945 operator @, this builds the expression:
11947 A0@ ... (An-2 @ (An-1 @ An))
11949 Note that PACK must not be empty.
11951 The operator is defined by the original fold expression T. */
11954 expand_right_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11956 // Build the expression.
11957 int n
= TREE_VEC_LENGTH (pack
);
11958 tree right
= TREE_VEC_ELT (pack
, n
- 1);
11959 for (--n
; n
!= 0; --n
)
11961 tree left
= TREE_VEC_ELT (pack
, n
- 1);
11962 right
= fold_expression (t
, left
, right
, complain
);
11967 /* Substitute into a unary right fold expression. */
11970 tsubst_unary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
11973 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11974 if (pack
== error_mark_node
)
11975 return error_mark_node
;
11976 if (PACK_EXPANSION_P (pack
))
11978 tree r
= copy_node (t
);
11979 FOLD_EXPR_PACK (r
) = pack
;
11982 if (TREE_VEC_LENGTH (pack
) == 0)
11983 return expand_empty_fold (t
, complain
);
11985 return expand_right_fold (t
, pack
, complain
);
11988 /* Substitute into a binary right fold expression.
11990 Do ths by building a single (non-empty) vector of arguments and
11991 building the expression from those elements. */
11994 tsubst_binary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
11997 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11998 if (pack
== error_mark_node
)
11999 return error_mark_node
;
12000 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
12001 if (init
== error_mark_node
)
12002 return error_mark_node
;
12004 if (PACK_EXPANSION_P (pack
))
12006 tree r
= copy_node (t
);
12007 FOLD_EXPR_PACK (r
) = pack
;
12008 FOLD_EXPR_INIT (r
) = init
;
12012 int n
= TREE_VEC_LENGTH (pack
);
12013 tree vec
= make_tree_vec (n
+ 1);
12014 for (int i
= 0; i
< n
; ++i
)
12015 TREE_VEC_ELT (vec
, i
) = TREE_VEC_ELT (pack
, i
);
12016 TREE_VEC_ELT (vec
, n
) = init
;
12018 return expand_right_fold (t
, vec
, complain
);
12021 /* Walk through the pattern of a pack expansion, adding everything in
12022 local_specializations to a list. */
12026 hash_set
<tree
> internal
;
12028 tsubst_flags_t complain
;
12030 el_data (tsubst_flags_t c
)
12031 : extra (NULL_TREE
), complain (c
) {}
12034 extract_locals_r (tree
*tp
, int */
*walk_subtrees*/
, void *data_
)
12036 el_data
&data
= *reinterpret_cast<el_data
*>(data_
);
12037 tree
*extra
= &data
.extra
;
12038 tsubst_flags_t complain
= data
.complain
;
12040 if (TYPE_P (*tp
) && typedef_variant_p (*tp
))
12041 /* Remember local typedefs (85214). */
12042 tp
= &TYPE_NAME (*tp
);
12044 if (TREE_CODE (*tp
) == DECL_EXPR
)
12045 data
.internal
.add (DECL_EXPR_DECL (*tp
));
12046 else if (tree spec
= retrieve_local_specialization (*tp
))
12048 if (data
.internal
.contains (*tp
))
12049 /* Don't mess with variables declared within the pattern. */
12051 if (TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
)
12053 /* Maybe pull out the PARM_DECL for a partial instantiation. */
12054 tree args
= ARGUMENT_PACK_ARGS (spec
);
12055 if (TREE_VEC_LENGTH (args
) == 1)
12057 tree elt
= TREE_VEC_ELT (args
, 0);
12058 if (PACK_EXPANSION_P (elt
))
12059 elt
= PACK_EXPANSION_PATTERN (elt
);
12060 if (DECL_PACK_P (elt
))
12063 if (TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
)
12065 /* Handle lambda capture here, since we aren't doing any
12066 substitution now, and so tsubst_copy won't call
12067 process_outer_var_ref. */
12068 tree args
= ARGUMENT_PACK_ARGS (spec
);
12069 int len
= TREE_VEC_LENGTH (args
);
12070 for (int i
= 0; i
< len
; ++i
)
12072 tree arg
= TREE_VEC_ELT (args
, i
);
12074 if (outer_automatic_var_p (arg
))
12075 carg
= process_outer_var_ref (arg
, complain
);
12078 /* Make a new NONTYPE_ARGUMENT_PACK of the capture
12082 spec
= copy_node (spec
);
12083 args
= copy_node (args
);
12084 SET_ARGUMENT_PACK_ARGS (spec
, args
);
12085 register_local_specialization (spec
, *tp
);
12087 TREE_VEC_ELT (args
, i
) = carg
;
12092 if (outer_automatic_var_p (spec
))
12093 spec
= process_outer_var_ref (spec
, complain
);
12094 *extra
= tree_cons (*tp
, spec
, *extra
);
12099 extract_local_specs (tree pattern
, tsubst_flags_t complain
)
12101 el_data
data (complain
);
12102 cp_walk_tree_without_duplicates (&pattern
, extract_locals_r
, &data
);
12106 /* Extract any uses of local_specializations from PATTERN and add them to ARGS
12107 for use in PACK_EXPANSION_EXTRA_ARGS. */
12110 build_extra_args (tree pattern
, tree args
, tsubst_flags_t complain
)
12113 if (local_specializations
)
12114 if (tree locals
= extract_local_specs (pattern
, complain
))
12115 extra
= tree_cons (NULL_TREE
, extra
, locals
);
12119 /* Apply any local specializations from PACK_EXPANSION_EXTRA_ARGS and add the
12120 normal template args to ARGS. */
12123 add_extra_args (tree extra
, tree args
)
12125 if (extra
&& TREE_CODE (extra
) == TREE_LIST
)
12127 for (tree elt
= TREE_CHAIN (extra
); elt
; elt
= TREE_CHAIN (elt
))
12129 /* The partial instantiation involved local declarations collected in
12130 extract_local_specs; map from the general template to our local
12132 tree gen
= TREE_PURPOSE (elt
);
12133 tree inst
= TREE_VALUE (elt
);
12135 if (tree local
= retrieve_local_specialization (inst
))
12137 /* else inst is already a full instantiation of the pack. */
12138 register_local_specialization (inst
, gen
);
12140 gcc_assert (!TREE_PURPOSE (extra
));
12141 extra
= TREE_VALUE (extra
);
12143 return add_to_template_args (extra
, args
);
12146 /* Substitute ARGS into T, which is an pack expansion
12147 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
12148 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
12149 (if only a partial substitution could be performed) or
12150 ERROR_MARK_NODE if there was an error. */
12152 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
12156 tree pack
, packs
= NULL_TREE
;
12157 bool unsubstituted_packs
= false;
12158 bool unsubstituted_fn_pack
= false;
12161 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
12162 bool need_local_specializations
= false;
12165 gcc_assert (PACK_EXPANSION_P (t
));
12166 pattern
= PACK_EXPANSION_PATTERN (t
);
12168 /* Add in any args remembered from an earlier partial instantiation. */
12169 args
= add_extra_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
12171 levels
= TMPL_ARGS_DEPTH (args
);
12173 /* Determine the argument packs that will instantiate the parameter
12174 packs used in the expansion expression. While we're at it,
12175 compute the number of arguments to be expanded and make sure it
12177 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
12178 pack
= TREE_CHAIN (pack
))
12180 tree parm_pack
= TREE_VALUE (pack
);
12181 tree arg_pack
= NULL_TREE
;
12182 tree orig_arg
= NULL_TREE
;
12185 if (TREE_CODE (parm_pack
) == BASES
)
12187 gcc_assert (parm_pack
== pattern
);
12188 if (BASES_DIRECT (parm_pack
))
12189 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
12194 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
12195 args
, complain
, in_decl
,
12198 else if (builtin_pack_call_p (parm_pack
))
12200 if (parm_pack
!= pattern
)
12202 if (complain
& tf_error
)
12203 sorry ("%qE is not the entire pattern of the pack expansion",
12205 return error_mark_node
;
12207 return expand_builtin_pack_call (parm_pack
, args
,
12208 complain
, in_decl
);
12210 else if (TREE_CODE (parm_pack
) == PARM_DECL
)
12212 /* We know we have correct local_specializations if this
12213 expansion is at function scope, or if we're dealing with a
12214 local parameter in a requires expression; for the latter,
12215 tsubst_requires_expr set it up appropriately. */
12216 if (PACK_EXPANSION_LOCAL_P (t
) || CONSTRAINT_VAR_P (parm_pack
))
12217 arg_pack
= retrieve_local_specialization (parm_pack
);
12219 /* We can't rely on local_specializations for a parameter
12220 name used later in a function declaration (such as in a
12221 late-specified return type). Even if it exists, it might
12222 have the wrong value for a recursive call. */
12223 need_local_specializations
= true;
12227 /* This parameter pack was used in an unevaluated context. Just
12228 make a dummy decl, since it's only used for its type. */
12229 ++cp_unevaluated_operand
;
12230 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
12231 --cp_unevaluated_operand
;
12232 if (arg_pack
&& DECL_PACK_P (arg_pack
))
12233 /* Partial instantiation of the parm_pack, we can't build
12234 up an argument pack yet. */
12235 arg_pack
= NULL_TREE
;
12237 arg_pack
= make_fnparm_pack (arg_pack
);
12239 else if (argument_pack_element_is_expansion_p (arg_pack
, 0))
12240 /* This argument pack isn't fully instantiated yet. We set this
12241 flag rather than clear arg_pack because we do want to do the
12242 optimization below, and we don't want to substitute directly
12243 into the pattern (as that would expose a NONTYPE_ARGUMENT_PACK
12244 where it isn't expected). */
12245 unsubstituted_fn_pack
= true;
12247 else if (is_capture_proxy (parm_pack
))
12249 arg_pack
= retrieve_local_specialization (parm_pack
);
12250 if (argument_pack_element_is_expansion_p (arg_pack
, 0))
12251 unsubstituted_fn_pack
= true;
12256 template_parm_level_and_index (parm_pack
, &level
, &idx
);
12258 if (level
<= levels
)
12259 arg_pack
= TMPL_ARG (args
, level
, idx
);
12262 orig_arg
= arg_pack
;
12263 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
12264 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
12266 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
12267 /* This can only happen if we forget to expand an argument
12268 pack somewhere else. Just return an error, silently. */
12270 result
= make_tree_vec (1);
12271 TREE_VEC_ELT (result
, 0) = error_mark_node
;
12278 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
12280 /* Don't bother trying to do a partial substitution with
12281 incomplete packs; we'll try again after deduction. */
12282 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
12287 else if (len
!= my_len
12288 && !unsubstituted_fn_pack
)
12290 if (!(complain
& tf_error
))
12291 /* Fail quietly. */;
12292 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
12293 error ("mismatched argument pack lengths while expanding %qT",
12296 error ("mismatched argument pack lengths while expanding %qE",
12298 return error_mark_node
;
12301 /* Keep track of the parameter packs and their corresponding
12303 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
12304 TREE_TYPE (packs
) = orig_arg
;
12308 /* We can't substitute for this parameter pack. We use a flag as
12309 well as the missing_level counter because function parameter
12310 packs don't have a level. */
12311 gcc_assert (processing_template_decl
|| is_auto (parm_pack
));
12312 unsubstituted_packs
= true;
12316 /* If the expansion is just T..., return the matching argument pack, unless
12317 we need to call convert_from_reference on all the elements. This is an
12318 important optimization; see c++/68422. */
12319 if (!unsubstituted_packs
12320 && TREE_PURPOSE (packs
) == pattern
)
12322 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
12324 /* If the argument pack is a single pack expansion, pull it out. */
12325 if (TREE_VEC_LENGTH (args
) == 1
12326 && pack_expansion_args_count (args
))
12327 return TREE_VEC_ELT (args
, 0);
12329 /* Types need no adjustment, nor does sizeof..., and if we still have
12330 some pack expansion args we won't do anything yet. */
12331 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
12332 || PACK_EXPANSION_SIZEOF_P (t
)
12333 || pack_expansion_args_count (args
))
12335 /* Also optimize expression pack expansions if we can tell that the
12336 elements won't have reference type. */
12337 tree type
= TREE_TYPE (pattern
);
12338 if (type
&& !TYPE_REF_P (type
)
12339 && !PACK_EXPANSION_P (type
)
12340 && !WILDCARD_TYPE_P (type
))
12342 /* Otherwise use the normal path so we get convert_from_reference. */
12345 /* We cannot expand this expansion expression, because we don't have
12346 all of the argument packs we need. */
12347 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
12349 /* We got some full packs, but we can't substitute them in until we
12350 have values for all the packs. So remember these until then. */
12352 t
= make_pack_expansion (pattern
, complain
);
12353 PACK_EXPANSION_EXTRA_ARGS (t
)
12354 = build_extra_args (pattern
, args
, complain
);
12357 else if (unsubstituted_packs
)
12359 /* There were no real arguments, we're just replacing a parameter
12360 pack with another version of itself. Substitute into the
12361 pattern and return a PACK_EXPANSION_*. The caller will need to
12363 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
12364 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
12365 /*integral_constant_expression_p=*/false);
12367 t
= tsubst (pattern
, args
, complain
, in_decl
);
12368 t
= make_pack_expansion (t
, complain
);
12372 gcc_assert (len
>= 0);
12374 if (need_local_specializations
)
12376 /* We're in a late-specified return type, so create our own local
12377 specializations map; the current map is either NULL or (in the
12378 case of recursive unification) might have bindings that we don't
12379 want to use or alter. */
12380 saved_local_specializations
= local_specializations
;
12381 local_specializations
= new hash_map
<tree
, tree
>;
12384 /* For each argument in each argument pack, substitute into the
12386 result
= make_tree_vec (len
);
12387 tree elem_args
= copy_template_args (args
);
12388 for (i
= 0; i
< len
; ++i
)
12390 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
12392 elem_args
, complain
,
12394 TREE_VEC_ELT (result
, i
) = t
;
12395 if (t
== error_mark_node
)
12397 result
= error_mark_node
;
12402 /* Update ARGS to restore the substitution from parameter packs to
12403 their argument packs. */
12404 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12406 tree parm
= TREE_PURPOSE (pack
);
12408 if (TREE_CODE (parm
) == PARM_DECL
12410 || TREE_CODE (parm
) == FIELD_DECL
)
12411 register_local_specialization (TREE_TYPE (pack
), parm
);
12416 if (TREE_VALUE (pack
) == NULL_TREE
)
12419 template_parm_level_and_index (parm
, &level
, &idx
);
12421 /* Update the corresponding argument. */
12422 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
12423 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
12426 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
12430 if (need_local_specializations
)
12432 delete local_specializations
;
12433 local_specializations
= saved_local_specializations
;
12436 /* If the dependent pack arguments were such that we end up with only a
12437 single pack expansion again, there's no need to keep it in a TREE_VEC. */
12438 if (len
== 1 && TREE_CODE (result
) == TREE_VEC
12439 && PACK_EXPANSION_P (TREE_VEC_ELT (result
, 0)))
12440 return TREE_VEC_ELT (result
, 0);
12445 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
12446 TMPL. We do this using DECL_PARM_INDEX, which should work even with
12447 parameter packs; all parms generated from a function parameter pack will
12448 have the same DECL_PARM_INDEX. */
12451 get_pattern_parm (tree parm
, tree tmpl
)
12453 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
12456 if (DECL_ARTIFICIAL (parm
))
12458 for (patparm
= DECL_ARGUMENTS (pattern
);
12459 patparm
; patparm
= DECL_CHAIN (patparm
))
12460 if (DECL_ARTIFICIAL (patparm
)
12461 && DECL_NAME (parm
) == DECL_NAME (patparm
))
12466 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
12467 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
12468 gcc_assert (DECL_PARM_INDEX (patparm
)
12469 == DECL_PARM_INDEX (parm
));
12475 /* Make an argument pack out of the TREE_VEC VEC. */
12478 make_argument_pack (tree vec
)
12481 tree elt
= TREE_VEC_ELT (vec
, 0);
12483 pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
12486 pack
= make_node (NONTYPE_ARGUMENT_PACK
);
12487 TREE_CONSTANT (pack
) = 1;
12489 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
12493 /* Return an exact copy of template args T that can be modified
12497 copy_template_args (tree t
)
12499 if (t
== error_mark_node
)
12502 int len
= TREE_VEC_LENGTH (t
);
12503 tree new_vec
= make_tree_vec (len
);
12505 for (int i
= 0; i
< len
; ++i
)
12507 tree elt
= TREE_VEC_ELT (t
, i
);
12508 if (elt
&& TREE_CODE (elt
) == TREE_VEC
)
12509 elt
= copy_template_args (elt
);
12510 TREE_VEC_ELT (new_vec
, i
) = elt
;
12513 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_vec
)
12514 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
12519 /* Substitute ARGS into the vector or list of template arguments T. */
12522 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12525 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
12528 if (t
== error_mark_node
)
12529 return error_mark_node
;
12531 len
= TREE_VEC_LENGTH (t
);
12532 elts
= XALLOCAVEC (tree
, len
);
12534 for (i
= 0; i
< len
; i
++)
12536 tree orig_arg
= TREE_VEC_ELT (t
, i
);
12539 if (TREE_CODE (orig_arg
) == TREE_VEC
)
12540 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
12541 else if (PACK_EXPANSION_P (orig_arg
))
12543 /* Substitute into an expansion expression. */
12544 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
12546 if (TREE_CODE (new_arg
) == TREE_VEC
)
12547 /* Add to the expanded length adjustment the number of
12548 expanded arguments. We subtract one from this
12549 measurement, because the argument pack expression
12550 itself is already counted as 1 in
12551 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
12552 the argument pack is empty. */
12553 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
12555 else if (ARGUMENT_PACK_P (orig_arg
))
12557 /* Substitute into each of the arguments. */
12558 new_arg
= TYPE_P (orig_arg
)
12559 ? cxx_make_type (TREE_CODE (orig_arg
))
12560 : make_node (TREE_CODE (orig_arg
));
12562 tree pack_args
= tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
12563 args
, complain
, in_decl
);
12564 if (pack_args
== error_mark_node
)
12565 new_arg
= error_mark_node
;
12567 SET_ARGUMENT_PACK_ARGS (new_arg
, pack_args
);
12569 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
)
12570 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
12573 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
12575 if (new_arg
== error_mark_node
)
12576 return error_mark_node
;
12579 if (new_arg
!= orig_arg
)
12586 /* Make space for the expanded arguments coming from template
12588 t
= make_tree_vec (len
+ expanded_len_adjust
);
12589 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
12590 arguments for a member template.
12591 In that case each TREE_VEC in ORIG_T represents a level of template
12592 arguments, and ORIG_T won't carry any non defaulted argument count.
12593 It will rather be the nested TREE_VECs that will carry one.
12594 In other words, ORIG_T carries a non defaulted argument count only
12595 if it doesn't contain any nested TREE_VEC. */
12596 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
12598 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
12599 count
+= expanded_len_adjust
;
12600 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
12602 for (i
= 0, out
= 0; i
< len
; i
++)
12604 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
12605 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
12606 && TREE_CODE (elts
[i
]) == TREE_VEC
)
12610 /* Now expand the template argument pack "in place". */
12611 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
12612 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
12616 TREE_VEC_ELT (t
, out
) = elts
[i
];
12624 /* Substitute ARGS into one level PARMS of template parameters. */
12627 tsubst_template_parms_level (tree parms
, tree args
, tsubst_flags_t complain
)
12629 if (parms
== error_mark_node
)
12630 return error_mark_node
;
12632 tree new_vec
= make_tree_vec (TREE_VEC_LENGTH (parms
));
12634 for (int i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
12636 tree tuple
= TREE_VEC_ELT (parms
, i
);
12638 if (tuple
== error_mark_node
)
12641 TREE_VEC_ELT (new_vec
, i
) =
12642 tsubst_template_parm (tuple
, args
, complain
);
12648 /* Return the result of substituting ARGS into the template parameters
12649 given by PARMS. If there are m levels of ARGS and m + n levels of
12650 PARMS, then the result will contain n levels of PARMS. For
12651 example, if PARMS is `template <class T> template <class U>
12652 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
12653 result will be `template <int*, double, class V>'. */
12656 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
12658 tree r
= NULL_TREE
;
12661 /* When substituting into a template, we must set
12662 PROCESSING_TEMPLATE_DECL as the template parameters may be
12663 dependent if they are based on one-another, and the dependency
12664 predicates are short-circuit outside of templates. */
12665 ++processing_template_decl
;
12667 for (new_parms
= &r
;
12668 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
12669 new_parms
= &(TREE_CHAIN (*new_parms
)),
12670 parms
= TREE_CHAIN (parms
))
12672 tree new_vec
= tsubst_template_parms_level (TREE_VALUE (parms
),
12675 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
12676 - TMPL_ARGS_DEPTH (args
)),
12677 new_vec
, NULL_TREE
);
12680 --processing_template_decl
;
12685 /* Return the result of substituting ARGS into one template parameter
12686 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
12687 parameter and which TREE_PURPOSE is the default argument of the
12688 template parameter. */
12691 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
12693 tree default_value
, parm_decl
;
12695 if (args
== NULL_TREE
12697 || t
== error_mark_node
)
12700 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
12702 default_value
= TREE_PURPOSE (t
);
12703 parm_decl
= TREE_VALUE (t
);
12705 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
12706 if (TREE_CODE (parm_decl
) == PARM_DECL
12707 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
12708 parm_decl
= error_mark_node
;
12709 default_value
= tsubst_template_arg (default_value
, args
,
12710 complain
, NULL_TREE
);
12712 return build_tree_list (default_value
, parm_decl
);
12715 /* Substitute the ARGS into the indicated aggregate (or enumeration)
12716 type T. If T is not an aggregate or enumeration type, it is
12717 handled as if by tsubst. IN_DECL is as for tsubst. If
12718 ENTERING_SCOPE is nonzero, T is the context for a template which
12719 we are presently tsubst'ing. Return the substituted value. */
12722 tsubst_aggr_type (tree t
,
12724 tsubst_flags_t complain
,
12726 int entering_scope
)
12728 if (t
== NULL_TREE
)
12731 switch (TREE_CODE (t
))
12734 if (TYPE_PTRMEMFUNC_P (t
))
12735 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
12737 /* Fall through. */
12738 case ENUMERAL_TYPE
:
12740 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
12746 /* In "sizeof(X<I>)" we need to evaluate "I". */
12749 /* First, determine the context for the type we are looking
12751 context
= TYPE_CONTEXT (t
);
12752 if (context
&& TYPE_P (context
))
12754 context
= tsubst_aggr_type (context
, args
, complain
,
12755 in_decl
, /*entering_scope=*/1);
12756 /* If context is a nested class inside a class template,
12757 it may still need to be instantiated (c++/33959). */
12758 context
= complete_type (context
);
12761 /* Then, figure out what arguments are appropriate for the
12762 type we are trying to find. For example, given:
12764 template <class T> struct S;
12765 template <class T, class U> void f(T, U) { S<U> su; }
12767 and supposing that we are instantiating f<int, double>,
12768 then our ARGS will be {int, double}, but, when looking up
12769 S we only want {double}. */
12770 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
12771 complain
, in_decl
);
12772 if (argvec
== error_mark_node
)
12773 r
= error_mark_node
;
12776 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
12777 entering_scope
, complain
);
12778 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12784 /* This is not a template type, so there's nothing to do. */
12788 return tsubst (t
, args
, complain
, in_decl
);
12792 static GTY((cache
)) tree_cache_map
*defarg_inst
;
12794 /* Substitute into the default argument ARG (a default argument for
12795 FN), which has the indicated TYPE. */
12798 tsubst_default_argument (tree fn
, int parmnum
, tree type
, tree arg
,
12799 tsubst_flags_t complain
)
12801 int errs
= errorcount
+ sorrycount
;
12803 /* This can happen in invalid code. */
12804 if (TREE_CODE (arg
) == DEFAULT_ARG
)
12807 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
12808 parm
= chain_index (parmnum
, parm
);
12809 tree parmtype
= TREE_TYPE (parm
);
12810 if (DECL_BY_REFERENCE (parm
))
12811 parmtype
= TREE_TYPE (parmtype
);
12812 if (parmtype
== error_mark_node
)
12813 return error_mark_node
;
12815 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, parmtype
));
12818 if (defarg_inst
&& (slot
= defarg_inst
->get (parm
)))
12821 /* This default argument came from a template. Instantiate the
12822 default argument here, not in tsubst. In the case of
12831 we must be careful to do name lookup in the scope of S<T>,
12832 rather than in the current class. */
12833 push_to_top_level ();
12834 push_access_scope (fn
);
12835 push_deferring_access_checks (dk_no_deferred
);
12836 start_lambda_scope (parm
);
12838 /* The default argument expression may cause implicitly defined
12839 member functions to be synthesized, which will result in garbage
12840 collection. We must treat this situation as if we were within
12841 the body of function so as to avoid collecting live data on the
12844 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
12845 complain
, NULL_TREE
,
12846 /*integral_constant_expression_p=*/false);
12849 finish_lambda_scope ();
12851 /* Make sure the default argument is reasonable. */
12852 arg
= check_default_argument (type
, arg
, complain
);
12854 if (errorcount
+sorrycount
> errs
12855 && (complain
& tf_warning_or_error
))
12856 inform (input_location
,
12857 " when instantiating default argument for call to %qD", fn
);
12859 pop_deferring_access_checks ();
12860 pop_access_scope (fn
);
12861 pop_from_top_level ();
12863 if (arg
!= error_mark_node
&& !cp_unevaluated_operand
)
12866 defarg_inst
= tree_cache_map::create_ggc (37);
12867 defarg_inst
->put (parm
, arg
);
12873 /* Substitute into all the default arguments for FN. */
12876 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
12881 tmpl_args
= DECL_TI_ARGS (fn
);
12883 /* If this function is not yet instantiated, we certainly don't need
12884 its default arguments. */
12885 if (uses_template_parms (tmpl_args
))
12887 /* Don't do this again for clones. */
12888 if (DECL_CLONED_FUNCTION_P (fn
))
12892 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
12894 arg
= TREE_CHAIN (arg
), ++i
)
12895 if (TREE_PURPOSE (arg
))
12896 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
, i
,
12898 TREE_PURPOSE (arg
),
12902 /* Hash table mapping a FUNCTION_DECL to its dependent explicit-specifier. */
12903 static GTY((cache
)) tree_cache_map
*explicit_specifier_map
;
12905 /* Store a pair to EXPLICIT_SPECIFIER_MAP. */
12908 store_explicit_specifier (tree v
, tree t
)
12910 if (!explicit_specifier_map
)
12911 explicit_specifier_map
= tree_cache_map::create_ggc (37);
12912 DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (v
) = true;
12913 explicit_specifier_map
->put (v
, t
);
12916 /* Lookup an element in EXPLICIT_SPECIFIER_MAP. */
12919 lookup_explicit_specifier (tree v
)
12921 return *explicit_specifier_map
->get (v
);
12924 /* Subroutine of tsubst_decl for the case when T is a FUNCTION_DECL. */
12927 tsubst_function_decl (tree t
, tree args
, tsubst_flags_t complain
,
12928 tree lambda_fntype
)
12930 tree gen_tmpl
, argvec
;
12931 hashval_t hash
= 0;
12934 /* Nobody should be tsubst'ing into non-template functions. */
12935 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
12937 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
12939 /* If T is not dependent, just return it. */
12940 if (!uses_template_parms (DECL_TI_ARGS (t
))
12941 && !LAMBDA_FUNCTION_P (t
))
12944 /* Calculate the most general template of which R is a
12946 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
12948 /* We're substituting a lambda function under tsubst_lambda_expr but not
12949 directly from it; find the matching function we're already inside.
12950 But don't do this if T is a generic lambda with a single level of
12951 template parms, as in that case we're doing a normal instantiation. */
12952 if (LAMBDA_FUNCTION_P (t
) && !lambda_fntype
12953 && (!generic_lambda_fn_p (t
)
12954 || TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
)) > 1))
12955 return enclosing_instantiation_of (t
);
12957 /* Calculate the complete set of arguments used to
12959 argvec
= tsubst_template_args (DECL_TI_ARGS
12960 (DECL_TEMPLATE_RESULT
12961 (DECL_TI_TEMPLATE (t
))),
12962 args
, complain
, in_decl
);
12963 if (argvec
== error_mark_node
)
12964 return error_mark_node
;
12966 /* Check to see if we already have this specialization. */
12967 if (!lambda_fntype
)
12969 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
12970 if (tree spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
))
12974 /* We can see more levels of arguments than parameters if
12975 there was a specialization of a member template, like
12978 template <class T> struct S { template <class U> void f(); }
12979 template <> template <class U> void S<int>::f(U);
12981 Here, we'll be substituting into the specialization,
12982 because that's where we can find the code we actually
12983 want to generate, but we'll have enough arguments for
12984 the most general template.
12986 We also deal with the peculiar case:
12988 template <class T> struct S {
12989 template <class U> friend void f();
12991 template <class U> void f() {}
12993 template void f<double>();
12995 Here, the ARGS for the instantiation of will be {int,
12996 double}. But, we only need as many ARGS as there are
12997 levels of template parameters in CODE_PATTERN. We are
12998 careful not to get fooled into reducing the ARGS in
13001 template <class T> struct S { template <class U> void f(U); }
13002 template <class T> template <> void S<T>::f(int) {}
13004 which we can spot because the pattern will be a
13005 specialization in this case. */
13006 int args_depth
= TMPL_ARGS_DEPTH (args
);
13008 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
13010 if (args_depth
> parms_depth
&& !DECL_TEMPLATE_SPECIALIZATION (t
))
13011 args
= get_innermost_template_args (args
, parms_depth
);
13015 /* This special case arises when we have something like this:
13017 template <class T> struct S {
13018 friend void f<int>(int, double);
13021 Here, the DECL_TI_TEMPLATE for the friend declaration
13022 will be an IDENTIFIER_NODE. We are being called from
13023 tsubst_friend_function, and we want only to create a
13024 new decl (R) with appropriate types so that we can call
13025 determine_specialization. */
13026 gen_tmpl
= NULL_TREE
;
13027 argvec
= NULL_TREE
;
13030 tree closure
= (lambda_fntype
? TYPE_METHOD_BASETYPE (lambda_fntype
)
13032 tree ctx
= closure
? closure
: DECL_CONTEXT (t
);
13033 bool member
= ctx
&& TYPE_P (ctx
);
13035 if (member
&& !closure
)
13036 ctx
= tsubst_aggr_type (ctx
, args
,
13037 complain
, t
, /*entering_scope=*/1);
13039 tree type
= (lambda_fntype
? lambda_fntype
13040 : tsubst (TREE_TYPE (t
), args
,
13041 complain
| tf_fndecl_type
, in_decl
));
13042 if (type
== error_mark_node
)
13043 return error_mark_node
;
13045 /* If we hit excessive deduction depth, the type is bogus even if
13046 it isn't error_mark_node, so don't build a decl. */
13047 if (excessive_deduction_depth
)
13048 return error_mark_node
;
13050 /* We do NOT check for matching decls pushed separately at this
13051 point, as they may not represent instantiations of this
13052 template, and in any case are considered separate under the
13054 tree r
= copy_decl (t
);
13055 DECL_USE_TEMPLATE (r
) = 0;
13056 TREE_TYPE (r
) = type
;
13057 /* Clear out the mangled name and RTL for the instantiation. */
13058 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
13059 SET_DECL_RTL (r
, NULL
);
13060 /* Leave DECL_INITIAL set on deleted instantiations. */
13061 if (!DECL_DELETED_FN (r
))
13062 DECL_INITIAL (r
) = NULL_TREE
;
13063 DECL_CONTEXT (r
) = ctx
;
13065 /* Handle explicit(dependent-expr). */
13066 if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t
))
13068 tree spec
= lookup_explicit_specifier (t
);
13069 spec
= tsubst_copy_and_build (spec
, args
, complain
, in_decl
,
13070 /*function_p=*/false,
13072 spec
= build_explicit_specifier (spec
, complain
);
13073 DECL_NONCONVERTING_P (r
) = (spec
== boolean_true_node
);
13076 /* OpenMP UDRs have the only argument a reference to the declared
13077 type. We want to diagnose if the declared type is a reference,
13078 which is invalid, but as references to references are usually
13079 quietly merged, diagnose it here. */
13080 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
13083 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
13084 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
13085 if (TYPE_REF_P (argtype
))
13086 error_at (DECL_SOURCE_LOCATION (t
),
13087 "reference type %qT in "
13088 "%<#pragma omp declare reduction%>", argtype
);
13089 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
13090 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
13094 if (member
&& DECL_CONV_FN_P (r
))
13095 /* Type-conversion operator. Reconstruct the name, in
13096 case it's the name of one of the template's parameters. */
13097 DECL_NAME (r
) = make_conv_op_name (TREE_TYPE (type
));
13099 tree parms
= DECL_ARGUMENTS (t
);
13101 parms
= DECL_CHAIN (parms
);
13102 parms
= tsubst (parms
, args
, complain
, t
);
13103 for (tree parm
= parms
; parm
; parm
= DECL_CHAIN (parm
))
13104 DECL_CONTEXT (parm
) = r
;
13107 tree tparm
= build_this_parm (r
, closure
, type_memfn_quals (type
));
13108 DECL_CHAIN (tparm
) = parms
;
13111 DECL_ARGUMENTS (r
) = parms
;
13112 DECL_RESULT (r
) = NULL_TREE
;
13114 TREE_STATIC (r
) = 0;
13115 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
13116 DECL_EXTERNAL (r
) = 1;
13117 /* If this is an instantiation of a function with internal
13118 linkage, we already know what object file linkage will be
13119 assigned to the instantiation. */
13120 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
13121 DECL_DEFER_OUTPUT (r
) = 0;
13122 DECL_CHAIN (r
) = NULL_TREE
;
13123 DECL_PENDING_INLINE_INFO (r
) = 0;
13124 DECL_PENDING_INLINE_P (r
) = 0;
13125 DECL_SAVED_TREE (r
) = NULL_TREE
;
13126 DECL_STRUCT_FUNCTION (r
) = NULL
;
13128 /* We'll re-clone as appropriate in instantiate_template. */
13129 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
13131 /* If we aren't complaining now, return on error before we register
13132 the specialization so that we'll complain eventually. */
13133 if ((complain
& tf_error
) == 0
13134 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
13135 && !grok_op_properties (r
, /*complain=*/false))
13136 return error_mark_node
;
13138 /* When instantiating a constrained member, substitute
13139 into the constraints to create a new constraint. */
13140 if (tree ci
= get_constraints (t
))
13143 ci
= tsubst_constraint_info (ci
, argvec
, complain
, NULL_TREE
);
13144 set_constraints (r
, ci
);
13147 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
13148 SET_DECL_FRIEND_CONTEXT (r
,
13149 tsubst (DECL_FRIEND_CONTEXT (t
),
13150 args
, complain
, in_decl
));
13152 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
13153 this in the special friend case mentioned above where
13154 GEN_TMPL is NULL. */
13155 if (gen_tmpl
&& !closure
)
13157 DECL_TEMPLATE_INFO (r
)
13158 = build_template_info (gen_tmpl
, argvec
);
13159 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13162 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
13164 /* We instantiated this while substituting into
13165 the type earlier (template/friend54.C). */
13168 /* We're not supposed to instantiate default arguments
13169 until they are called, for a template. But, for a
13172 template <class T> void f ()
13173 { extern void g(int i = T()); }
13175 we should do the substitution when the template is
13176 instantiated. We handle the member function case in
13177 instantiate_class_template since the default arguments
13178 might refer to other members of the class. */
13180 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
13181 && !uses_template_parms (argvec
))
13182 tsubst_default_arguments (r
, complain
);
13185 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13187 /* Copy the list of befriending classes. */
13188 for (tree
*friends
= &DECL_BEFRIENDING_CLASSES (r
);
13190 friends
= &TREE_CHAIN (*friends
))
13192 *friends
= copy_node (*friends
);
13193 TREE_VALUE (*friends
)
13194 = tsubst (TREE_VALUE (*friends
), args
, complain
, in_decl
);
13197 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
13199 maybe_retrofit_in_chrg (r
);
13200 if (DECL_CONSTRUCTOR_P (r
) && !grok_ctor_properties (ctx
, r
))
13201 return error_mark_node
;
13202 /* If this is an instantiation of a member template, clone it.
13203 If it isn't, that'll be handled by
13204 clone_constructors_and_destructors. */
13205 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
13206 clone_function_decl (r
, /*update_methods=*/false);
13208 else if ((complain
& tf_error
) != 0
13209 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
13210 && !grok_op_properties (r
, /*complain=*/true))
13211 return error_mark_node
;
13213 /* Possibly limit visibility based on template args. */
13214 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
13215 if (DECL_VISIBILITY_SPECIFIED (t
))
13217 DECL_VISIBILITY_SPECIFIED (r
) = 0;
13218 DECL_ATTRIBUTES (r
)
13219 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
13221 determine_visibility (r
);
13222 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
13223 && !processing_template_decl
)
13224 defaulted_late_check (r
);
13226 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
13227 args
, complain
, in_decl
);
13231 /* Subroutine of tsubst_decl for the case when T is a TEMPLATE_DECL. */
13234 tsubst_template_decl (tree t
, tree args
, tsubst_flags_t complain
,
13235 tree lambda_fntype
)
13237 /* We can get here when processing a member function template,
13238 member class template, or template template parameter. */
13239 tree decl
= DECL_TEMPLATE_RESULT (t
);
13245 hashval_t hash
= 0;
13247 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
13249 /* Template template parameter is treated here. */
13250 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13251 if (new_type
== error_mark_node
)
13252 r
= error_mark_node
;
13253 /* If we get a real template back, return it. This can happen in
13254 the context of most_specialized_partial_spec. */
13255 else if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
13258 /* The new TEMPLATE_DECL was built in
13259 reduce_template_parm_level. */
13260 r
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (new_type
);
13264 if (!lambda_fntype
)
13266 /* We might already have an instance of this template.
13267 The ARGS are for the surrounding class type, so the
13268 full args contain the tsubst'd args for the context,
13269 plus the innermost args from the template decl. */
13270 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
13271 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
13272 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
13273 /* Because this is a template, the arguments will still be
13274 dependent, even after substitution. If
13275 PROCESSING_TEMPLATE_DECL is not set, the dependency
13276 predicates will short-circuit. */
13277 ++processing_template_decl
;
13278 full_args
= tsubst_template_args (tmpl_args
, args
,
13279 complain
, in_decl
);
13280 --processing_template_decl
;
13281 if (full_args
== error_mark_node
)
13282 return error_mark_node
;
13284 /* If this is a default template template argument,
13285 tsubst might not have changed anything. */
13286 if (full_args
== tmpl_args
)
13289 hash
= hash_tmpl_and_args (t
, full_args
);
13290 spec
= retrieve_specialization (t
, full_args
, hash
);
13291 if (spec
!= NULL_TREE
)
13294 /* Type partial instantiations are stored as the type by
13295 lookup_template_class_1, not here as the template. */
13296 spec
= CLASSTYPE_TI_TEMPLATE (spec
);
13301 /* Make a new template decl. It will be similar to the
13302 original, but will record the current template arguments.
13303 We also create a new function declaration, which is just
13304 like the old one, but points to this new template, rather
13305 than the old one. */
13307 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
13308 DECL_CHAIN (r
) = NULL_TREE
;
13310 // Build new template info linking to the original template decl.
13311 if (!lambda_fntype
)
13313 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
13314 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13317 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13319 /* The template parameters for this new template are all the
13320 template parameters for the old template, except the
13321 outermost level of parameters. */
13322 DECL_TEMPLATE_PARMS (r
)
13323 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
13326 if (TREE_CODE (decl
) == TYPE_DECL
13327 && !TYPE_DECL_ALIAS_P (decl
))
13330 ++processing_template_decl
;
13331 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13332 --processing_template_decl
;
13333 if (new_type
== error_mark_node
)
13334 return error_mark_node
;
13336 TREE_TYPE (r
) = new_type
;
13337 /* For a partial specialization, we need to keep pointing to
13338 the primary template. */
13339 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
13340 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
13341 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
13342 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
13343 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
13348 ++processing_template_decl
;
13349 if (TREE_CODE (decl
) == FUNCTION_DECL
)
13350 new_decl
= tsubst_function_decl (decl
, args
, complain
, lambda_fntype
);
13352 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
13353 --processing_template_decl
;
13354 if (new_decl
== error_mark_node
)
13355 return error_mark_node
;
13357 DECL_TEMPLATE_RESULT (r
) = new_decl
;
13358 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
13359 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
13362 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (r
));
13363 DECL_TEMPLATE_INFO (new_decl
) = build_template_info (r
, args
);
13367 DECL_TI_TEMPLATE (new_decl
) = r
;
13368 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
13372 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
13373 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
13375 if (PRIMARY_TEMPLATE_P (t
))
13376 DECL_PRIMARY_TEMPLATE (r
) = r
;
13378 if (TREE_CODE (decl
) != TYPE_DECL
&& !VAR_P (decl
)
13380 /* Record this non-type partial instantiation. */
13381 register_specialization (r
, t
,
13382 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
13388 /* True if FN is the op() for a lambda in an uninstantiated template. */
13391 lambda_fn_in_template_p (tree fn
)
13393 if (!fn
|| !LAMBDA_FUNCTION_P (fn
))
13395 tree closure
= DECL_CONTEXT (fn
);
13396 return CLASSTYPE_TEMPLATE_INFO (closure
) != NULL_TREE
;
13399 /* True if FN is the substitution (via tsubst_lambda_expr) of a function for
13400 which the above is true. */
13403 instantiated_lambda_fn_p (tree fn
)
13405 if (!fn
|| !LAMBDA_FUNCTION_P (fn
))
13407 tree closure
= DECL_CONTEXT (fn
);
13408 tree lam
= CLASSTYPE_LAMBDA_EXPR (closure
);
13409 return LAMBDA_EXPR_INSTANTIATED (lam
);
13412 /* We're instantiating a variable from template function TCTX. Return the
13413 corresponding current enclosing scope. This gets complicated because lambda
13414 functions in templates are regenerated rather than instantiated, but generic
13415 lambda functions are subsequently instantiated. */
13418 enclosing_instantiation_of (tree otctx
)
13421 tree fn
= current_function_decl
;
13422 int lambda_count
= 0;
13424 for (; tctx
&& (lambda_fn_in_template_p (tctx
)
13425 || instantiated_lambda_fn_p (tctx
));
13426 tctx
= decl_function_context (tctx
))
13428 for (; fn
; fn
= decl_function_context (fn
))
13431 int flambda_count
= 0;
13432 for (; fn
&& instantiated_lambda_fn_p (fn
);
13433 fn
= decl_function_context (fn
))
13435 if ((fn
&& DECL_TEMPLATE_INFO (fn
))
13436 ? most_general_template (fn
) != most_general_template (tctx
)
13439 if (flambda_count
!= lambda_count
)
13441 gcc_assert (flambda_count
> lambda_count
);
13442 for (; flambda_count
> lambda_count
; --flambda_count
)
13443 ofn
= decl_function_context (ofn
);
13445 gcc_assert (DECL_NAME (ofn
) == DECL_NAME (otctx
)
13446 || DECL_CONV_FN_P (ofn
));
13449 gcc_unreachable ();
13452 /* Substitute the ARGS into the T, which is a _DECL. Return the
13453 result of the substitution. Issue error and warning messages under
13454 control of COMPLAIN. */
13457 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
13459 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13460 location_t saved_loc
;
13461 tree r
= NULL_TREE
;
13463 hashval_t hash
= 0;
13465 /* Set the filename and linenumber to improve error-reporting. */
13466 saved_loc
= input_location
;
13467 input_location
= DECL_SOURCE_LOCATION (t
);
13469 switch (TREE_CODE (t
))
13471 case TEMPLATE_DECL
:
13472 r
= tsubst_template_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
13475 case FUNCTION_DECL
:
13476 r
= tsubst_function_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
13481 tree type
= NULL_TREE
;
13483 tree expanded_types
= NULL_TREE
;
13484 tree prev_r
= NULL_TREE
;
13485 tree first_r
= NULL_TREE
;
13487 if (DECL_PACK_P (t
))
13489 /* If there is a local specialization that isn't a
13490 parameter pack, it means that we're doing a "simple"
13491 substitution from inside tsubst_pack_expansion. Just
13492 return the local specialization (which will be a single
13494 tree spec
= retrieve_local_specialization (t
);
13496 && TREE_CODE (spec
) == PARM_DECL
13497 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
13500 /* Expand the TYPE_PACK_EXPANSION that provides the types for
13501 the parameters in this function parameter pack. */
13502 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
13503 complain
, in_decl
);
13504 if (TREE_CODE (expanded_types
) == TREE_VEC
)
13506 len
= TREE_VEC_LENGTH (expanded_types
);
13508 /* Zero-length parameter packs are boring. Just substitute
13511 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
13516 /* All we did was update the type. Make a note of that. */
13517 type
= expanded_types
;
13518 expanded_types
= NULL_TREE
;
13522 /* Loop through all of the parameters we'll build. When T is
13523 a function parameter pack, LEN is the number of expanded
13524 types in EXPANDED_TYPES; otherwise, LEN is 1. */
13526 for (i
= 0; i
< len
; ++i
)
13530 if (DECL_TEMPLATE_PARM_P (t
))
13531 SET_DECL_TEMPLATE_PARM_P (r
);
13533 if (expanded_types
)
13534 /* We're on the Ith parameter of the function parameter
13537 /* Get the Ith type. */
13538 type
= TREE_VEC_ELT (expanded_types
, i
);
13540 /* Rename the parameter to include the index. */
13542 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
13545 /* We're dealing with a normal parameter. */
13546 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13548 type
= type_decays_to (type
);
13549 TREE_TYPE (r
) = type
;
13550 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13552 if (DECL_INITIAL (r
))
13554 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
13555 DECL_INITIAL (r
) = TREE_TYPE (r
);
13557 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
13558 complain
, in_decl
);
13561 DECL_CONTEXT (r
) = NULL_TREE
;
13563 if (!DECL_TEMPLATE_PARM_P (r
))
13564 DECL_ARG_TYPE (r
) = type_passed_as (type
);
13566 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
13567 args
, complain
, in_decl
);
13569 /* Keep track of the first new parameter we
13570 generate. That's what will be returned to the
13575 /* Build a proper chain of parameters when substituting
13576 into a function parameter pack. */
13578 DECL_CHAIN (prev_r
) = r
;
13581 /* If cp_unevaluated_operand is set, we're just looking for a
13582 single dummy parameter, so don't keep going. */
13583 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
13584 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
13585 complain
, DECL_CHAIN (t
));
13587 /* FIRST_R contains the start of the chain we've built. */
13594 tree type
= NULL_TREE
;
13595 tree vec
= NULL_TREE
;
13596 tree expanded_types
= NULL_TREE
;
13599 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
13601 /* This field is a lambda capture pack. Return a TREE_VEC of
13602 the expanded fields to instantiate_class_template_1. */
13603 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
13604 complain
, in_decl
);
13605 if (TREE_CODE (expanded_types
) == TREE_VEC
)
13607 len
= TREE_VEC_LENGTH (expanded_types
);
13608 vec
= make_tree_vec (len
);
13612 /* All we did was update the type. Make a note of that. */
13613 type
= expanded_types
;
13614 expanded_types
= NULL_TREE
;
13618 for (int i
= 0; i
< len
; ++i
)
13621 if (expanded_types
)
13623 type
= TREE_VEC_ELT (expanded_types
, i
);
13625 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
13628 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13630 if (type
== error_mark_node
)
13631 RETURN (error_mark_node
);
13632 TREE_TYPE (r
) = type
;
13633 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13635 if (DECL_C_BIT_FIELD (r
))
13636 /* For bit-fields, DECL_BIT_FIELD_REPRESENTATIVE gives the
13638 DECL_BIT_FIELD_REPRESENTATIVE (r
)
13639 = tsubst_expr (DECL_BIT_FIELD_REPRESENTATIVE (t
), args
,
13641 /*integral_constant_expression_p=*/true);
13642 if (DECL_INITIAL (t
))
13644 /* Set up DECL_TEMPLATE_INFO so that we can get at the
13645 NSDMI in perform_member_init. Still set DECL_INITIAL
13646 so that we know there is one. */
13647 DECL_INITIAL (r
) = void_node
;
13648 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
13649 retrofit_lang_decl (r
);
13650 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
13652 /* We don't have to set DECL_CONTEXT here; it is set by
13653 finish_member_declaration. */
13654 DECL_CHAIN (r
) = NULL_TREE
;
13656 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
13657 args
, complain
, in_decl
);
13660 TREE_VEC_ELT (vec
, i
) = r
;
13669 /* We reach here only for member using decls. We also need to check
13670 uses_template_parms because DECL_DEPENDENT_P is not set for a
13671 using-declaration that designates a member of the current
13672 instantiation (c++/53549). */
13673 if (DECL_DEPENDENT_P (t
)
13674 || uses_template_parms (USING_DECL_SCOPE (t
)))
13676 tree scope
= USING_DECL_SCOPE (t
);
13677 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
13678 if (PACK_EXPANSION_P (scope
))
13680 tree vec
= tsubst_pack_expansion (scope
, args
, complain
, in_decl
);
13681 int len
= TREE_VEC_LENGTH (vec
);
13682 r
= make_tree_vec (len
);
13683 for (int i
= 0; i
< len
; ++i
)
13685 tree escope
= TREE_VEC_ELT (vec
, i
);
13686 tree elt
= do_class_using_decl (escope
, name
);
13689 r
= error_mark_node
;
13694 TREE_PROTECTED (elt
) = TREE_PROTECTED (t
);
13695 TREE_PRIVATE (elt
) = TREE_PRIVATE (t
);
13697 TREE_VEC_ELT (r
, i
) = elt
;
13702 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
13703 complain
, in_decl
);
13704 r
= do_class_using_decl (inst_scope
, name
);
13706 r
= error_mark_node
;
13709 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
13710 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
13717 DECL_CHAIN (r
) = NULL_TREE
;
13724 tree argvec
= NULL_TREE
;
13725 tree gen_tmpl
= NULL_TREE
;
13727 tree tmpl
= NULL_TREE
;
13729 tree type
= NULL_TREE
;
13732 if (TREE_TYPE (t
) == error_mark_node
)
13733 RETURN (error_mark_node
);
13735 if (TREE_CODE (t
) == TYPE_DECL
13736 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
13738 /* If this is the canonical decl, we don't have to
13739 mess with instantiations, and often we can't (for
13740 typename, template type parms and such). Note that
13741 TYPE_NAME is not correct for the above test if
13742 we've copied the type for a typedef. */
13743 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13744 if (type
== error_mark_node
)
13745 RETURN (error_mark_node
);
13746 r
= TYPE_NAME (type
);
13750 /* Check to see if we already have the specialization we
13753 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
13755 /* T is a static data member or namespace-scope entity.
13756 We have to substitute into namespace-scope variables
13757 (not just variable templates) because of cases like:
13759 template <class T> void f() { extern T t; }
13761 where the entity referenced is not known until
13762 instantiation time. */
13764 ctx
= DECL_CONTEXT (t
);
13765 if (DECL_CLASS_SCOPE_P (t
))
13767 ctx
= tsubst_aggr_type (ctx
, args
,
13769 in_decl
, /*entering_scope=*/1);
13770 /* If CTX is unchanged, then T is in fact the
13771 specialization we want. That situation occurs when
13772 referencing a static data member within in its own
13773 class. We can use pointer equality, rather than
13774 same_type_p, because DECL_CONTEXT is always
13776 if (ctx
== DECL_CONTEXT (t
)
13777 /* ... unless T is a member template; in which
13778 case our caller can be willing to create a
13779 specialization of that template represented
13781 && !(DECL_TI_TEMPLATE (t
)
13782 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
13788 tmpl
= DECL_TI_TEMPLATE (t
);
13789 gen_tmpl
= most_general_template (tmpl
);
13790 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
13791 if (argvec
!= error_mark_node
)
13792 argvec
= (coerce_innermost_template_parms
13793 (DECL_TEMPLATE_PARMS (gen_tmpl
),
13794 argvec
, t
, complain
,
13795 /*all*/true, /*defarg*/true));
13796 if (argvec
== error_mark_node
)
13797 RETURN (error_mark_node
);
13798 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
13799 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
13804 /* A local variable. */
13806 /* Subsequent calls to pushdecl will fill this in. */
13808 /* Unless this is a reference to a static variable from an
13809 enclosing function, in which case we need to fill it in now. */
13810 if (TREE_STATIC (t
))
13812 tree fn
= enclosing_instantiation_of (DECL_CONTEXT (t
));
13813 if (fn
!= current_function_decl
)
13816 spec
= retrieve_local_specialization (t
);
13818 /* If we already have the specialization we need, there is
13819 nothing more to do. */
13826 /* Create a new node for the specialization we need. */
13827 if (type
== NULL_TREE
)
13829 if (is_typedef_decl (t
))
13830 type
= DECL_ORIGINAL_TYPE (t
);
13832 type
= TREE_TYPE (t
);
13834 && VAR_HAD_UNKNOWN_BOUND (t
)
13835 && type
!= error_mark_node
)
13836 type
= strip_array_domain (type
);
13837 tree sub_args
= args
;
13838 if (tree auto_node
= type_uses_auto (type
))
13840 /* Mask off any template args past the variable's context so we
13841 don't replace the auto with an unrelated argument. */
13842 int nouter
= TEMPLATE_TYPE_LEVEL (auto_node
) - 1;
13843 int extra
= TMPL_ARGS_DEPTH (args
) - nouter
;
13845 /* This should never happen with the new lambda instantiation
13846 model, but keep the handling just in case. */
13847 gcc_assert (!CHECKING_P
),
13848 sub_args
= strip_innermost_template_args (args
, extra
);
13850 type
= tsubst (type
, sub_args
, complain
, in_decl
);
13851 /* Substituting the type might have recursively instantiated this
13852 same alias (c++/86171). */
13853 if (gen_tmpl
&& DECL_ALIAS_TEMPLATE_P (gen_tmpl
)
13854 && (spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
)))
13863 DECL_INITIALIZED_P (r
) = 0;
13864 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
13865 if (type
== error_mark_node
)
13866 RETURN (error_mark_node
);
13867 if (TREE_CODE (type
) == FUNCTION_TYPE
)
13869 /* It may seem that this case cannot occur, since:
13874 declares a function, not a variable. However:
13877 template <typename T> void g() { T t; }
13878 template void g<f>();
13880 is an attempt to declare a variable with function
13882 error ("variable %qD has function type",
13883 /* R is not yet sufficiently initialized, so we
13884 just use its name. */
13886 RETURN (error_mark_node
);
13888 type
= complete_type (type
);
13889 /* Wait until cp_finish_decl to set this again, to handle
13890 circular dependency (template/instantiate6.C). */
13891 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
13892 type
= check_var_type (DECL_NAME (r
), type
);
13894 if (DECL_HAS_VALUE_EXPR_P (t
))
13896 tree ve
= DECL_VALUE_EXPR (t
);
13897 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
13898 /*constant_expression_p=*/false);
13899 if (REFERENCE_REF_P (ve
))
13901 gcc_assert (TYPE_REF_P (type
));
13902 ve
= TREE_OPERAND (ve
, 0);
13904 SET_DECL_VALUE_EXPR (r
, ve
);
13906 if (CP_DECL_THREAD_LOCAL_P (r
)
13907 && !processing_template_decl
)
13908 set_decl_tls_model (r
, decl_default_tls_model (r
));
13910 else if (DECL_SELF_REFERENCE_P (t
))
13911 SET_DECL_SELF_REFERENCE_P (r
);
13912 TREE_TYPE (r
) = type
;
13913 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13914 DECL_CONTEXT (r
) = ctx
;
13915 /* Clear out the mangled name and RTL for the instantiation. */
13916 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
13917 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
13918 SET_DECL_RTL (r
, NULL
);
13919 /* The initializer must not be expanded until it is required;
13920 see [temp.inst]. */
13921 DECL_INITIAL (r
) = NULL_TREE
;
13922 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
13925 if (DECL_LANG_SPECIFIC (r
))
13926 SET_DECL_DEPENDENT_INIT_P (r
, false);
13928 SET_DECL_MODE (r
, VOIDmode
);
13930 /* Possibly limit visibility based on template args. */
13931 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
13932 if (DECL_VISIBILITY_SPECIFIED (t
))
13934 DECL_VISIBILITY_SPECIFIED (r
) = 0;
13935 DECL_ATTRIBUTES (r
)
13936 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
13938 determine_visibility (r
);
13943 /* A static data member declaration is always marked
13944 external when it is declared in-class, even if an
13945 initializer is present. We mimic the non-template
13946 processing here. */
13947 DECL_EXTERNAL (r
) = 1;
13948 if (DECL_NAMESPACE_SCOPE_P (t
))
13949 DECL_NOT_REALLY_EXTERN (r
) = 1;
13951 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
13952 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13953 if (!error_operand_p (r
) || (complain
& tf_error
))
13954 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
13958 if (DECL_LANG_SPECIFIC (r
))
13959 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13960 if (!cp_unevaluated_operand
)
13961 register_local_specialization (r
, t
);
13964 DECL_CHAIN (r
) = NULL_TREE
;
13966 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
13968 args
, complain
, in_decl
);
13970 /* Preserve a typedef that names a type. */
13971 if (is_typedef_decl (r
) && type
!= error_mark_node
)
13973 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
13974 set_underlying_type (r
);
13975 if (TYPE_DECL_ALIAS_P (r
))
13976 /* An alias template specialization can be dependent
13977 even if its underlying type is not. */
13978 TYPE_DEPENDENT_P_VALID (TREE_TYPE (r
)) = false;
13981 layout_decl (r
, 0);
13986 gcc_unreachable ();
13991 /* Restore the file and line information. */
13992 input_location
= saved_loc
;
13997 /* Substitute into the ARG_TYPES of a function type.
13998 If END is a TREE_CHAIN, leave it and any following types
14002 tsubst_arg_types (tree arg_types
,
14005 tsubst_flags_t complain
,
14008 tree remaining_arg_types
;
14009 tree type
= NULL_TREE
;
14011 tree expanded_args
= NULL_TREE
;
14014 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
14017 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
14018 args
, end
, complain
, in_decl
);
14019 if (remaining_arg_types
== error_mark_node
)
14020 return error_mark_node
;
14022 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
14024 /* For a pack expansion, perform substitution on the
14025 entire expression. Later on, we'll handle the arguments
14027 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
14028 args
, complain
, in_decl
);
14030 if (TREE_CODE (expanded_args
) == TREE_VEC
)
14031 /* So that we'll spin through the parameters, one by one. */
14032 i
= TREE_VEC_LENGTH (expanded_args
);
14035 /* We only partially substituted into the parameter
14036 pack. Our type is TYPE_PACK_EXPANSION. */
14037 type
= expanded_args
;
14038 expanded_args
= NULL_TREE
;
14046 type
= TREE_VEC_ELT (expanded_args
, i
);
14048 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
14050 if (type
== error_mark_node
)
14051 return error_mark_node
;
14052 if (VOID_TYPE_P (type
))
14054 if (complain
& tf_error
)
14056 error ("invalid parameter type %qT", type
);
14058 error ("in declaration %q+D", in_decl
);
14060 return error_mark_node
;
14063 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
14064 return error_mark_node
;
14066 /* Do array-to-pointer, function-to-pointer conversion, and ignore
14067 top-level qualifiers as required. */
14068 type
= cv_unqualified (type_decays_to (type
));
14070 /* We do not substitute into default arguments here. The standard
14071 mandates that they be instantiated only when needed, which is
14072 done in build_over_call. */
14073 default_arg
= TREE_PURPOSE (arg_types
);
14075 /* Except that we do substitute default arguments under tsubst_lambda_expr,
14076 since the new op() won't have any associated template arguments for us
14077 to refer to later. */
14078 if (lambda_fn_in_template_p (in_decl
))
14079 default_arg
= tsubst_copy_and_build (default_arg
, args
, complain
, in_decl
,
14080 false/*fn*/, false/*constexpr*/);
14082 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
14084 /* We've instantiated a template before its default arguments
14085 have been parsed. This can happen for a nested template
14086 class, and is not an error unless we require the default
14087 argument in a call of this function. */
14088 remaining_arg_types
=
14089 tree_cons (default_arg
, type
, remaining_arg_types
);
14090 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
14093 remaining_arg_types
=
14094 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
14097 return remaining_arg_types
;
14100 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
14101 *not* handle the exception-specification for FNTYPE, because the
14102 initial substitution of explicitly provided template parameters
14103 during argument deduction forbids substitution into the
14104 exception-specification:
14108 All references in the function type of the function template to the
14109 corresponding template parameters are replaced by the specified tem-
14110 plate argument values. If a substitution in a template parameter or
14111 in the function type of the function template results in an invalid
14112 type, type deduction fails. [Note: The equivalent substitution in
14113 exception specifications is done only when the function is instanti-
14114 ated, at which point a program is ill-formed if the substitution
14115 results in an invalid type.] */
14118 tsubst_function_type (tree t
,
14120 tsubst_flags_t complain
,
14124 tree arg_types
= NULL_TREE
;
14127 /* The TYPE_CONTEXT is not used for function/method types. */
14128 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
14130 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
14132 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
14134 if (late_return_type_p
)
14136 /* Substitute the argument types. */
14137 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
14138 complain
, in_decl
);
14139 if (arg_types
== error_mark_node
)
14140 return error_mark_node
;
14142 tree save_ccp
= current_class_ptr
;
14143 tree save_ccr
= current_class_ref
;
14144 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
14145 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
14146 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
14149 /* DR 1207: 'this' is in scope in the trailing return type. */
14150 inject_this_parameter (this_type
, cp_type_quals (this_type
));
14153 /* Substitute the return type. */
14154 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14158 current_class_ptr
= save_ccp
;
14159 current_class_ref
= save_ccr
;
14163 /* Substitute the return type. */
14164 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14166 if (return_type
== error_mark_node
)
14167 return error_mark_node
;
14168 /* DR 486 clarifies that creation of a function type with an
14169 invalid return type is a deduction failure. */
14170 if (TREE_CODE (return_type
) == ARRAY_TYPE
14171 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
14173 if (complain
& tf_error
)
14175 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
14176 error ("function returning an array");
14178 error ("function returning a function");
14180 return error_mark_node
;
14183 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
14184 return error_mark_node
;
14186 if (!late_return_type_p
)
14188 /* Substitute the argument types. */
14189 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
14190 complain
, in_decl
);
14191 if (arg_types
== error_mark_node
)
14192 return error_mark_node
;
14195 /* Construct a new type node and return it. */
14196 if (TREE_CODE (t
) == FUNCTION_TYPE
)
14198 fntype
= build_function_type (return_type
, arg_types
);
14199 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (t
));
14203 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
14204 /* Don't pick up extra function qualifiers from the basetype. */
14205 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
14206 if (! MAYBE_CLASS_TYPE_P (r
))
14210 Type deduction may fail for any of the following
14213 -- Attempting to create "pointer to member of T" when T
14214 is not a class type. */
14215 if (complain
& tf_error
)
14216 error ("creating pointer to member function of non-class type %qT",
14218 return error_mark_node
;
14221 fntype
= build_method_type_directly (r
, return_type
,
14222 TREE_CHAIN (arg_types
));
14224 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
14226 /* See comment above. */
14227 tree raises
= NULL_TREE
;
14228 cp_ref_qualifier rqual
= type_memfn_rqual (t
);
14229 fntype
= build_cp_fntype_variant (fntype
, rqual
, raises
, late_return_type_p
);
14234 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
14235 ARGS into that specification, and return the substituted
14236 specification. If there is no specification, return NULL_TREE. */
14239 tsubst_exception_specification (tree fntype
,
14241 tsubst_flags_t complain
,
14248 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
14249 new_specs
= NULL_TREE
;
14250 if (specs
&& TREE_PURPOSE (specs
))
14252 /* A noexcept-specifier. */
14253 tree expr
= TREE_PURPOSE (specs
);
14254 if (TREE_CODE (expr
) == INTEGER_CST
)
14258 /* Defer instantiation of noexcept-specifiers to avoid
14259 excessive instantiations (c++/49107). */
14260 new_specs
= make_node (DEFERRED_NOEXCEPT
);
14261 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
14263 /* We already partially instantiated this member template,
14264 so combine the new args with the old. */
14265 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
14266 = DEFERRED_NOEXCEPT_PATTERN (expr
);
14267 DEFERRED_NOEXCEPT_ARGS (new_specs
)
14268 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
14272 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
14273 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
14278 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
14280 args
= add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
),
14282 expr
= DEFERRED_NOEXCEPT_PATTERN (expr
);
14284 new_specs
= tsubst_copy_and_build
14285 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
14286 /*integral_constant_expression_p=*/true);
14288 new_specs
= build_noexcept_spec (new_specs
, complain
);
14292 if (! TREE_VALUE (specs
))
14299 tree expanded_specs
= NULL_TREE
;
14301 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
14303 /* Expand the pack expansion type. */
14304 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
14308 if (expanded_specs
== error_mark_node
)
14309 return error_mark_node
;
14310 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
14311 len
= TREE_VEC_LENGTH (expanded_specs
);
14314 /* We're substituting into a member template, so
14315 we got a TYPE_PACK_EXPANSION back. Add that
14316 expansion and move on. */
14317 gcc_assert (TREE_CODE (expanded_specs
)
14318 == TYPE_PACK_EXPANSION
);
14319 new_specs
= add_exception_specifier (new_specs
,
14322 specs
= TREE_CHAIN (specs
);
14327 for (i
= 0; i
< len
; ++i
)
14329 if (expanded_specs
)
14330 spec
= TREE_VEC_ELT (expanded_specs
, i
);
14332 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
14333 if (spec
== error_mark_node
)
14335 new_specs
= add_exception_specifier (new_specs
, spec
,
14339 specs
= TREE_CHAIN (specs
);
14345 /* Take the tree structure T and replace template parameters used
14346 therein with the argument vector ARGS. IN_DECL is an associated
14347 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
14348 Issue error and warning messages under control of COMPLAIN. Note
14349 that we must be relatively non-tolerant of extensions here, in
14350 order to preserve conformance; if we allow substitutions that
14351 should not be allowed, we may allow argument deductions that should
14352 not succeed, and therefore report ambiguous overload situations
14353 where there are none. In theory, we could allow the substitution,
14354 but indicate that it should have failed, and allow our caller to
14355 make sure that the right thing happens, but we don't try to do this
14358 This function is used for dealing with types, decls and the like;
14359 for expressions, use tsubst_expr or tsubst_copy. */
14362 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14364 enum tree_code code
;
14365 tree type
, r
= NULL_TREE
;
14367 if (t
== NULL_TREE
|| t
== error_mark_node
14368 || t
== integer_type_node
14369 || t
== void_type_node
14370 || t
== char_type_node
14371 || t
== unknown_type_node
14372 || TREE_CODE (t
) == NAMESPACE_DECL
14373 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
14377 return tsubst_decl (t
, args
, complain
);
14379 if (args
== NULL_TREE
)
14382 code
= TREE_CODE (t
);
14384 if (code
== IDENTIFIER_NODE
)
14385 type
= IDENTIFIER_TYPE_VALUE (t
);
14387 type
= TREE_TYPE (t
);
14389 gcc_assert (type
!= unknown_type_node
);
14391 /* Reuse typedefs. We need to do this to handle dependent attributes,
14392 such as attribute aligned. */
14394 && typedef_variant_p (t
))
14396 tree decl
= TYPE_NAME (t
);
14398 if (alias_template_specialization_p (t
))
14400 /* DECL represents an alias template and we want to
14402 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
14403 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
14404 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
14406 else if (DECL_CLASS_SCOPE_P (decl
)
14407 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
14408 && uses_template_parms (DECL_CONTEXT (decl
)))
14410 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
14411 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
14412 r
= retrieve_specialization (tmpl
, gen_args
, 0);
14414 else if (DECL_FUNCTION_SCOPE_P (decl
)
14415 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
14416 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
14417 r
= retrieve_local_specialization (decl
);
14419 /* The typedef is from a non-template context. */
14425 r
= cp_build_qualified_type_real
14426 (r
, cp_type_quals (t
) | cp_type_quals (r
),
14427 complain
| tf_ignore_bad_quals
);
14432 /* We don't have an instantiation yet, so drop the typedef. */
14433 int quals
= cp_type_quals (t
);
14434 t
= DECL_ORIGINAL_TYPE (decl
);
14435 t
= cp_build_qualified_type_real (t
, quals
,
14436 complain
| tf_ignore_bad_quals
);
14440 bool fndecl_type
= (complain
& tf_fndecl_type
);
14441 complain
&= ~tf_fndecl_type
;
14444 && code
!= TYPENAME_TYPE
14445 && code
!= TEMPLATE_TYPE_PARM
14446 && code
!= TEMPLATE_PARM_INDEX
14447 && code
!= IDENTIFIER_NODE
14448 && code
!= FUNCTION_TYPE
14449 && code
!= METHOD_TYPE
)
14450 type
= tsubst (type
, args
, complain
, in_decl
);
14451 if (type
== error_mark_node
)
14452 return error_mark_node
;
14458 case ENUMERAL_TYPE
:
14459 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
14460 /*entering_scope=*/0);
14463 case IDENTIFIER_NODE
:
14474 if (t
== integer_type_node
)
14477 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
14478 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
14482 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
14484 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
14485 /*integral_constant_expression_p=*/false);
14487 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
14489 if (TREE_CODE (max
) == NOP_EXPR
14490 && TREE_SIDE_EFFECTS (omax
)
14491 && !TREE_TYPE (max
))
14492 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
14494 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
14495 with TREE_SIDE_EFFECTS that indicates this is not an integral
14496 constant expression. */
14497 if (processing_template_decl
14498 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
14500 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
14501 TREE_SIDE_EFFECTS (max
) = 1;
14504 return compute_array_index_type (NULL_TREE
, max
, complain
);
14507 case TEMPLATE_TYPE_PARM
:
14508 case TEMPLATE_TEMPLATE_PARM
:
14509 case BOUND_TEMPLATE_TEMPLATE_PARM
:
14510 case TEMPLATE_PARM_INDEX
:
14515 tree arg
= NULL_TREE
;
14517 /* Early in template argument deduction substitution, we don't
14518 want to reduce the level of 'auto', or it will be confused
14519 with a normal template parm in subsequent deduction. */
14520 if (is_auto (t
) && (complain
& tf_partial
))
14525 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
14526 template_parm_level_and_index (t
, &level
, &idx
);
14528 levels
= TMPL_ARGS_DEPTH (args
);
14529 if (level
<= levels
14530 && TREE_VEC_LENGTH (TMPL_ARGS_LEVEL (args
, level
)) > 0)
14532 arg
= TMPL_ARG (args
, level
, idx
);
14534 /* See through ARGUMENT_PACK_SELECT arguments. */
14535 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
14536 arg
= argument_pack_select_arg (arg
);
14539 if (arg
== error_mark_node
)
14540 return error_mark_node
;
14541 else if (arg
!= NULL_TREE
)
14543 if (ARGUMENT_PACK_P (arg
))
14544 /* If ARG is an argument pack, we don't actually want to
14545 perform a substitution here, because substitutions
14546 for argument packs are only done
14547 element-by-element. We can get to this point when
14548 substituting the type of a non-type template
14549 parameter pack, when that type actually contains
14550 template parameter packs from an outer template, e.g.,
14552 template<typename... Types> struct A {
14553 template<Types... Values> struct B { };
14557 if (code
== TEMPLATE_TYPE_PARM
)
14560 gcc_assert (TYPE_P (arg
));
14562 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
14564 return cp_build_qualified_type_real
14565 (arg
, quals
, complain
| tf_ignore_bad_quals
);
14567 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
14569 /* We are processing a type constructed from a
14570 template template parameter. */
14571 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
14572 args
, complain
, in_decl
);
14573 if (argvec
== error_mark_node
)
14574 return error_mark_node
;
14576 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
14577 || TREE_CODE (arg
) == TEMPLATE_DECL
14578 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
14580 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
14581 /* Consider this code:
14583 template <template <class> class Template>
14585 template <class Arg> using Bind = Template<Arg>;
14588 template <template <class> class Template, class Arg>
14589 using Instantiate = Template<Arg>; //#0
14591 template <template <class> class Template,
14594 Instantiate<Internal<Template>::template Bind,
14597 When #1 is parsed, the
14598 BOUND_TEMPLATE_TEMPLATE_PARM representing the
14599 parameter `Template' in #0 matches the
14600 UNBOUND_CLASS_TEMPLATE representing the argument
14601 `Internal<Template>::template Bind'; We then want
14602 to assemble the type `Bind<Argument>' that can't
14603 be fully created right now, because
14604 `Internal<Template>' not being complete, the Bind
14605 template cannot be looked up in that context. So
14606 we need to "store" `Bind<Argument>' for later
14607 when the context of Bind becomes complete. Let's
14608 store that in a TYPENAME_TYPE. */
14609 return make_typename_type (TYPE_CONTEXT (arg
),
14610 build_nt (TEMPLATE_ID_EXPR
,
14611 TYPE_IDENTIFIER (arg
),
14616 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
14617 are resolving nested-types in the signature of a
14618 member function templates. Otherwise ARG is a
14619 TEMPLATE_DECL and is the real template to be
14621 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
14622 arg
= TYPE_NAME (arg
);
14624 r
= lookup_template_class (arg
,
14626 DECL_CONTEXT (arg
),
14627 /*entering_scope=*/0,
14629 return cp_build_qualified_type_real
14630 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
14632 else if (code
== TEMPLATE_TEMPLATE_PARM
)
14635 /* TEMPLATE_PARM_INDEX. */
14636 return convert_from_reference (unshare_expr (arg
));
14640 /* This can happen during the attempted tsubst'ing in
14641 unify. This means that we don't yet have any information
14642 about the template parameter in question. */
14645 /* If we get here, we must have been looking at a parm for a
14646 more deeply nested template. Make a new version of this
14647 template parameter, but with a lower level. */
14650 case TEMPLATE_TYPE_PARM
:
14651 case TEMPLATE_TEMPLATE_PARM
:
14652 case BOUND_TEMPLATE_TEMPLATE_PARM
:
14653 if (cp_type_quals (t
))
14655 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
14656 r
= cp_build_qualified_type_real
14657 (r
, cp_type_quals (t
),
14658 complain
| (code
== TEMPLATE_TYPE_PARM
14659 ? tf_ignore_bad_quals
: 0));
14661 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
14662 && PLACEHOLDER_TYPE_CONSTRAINTS (t
)
14663 && (r
= (TEMPLATE_PARM_DESCENDANTS
14664 (TEMPLATE_TYPE_PARM_INDEX (t
))))
14665 && (r
= TREE_TYPE (r
))
14666 && !PLACEHOLDER_TYPE_CONSTRAINTS (r
))
14667 /* Break infinite recursion when substituting the constraints
14668 of a constrained placeholder. */;
14669 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
14670 && !PLACEHOLDER_TYPE_CONSTRAINTS (t
)
14671 && !CLASS_PLACEHOLDER_TEMPLATE (t
)
14672 && (arg
= TEMPLATE_TYPE_PARM_INDEX (t
),
14673 r
= TEMPLATE_PARM_DESCENDANTS (arg
))
14674 && (TEMPLATE_PARM_LEVEL (r
)
14675 == TEMPLATE_PARM_LEVEL (arg
) - levels
))
14676 /* Cache the simple case of lowering a type parameter. */
14681 TEMPLATE_TYPE_PARM_INDEX (r
)
14682 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
14683 r
, levels
, args
, complain
);
14684 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
14685 TYPE_MAIN_VARIANT (r
) = r
;
14686 TYPE_POINTER_TO (r
) = NULL_TREE
;
14687 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
14689 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
14691 /* Propagate constraints on placeholders. */
14692 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
14693 PLACEHOLDER_TYPE_CONSTRAINTS (r
)
14694 = tsubst_constraint (constr
, args
, complain
, in_decl
);
14695 else if (tree pl
= CLASS_PLACEHOLDER_TEMPLATE (t
))
14697 pl
= tsubst_copy (pl
, args
, complain
, in_decl
);
14698 CLASS_PLACEHOLDER_TEMPLATE (r
) = pl
;
14702 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
14703 /* We have reduced the level of the template
14704 template parameter, but not the levels of its
14705 template parameters, so canonical_type_parameter
14706 will not be able to find the canonical template
14707 template parameter for this level. Thus, we
14708 require structural equality checking to compare
14709 TEMPLATE_TEMPLATE_PARMs. */
14710 SET_TYPE_STRUCTURAL_EQUALITY (r
);
14711 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
14712 SET_TYPE_STRUCTURAL_EQUALITY (r
);
14714 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
14716 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
14718 tree tinfo
= TYPE_TEMPLATE_INFO (t
);
14719 /* We might need to substitute into the types of non-type
14720 template parameters. */
14721 tree tmpl
= tsubst (TI_TEMPLATE (tinfo
), args
,
14722 complain
, in_decl
);
14723 if (tmpl
== error_mark_node
)
14724 return error_mark_node
;
14725 tree argvec
= tsubst (TI_ARGS (tinfo
), args
,
14726 complain
, in_decl
);
14727 if (argvec
== error_mark_node
)
14728 return error_mark_node
;
14730 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
14731 = build_template_info (tmpl
, argvec
);
14736 case TEMPLATE_PARM_INDEX
:
14737 /* OK, now substitute the type of the non-type parameter. We
14738 couldn't do it earlier because it might be an auto parameter,
14739 and we wouldn't need to if we had an argument. */
14740 type
= tsubst (type
, args
, complain
, in_decl
);
14741 if (type
== error_mark_node
)
14742 return error_mark_node
;
14743 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
14747 gcc_unreachable ();
14755 tree purpose
, value
, chain
;
14757 if (t
== void_list_node
)
14760 purpose
= TREE_PURPOSE (t
);
14763 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
14764 if (purpose
== error_mark_node
)
14765 return error_mark_node
;
14767 value
= TREE_VALUE (t
);
14770 value
= tsubst (value
, args
, complain
, in_decl
);
14771 if (value
== error_mark_node
)
14772 return error_mark_node
;
14774 chain
= TREE_CHAIN (t
);
14775 if (chain
&& chain
!= void_type_node
)
14777 chain
= tsubst (chain
, args
, complain
, in_decl
);
14778 if (chain
== error_mark_node
)
14779 return error_mark_node
;
14781 if (purpose
== TREE_PURPOSE (t
)
14782 && value
== TREE_VALUE (t
)
14783 && chain
== TREE_CHAIN (t
))
14785 return hash_tree_cons (purpose
, value
, chain
);
14789 /* We should never be tsubsting a binfo. */
14790 gcc_unreachable ();
14793 /* A vector of template arguments. */
14794 gcc_assert (!type
);
14795 return tsubst_template_args (t
, args
, complain
, in_decl
);
14798 case REFERENCE_TYPE
:
14800 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
14805 Type deduction may fail for any of the following
14808 -- Attempting to create a pointer to reference type.
14809 -- Attempting to create a reference to a reference type or
14810 a reference to void.
14812 Core issue 106 says that creating a reference to a reference
14813 during instantiation is no longer a cause for failure. We
14814 only enforce this check in strict C++98 mode. */
14815 if ((TYPE_REF_P (type
)
14816 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
14817 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
14819 static location_t last_loc
;
14821 /* We keep track of the last time we issued this error
14822 message to avoid spewing a ton of messages during a
14823 single bad template instantiation. */
14824 if (complain
& tf_error
14825 && last_loc
!= input_location
)
14827 if (VOID_TYPE_P (type
))
14828 error ("forming reference to void");
14829 else if (code
== POINTER_TYPE
)
14830 error ("forming pointer to reference type %qT", type
);
14832 error ("forming reference to reference type %qT", type
);
14833 last_loc
= input_location
;
14836 return error_mark_node
;
14838 else if (TREE_CODE (type
) == FUNCTION_TYPE
14839 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
14840 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
14842 if (complain
& tf_error
)
14844 if (code
== POINTER_TYPE
)
14845 error ("forming pointer to qualified function type %qT",
14848 error ("forming reference to qualified function type %qT",
14851 return error_mark_node
;
14853 else if (code
== POINTER_TYPE
)
14855 r
= build_pointer_type (type
);
14856 if (TREE_CODE (type
) == METHOD_TYPE
)
14857 r
= build_ptrmemfunc_type (r
);
14859 else if (TYPE_REF_P (type
))
14860 /* In C++0x, during template argument substitution, when there is an
14861 attempt to create a reference to a reference type, reference
14862 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
14864 "If a template-argument for a template-parameter T names a type
14865 that is a reference to a type A, an attempt to create the type
14866 'lvalue reference to cv T' creates the type 'lvalue reference to
14867 A,' while an attempt to create the type type rvalue reference to
14868 cv T' creates the type T"
14870 r
= cp_build_reference_type
14872 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
14874 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
14875 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
14877 if (r
!= error_mark_node
)
14878 /* Will this ever be needed for TYPE_..._TO values? */
14885 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
14886 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
14890 Type deduction may fail for any of the following
14893 -- Attempting to create "pointer to member of T" when T
14894 is not a class type. */
14895 if (complain
& tf_error
)
14896 error ("creating pointer to member of non-class type %qT", r
);
14897 return error_mark_node
;
14899 if (TYPE_REF_P (type
))
14901 if (complain
& tf_error
)
14902 error ("creating pointer to member reference type %qT", type
);
14903 return error_mark_node
;
14905 if (VOID_TYPE_P (type
))
14907 if (complain
& tf_error
)
14908 error ("creating pointer to member of type void");
14909 return error_mark_node
;
14911 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
14912 if (TREE_CODE (type
) == FUNCTION_TYPE
)
14914 /* The type of the implicit object parameter gets its
14915 cv-qualifiers from the FUNCTION_TYPE. */
14918 = build_memfn_type (type
, r
, type_memfn_quals (type
),
14919 type_memfn_rqual (type
));
14920 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
14921 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
14925 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
14929 case FUNCTION_TYPE
:
14934 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
14935 if (fntype
== error_mark_node
)
14936 return error_mark_node
;
14938 /* Substitute the exception specification. */
14939 specs
= tsubst_exception_specification (t
, args
, complain
, in_decl
,
14940 /*defer_ok*/fndecl_type
);
14941 if (specs
== error_mark_node
)
14942 return error_mark_node
;
14944 fntype
= build_exception_variant (fntype
, specs
);
14949 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
14950 if (domain
== error_mark_node
)
14951 return error_mark_node
;
14953 /* As an optimization, we avoid regenerating the array type if
14954 it will obviously be the same as T. */
14955 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
14958 /* These checks should match the ones in create_array_type_for_decl.
14962 The deduction may fail for any of the following reasons:
14964 -- Attempting to create an array with an element type that
14965 is void, a function type, or a reference type, or [DR337]
14966 an abstract class type. */
14967 if (VOID_TYPE_P (type
)
14968 || TREE_CODE (type
) == FUNCTION_TYPE
14969 || (TREE_CODE (type
) == ARRAY_TYPE
14970 && TYPE_DOMAIN (type
) == NULL_TREE
)
14971 || TYPE_REF_P (type
))
14973 if (complain
& tf_error
)
14974 error ("creating array of %qT", type
);
14975 return error_mark_node
;
14978 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
14979 return error_mark_node
;
14981 r
= build_cplus_array_type (type
, domain
);
14983 if (!valid_array_size_p (input_location
, r
, in_decl
,
14984 (complain
& tf_error
)))
14985 return error_mark_node
;
14987 if (TYPE_USER_ALIGN (t
))
14989 SET_TYPE_ALIGN (r
, TYPE_ALIGN (t
));
14990 TYPE_USER_ALIGN (r
) = 1;
14996 case TYPENAME_TYPE
:
14998 tree ctx
= TYPE_CONTEXT (t
);
14999 if (TREE_CODE (ctx
) == TYPE_PACK_EXPANSION
)
15001 ctx
= tsubst_pack_expansion (ctx
, args
, complain
, in_decl
);
15002 if (ctx
== error_mark_node
15003 || TREE_VEC_LENGTH (ctx
) > 1)
15004 return error_mark_node
;
15005 if (TREE_VEC_LENGTH (ctx
) == 0)
15007 if (complain
& tf_error
)
15008 error ("%qD is instantiated for an empty pack",
15009 TYPENAME_TYPE_FULLNAME (t
));
15010 return error_mark_node
;
15012 ctx
= TREE_VEC_ELT (ctx
, 0);
15015 ctx
= tsubst_aggr_type (ctx
, args
, complain
, in_decl
,
15016 /*entering_scope=*/1);
15017 if (ctx
== error_mark_node
)
15018 return error_mark_node
;
15020 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
15021 complain
, in_decl
);
15022 if (f
== error_mark_node
)
15023 return error_mark_node
;
15025 if (!MAYBE_CLASS_TYPE_P (ctx
))
15027 if (complain
& tf_error
)
15028 error ("%qT is not a class, struct, or union type", ctx
);
15029 return error_mark_node
;
15031 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
15033 /* Normally, make_typename_type does not require that the CTX
15034 have complete type in order to allow things like:
15036 template <class T> struct S { typename S<T>::X Y; };
15038 But, such constructs have already been resolved by this
15039 point, so here CTX really should have complete type, unless
15040 it's a partial instantiation. */
15041 ctx
= complete_type (ctx
);
15042 if (!COMPLETE_TYPE_P (ctx
))
15044 if (complain
& tf_error
)
15045 cxx_incomplete_type_error (NULL_TREE
, ctx
);
15046 return error_mark_node
;
15050 f
= make_typename_type (ctx
, f
, typename_type
,
15051 complain
| tf_keep_type_decl
);
15052 if (f
== error_mark_node
)
15054 if (TREE_CODE (f
) == TYPE_DECL
)
15056 complain
|= tf_ignore_bad_quals
;
15060 if (TREE_CODE (f
) != TYPENAME_TYPE
)
15062 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
15064 if (complain
& tf_error
)
15065 error ("%qT resolves to %qT, which is not an enumeration type",
15068 return error_mark_node
;
15070 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
15072 if (complain
& tf_error
)
15073 error ("%qT resolves to %qT, which is is not a class type",
15076 return error_mark_node
;
15080 return cp_build_qualified_type_real
15081 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
15084 case UNBOUND_CLASS_TEMPLATE
:
15086 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
15087 in_decl
, /*entering_scope=*/1);
15088 tree name
= TYPE_IDENTIFIER (t
);
15089 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
15091 if (ctx
== error_mark_node
|| name
== error_mark_node
)
15092 return error_mark_node
;
15095 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
15096 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
15103 ++cp_unevaluated_operand
;
15104 ++c_inhibit_evaluation_warnings
;
15106 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
15108 /*integral_constant_expression_p=*/false);
15110 --cp_unevaluated_operand
;
15111 --c_inhibit_evaluation_warnings
;
15113 type
= finish_typeof (type
);
15114 return cp_build_qualified_type_real (type
,
15116 | cp_type_quals (type
),
15120 case DECLTYPE_TYPE
:
15124 ++cp_unevaluated_operand
;
15125 ++c_inhibit_evaluation_warnings
;
15127 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
15128 complain
|tf_decltype
, in_decl
,
15129 /*function_p*/false,
15130 /*integral_constant_expression*/false);
15132 if (DECLTYPE_FOR_INIT_CAPTURE (t
))
15134 if (type
== NULL_TREE
)
15136 if (complain
& tf_error
)
15137 error ("empty initializer in lambda init-capture");
15138 type
= error_mark_node
;
15140 else if (TREE_CODE (type
) == TREE_LIST
)
15141 type
= build_x_compound_expr_from_list (type
, ELK_INIT
, complain
);
15144 --cp_unevaluated_operand
;
15145 --c_inhibit_evaluation_warnings
;
15147 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
15148 type
= lambda_capture_field_type (type
,
15149 DECLTYPE_FOR_INIT_CAPTURE (t
),
15150 DECLTYPE_FOR_REF_CAPTURE (t
));
15151 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
15152 type
= lambda_proxy_type (type
);
15155 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
15156 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
15158 /* In a template ~id could be either a complement expression
15159 or an unqualified-id naming a destructor; if instantiating
15160 it produces an expression, it's not an id-expression or
15163 type
= finish_decltype_type (type
, id
, complain
);
15165 return cp_build_qualified_type_real (type
,
15167 | cp_type_quals (type
),
15168 complain
| tf_ignore_bad_quals
);
15171 case UNDERLYING_TYPE
:
15173 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
15174 complain
, in_decl
);
15175 return finish_underlying_type (type
);
15178 case TYPE_ARGUMENT_PACK
:
15179 case NONTYPE_ARGUMENT_PACK
:
15183 if (code
== NONTYPE_ARGUMENT_PACK
)
15184 r
= make_node (code
);
15186 r
= cxx_make_type (code
);
15188 tree pack_args
= ARGUMENT_PACK_ARGS (t
);
15189 pack_args
= tsubst_template_args (pack_args
, args
, complain
, in_decl
);
15190 SET_ARGUMENT_PACK_ARGS (r
, pack_args
);
15208 /* We should use one of the expression tsubsts for these codes. */
15209 gcc_unreachable ();
15212 sorry ("use of %qs in template", get_tree_code_name (code
));
15213 return error_mark_node
;
15217 /* tsubst a BASELINK. OBJECT_TYPE, if non-NULL, is the type of the
15218 expression on the left-hand side of the "." or "->" operator. We
15219 only do the lookup if we had a dependent BASELINK. Otherwise we
15220 adjust it onto the instantiated heirarchy. */
15223 tsubst_baselink (tree baselink
, tree object_type
,
15224 tree args
, tsubst_flags_t complain
, tree in_decl
)
15226 bool qualified_p
= BASELINK_QUALIFIED_P (baselink
);
15227 tree qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
15228 qualifying_scope
= tsubst (qualifying_scope
, args
, complain
, in_decl
);
15230 tree optype
= BASELINK_OPTYPE (baselink
);
15231 optype
= tsubst (optype
, args
, complain
, in_decl
);
15233 tree template_args
= NULL_TREE
;
15234 bool template_id_p
= false;
15235 tree fns
= BASELINK_FUNCTIONS (baselink
);
15236 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
15238 template_id_p
= true;
15239 template_args
= TREE_OPERAND (fns
, 1);
15240 fns
= TREE_OPERAND (fns
, 0);
15242 template_args
= tsubst_template_args (template_args
, args
,
15243 complain
, in_decl
);
15246 tree binfo_type
= BINFO_TYPE (BASELINK_BINFO (baselink
));
15247 binfo_type
= tsubst (binfo_type
, args
, complain
, in_decl
);
15248 bool dependent_p
= binfo_type
!= BINFO_TYPE (BASELINK_BINFO (baselink
));
15252 tree name
= OVL_NAME (fns
);
15253 if (IDENTIFIER_CONV_OP_P (name
))
15254 name
= make_conv_op_name (optype
);
15256 if (name
== complete_dtor_identifier
)
15257 /* Treat as-if non-dependent below. */
15258 dependent_p
= false;
15260 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
15263 if ((complain
& tf_error
)
15264 && constructor_name_p (name
, qualifying_scope
))
15265 error ("cannot call constructor %<%T::%D%> directly",
15266 qualifying_scope
, name
);
15267 return error_mark_node
;
15270 if (BASELINK_P (baselink
))
15271 fns
= BASELINK_FUNCTIONS (baselink
);
15274 /* We're going to overwrite pieces below, make a duplicate. */
15275 baselink
= copy_node (baselink
);
15277 /* If lookup found a single function, mark it as used at this point.
15278 (If lookup found multiple functions the one selected later by
15279 overload resolution will be marked as used at that point.) */
15280 if (!template_id_p
&& !really_overloaded_fn (fns
))
15282 tree fn
= OVL_FIRST (fns
);
15283 bool ok
= mark_used (fn
, complain
);
15284 if (!ok
&& !(complain
& tf_error
))
15285 return error_mark_node
;
15286 if (ok
&& BASELINK_P (baselink
))
15287 /* We might have instantiated an auto function. */
15288 TREE_TYPE (baselink
) = TREE_TYPE (fn
);
15291 if (BASELINK_P (baselink
))
15293 /* Add back the template arguments, if present. */
15295 BASELINK_FUNCTIONS (baselink
)
15296 = build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fns
, template_args
);
15298 /* Update the conversion operator type. */
15299 BASELINK_OPTYPE (baselink
) = optype
;
15303 object_type
= current_class_type
;
15305 if (qualified_p
|| !dependent_p
)
15307 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
15311 /* We need to call adjust_result_of_qualified_name_lookup in case the
15312 destructor names a base class, but we unset BASELINK_QUALIFIED_P
15313 so that we still get virtual function binding. */
15314 BASELINK_QUALIFIED_P (baselink
) = false;
15320 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
15321 true if the qualified-id will be a postfix-expression in-and-of
15322 itself; false if more of the postfix-expression follows the
15323 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
15327 tsubst_qualified_id (tree qualified_id
, tree args
,
15328 tsubst_flags_t complain
, tree in_decl
,
15329 bool done
, bool address_p
)
15335 tree template_args
;
15336 location_t loc
= UNKNOWN_LOCATION
;
15338 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
15340 /* Figure out what name to look up. */
15341 name
= TREE_OPERAND (qualified_id
, 1);
15342 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
15344 is_template
= true;
15345 loc
= EXPR_LOCATION (name
);
15346 template_args
= TREE_OPERAND (name
, 1);
15348 template_args
= tsubst_template_args (template_args
, args
,
15349 complain
, in_decl
);
15350 if (template_args
== error_mark_node
)
15351 return error_mark_node
;
15352 name
= TREE_OPERAND (name
, 0);
15356 is_template
= false;
15357 template_args
= NULL_TREE
;
15360 /* Substitute into the qualifying scope. When there are no ARGS, we
15361 are just trying to simplify a non-dependent expression. In that
15362 case the qualifying scope may be dependent, and, in any case,
15363 substituting will not help. */
15364 scope
= TREE_OPERAND (qualified_id
, 0);
15367 scope
= tsubst (scope
, args
, complain
, in_decl
);
15368 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
15373 if (dependent_scope_p (scope
))
15376 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
15377 tree r
= build_qualified_name (NULL_TREE
, scope
, expr
,
15378 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
15379 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (qualified_id
);
15383 if (!BASELINK_P (name
) && !DECL_P (expr
))
15385 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
15387 /* A BIT_NOT_EXPR is used to represent a destructor. */
15388 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
15390 error ("qualifying type %qT does not match destructor name ~%qT",
15391 scope
, TREE_OPERAND (expr
, 0));
15392 expr
= error_mark_node
;
15395 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
15396 /*is_type_p=*/0, false);
15399 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
15400 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
15401 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
15403 if (complain
& tf_error
)
15405 error ("dependent-name %qE is parsed as a non-type, but "
15406 "instantiation yields a type", qualified_id
);
15407 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
15409 return error_mark_node
;
15415 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
15417 /* Remember that there was a reference to this entity. */
15418 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
15419 return error_mark_node
;
15422 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
15424 if (complain
& tf_error
)
15425 qualified_name_lookup_error (scope
,
15426 TREE_OPERAND (qualified_id
, 1),
15427 expr
, input_location
);
15428 return error_mark_node
;
15433 /* We may be repeating a check already done during parsing, but
15434 if it was well-formed and passed then, it will pass again
15435 now, and if it didn't, we wouldn't have got here. The case
15436 we want to catch is when we couldn't tell then, and can now,
15437 namely when templ prior to substitution was an
15439 if (flag_concepts
&& check_auto_in_tmpl_args (expr
, template_args
))
15440 return error_mark_node
;
15442 if (variable_template_p (expr
))
15443 expr
= lookup_and_finish_template_variable (expr
, template_args
,
15446 expr
= lookup_template_function (expr
, template_args
);
15449 if (expr
== error_mark_node
&& complain
& tf_error
)
15450 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
15451 expr
, input_location
);
15452 else if (TYPE_P (scope
))
15454 expr
= (adjust_result_of_qualified_name_lookup
15455 (expr
, scope
, current_nonlambda_class_type ()));
15456 expr
= (finish_qualified_id_expr
15457 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
15458 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
15459 /*template_arg_p=*/false, complain
));
15462 /* Expressions do not generally have reference type. */
15463 if (TREE_CODE (expr
) != SCOPE_REF
15464 /* However, if we're about to form a pointer-to-member, we just
15465 want the referenced member referenced. */
15466 && TREE_CODE (expr
) != OFFSET_REF
)
15467 expr
= convert_from_reference (expr
);
15469 if (REF_PARENTHESIZED_P (qualified_id
))
15470 expr
= force_paren_expr (expr
);
15475 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
15476 initializer, DECL is the substituted VAR_DECL. Other arguments are as
15480 tsubst_init (tree init
, tree decl
, tree args
,
15481 tsubst_flags_t complain
, tree in_decl
)
15486 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
15488 tree type
= TREE_TYPE (decl
);
15490 if (!init
&& type
!= error_mark_node
)
15492 if (tree auto_node
= type_uses_auto (type
))
15494 if (!CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
15496 if (complain
& tf_error
)
15497 error ("initializer for %q#D expands to an empty list "
15498 "of expressions", decl
);
15499 return error_mark_node
;
15502 else if (!dependent_type_p (type
))
15504 /* If we had an initializer but it
15505 instantiated to nothing,
15506 value-initialize the object. This will
15507 only occur when the initializer was a
15508 pack expansion where the parameter packs
15509 used in that expansion were of length
15511 init
= build_value_init (type
, complain
);
15512 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
15513 init
= get_target_expr_sfinae (init
, complain
);
15514 if (TREE_CODE (init
) == TARGET_EXPR
)
15515 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
15522 /* Like tsubst, but deals with expressions. This function just replaces
15523 template parms; to finish processing the resultant expression, use
15524 tsubst_copy_and_build or tsubst_expr. */
15527 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
15529 enum tree_code code
;
15532 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
15535 code
= TREE_CODE (t
);
15540 r
= retrieve_local_specialization (t
);
15542 if (r
== NULL_TREE
)
15544 /* We get here for a use of 'this' in an NSDMI. */
15545 if (DECL_NAME (t
) == this_identifier
&& current_class_ptr
)
15546 return current_class_ptr
;
15548 /* This can happen for a parameter name used later in a function
15549 declaration (such as in a late-specified return type). Just
15550 make a dummy decl, since it's only used for its type. */
15551 gcc_assert (cp_unevaluated_operand
!= 0);
15552 r
= tsubst_decl (t
, args
, complain
);
15553 /* Give it the template pattern as its context; its true context
15554 hasn't been instantiated yet and this is good enough for
15556 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
15559 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
15560 r
= argument_pack_select_arg (r
);
15561 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
15562 return error_mark_node
;
15570 if (DECL_TEMPLATE_PARM_P (t
))
15571 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
15572 /* There is no need to substitute into namespace-scope
15574 if (DECL_NAMESPACE_SCOPE_P (t
))
15576 /* If ARGS is NULL, then T is known to be non-dependent. */
15577 if (args
== NULL_TREE
)
15578 return scalar_constant_value (t
);
15580 /* Unfortunately, we cannot just call lookup_name here.
15583 template <int I> int f() {
15585 struct S { void g() { E e = a; } };
15588 When we instantiate f<7>::S::g(), say, lookup_name is not
15589 clever enough to find f<7>::a. */
15591 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
15592 /*entering_scope=*/0);
15594 for (v
= TYPE_VALUES (enum_type
);
15596 v
= TREE_CHAIN (v
))
15597 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
15598 return TREE_VALUE (v
);
15600 /* We didn't find the name. That should never happen; if
15601 name-lookup found it during preliminary parsing, we
15602 should find it again here during instantiation. */
15603 gcc_unreachable ();
15608 if (DECL_CONTEXT (t
))
15612 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
15613 /*entering_scope=*/1);
15614 if (ctx
!= DECL_CONTEXT (t
))
15616 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
15619 if (complain
& tf_error
)
15620 error ("using invalid field %qD", t
);
15621 return error_mark_node
;
15630 case FUNCTION_DECL
:
15631 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
15632 r
= tsubst (t
, args
, complain
, in_decl
);
15633 else if (local_variable_p (t
)
15634 && uses_template_parms (DECL_CONTEXT (t
)))
15636 r
= retrieve_local_specialization (t
);
15637 if (r
== NULL_TREE
)
15639 /* First try name lookup to find the instantiation. */
15640 r
= lookup_name (DECL_NAME (t
));
15645 /* During error-recovery we may find a non-variable,
15646 even an OVERLOAD: just bail out and avoid ICEs and
15647 duplicate diagnostics (c++/62207). */
15648 gcc_assert (seen_error ());
15649 return error_mark_node
;
15651 if (!is_capture_proxy (r
))
15653 /* Make sure the one we found is the one we want. */
15654 tree ctx
= enclosing_instantiation_of (DECL_CONTEXT (t
));
15655 if (ctx
!= DECL_CONTEXT (r
))
15664 /* This can happen for a variable used in a
15665 late-specified return type of a local lambda, or for a
15666 local static or constant. Building a new VAR_DECL
15667 should be OK in all those cases. */
15668 r
= tsubst_decl (t
, args
, complain
);
15669 if (local_specializations
)
15670 /* Avoid infinite recursion (79640). */
15671 register_local_specialization (r
, t
);
15672 if (decl_maybe_constant_var_p (r
))
15674 /* We can't call cp_finish_decl, so handle the
15675 initializer by hand. */
15676 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
15677 complain
, in_decl
);
15678 if (!processing_template_decl
)
15679 init
= maybe_constant_init (init
);
15680 if (processing_template_decl
15681 ? potential_constant_expression (init
)
15682 : reduced_constant_expression_p (init
))
15683 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
15684 = TREE_CONSTANT (r
) = true;
15685 DECL_INITIAL (r
) = init
;
15686 if (tree auto_node
= type_uses_auto (TREE_TYPE (r
)))
15688 = do_auto_deduction (TREE_TYPE (r
), init
, auto_node
,
15689 complain
, adc_variable_type
);
15691 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
15692 || decl_constant_var_p (r
)
15694 if (!processing_template_decl
15695 && !TREE_STATIC (r
))
15696 r
= process_outer_var_ref (r
, complain
);
15698 /* Remember this for subsequent uses. */
15699 if (local_specializations
)
15700 register_local_specialization (r
, t
);
15702 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
15703 r
= argument_pack_select_arg (r
);
15707 if (!mark_used (r
, complain
))
15708 return error_mark_node
;
15711 case NAMESPACE_DECL
:
15718 return tsubst_baselink (t
, current_nonlambda_class_type (),
15719 args
, complain
, in_decl
);
15721 case TEMPLATE_DECL
:
15722 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
15723 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
15724 args
, complain
, in_decl
);
15725 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
15726 return tsubst (t
, args
, complain
, in_decl
);
15727 else if (DECL_CLASS_SCOPE_P (t
)
15728 && uses_template_parms (DECL_CONTEXT (t
)))
15730 /* Template template argument like the following example need
15733 template <template <class> class TT> struct C {};
15734 template <class T> struct D {
15735 template <class U> struct E {};
15740 We are processing the template argument `E' in #1 for
15741 the template instantiation #2. Originally, `E' is a
15742 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
15743 have to substitute this with one having context `D<int>'. */
15745 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
15746 if (dependent_scope_p (context
))
15748 /* When rewriting a constructor into a deduction guide, a
15749 non-dependent name can become dependent, so memtmpl<args>
15750 becomes context::template memtmpl<args>. */
15751 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15752 return build_qualified_name (type
, context
, DECL_NAME (t
),
15755 return lookup_field (context
, DECL_NAME(t
), 0, false);
15758 /* Ordinary template template argument. */
15761 case NON_LVALUE_EXPR
:
15762 case VIEW_CONVERT_EXPR
:
15764 /* Handle location wrappers by substituting the wrapped node
15765 first, *then* reusing the resulting type. Doing the type
15766 first ensures that we handle template parameters and
15767 parameter pack expansions. */
15768 if (location_wrapper_p (t
))
15770 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
,
15771 complain
, in_decl
);
15772 return maybe_wrap_with_location (op0
, EXPR_LOCATION (t
));
15774 tree op
= TREE_OPERAND (t
, 0);
15775 if (code
== VIEW_CONVERT_EXPR
15776 && TREE_CODE (op
) == TEMPLATE_PARM_INDEX
)
15778 /* Wrapper to make a C++20 template parameter object const. */
15779 op
= tsubst_copy (op
, args
, complain
, in_decl
);
15780 if (TREE_CODE (op
) == TEMPLATE_PARM_INDEX
)
15782 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15783 return build1 (code
, type
, op
);
15787 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (op
)));
15791 /* We shouldn't see any other uses of these in templates. */
15792 gcc_unreachable ();
15796 case REINTERPRET_CAST_EXPR
:
15797 case CONST_CAST_EXPR
:
15798 case STATIC_CAST_EXPR
:
15799 case DYNAMIC_CAST_EXPR
:
15800 case IMPLICIT_CONV_EXPR
:
15804 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15805 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15806 return build1 (code
, type
, op0
);
15810 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
15811 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
15813 tree expanded
, op
= TREE_OPERAND (t
, 0);
15816 if (SIZEOF_EXPR_TYPE_P (t
))
15817 op
= TREE_TYPE (op
);
15819 ++cp_unevaluated_operand
;
15820 ++c_inhibit_evaluation_warnings
;
15821 /* We only want to compute the number of arguments. */
15822 if (PACK_EXPANSION_P (op
))
15823 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
15825 expanded
= tsubst_template_args (ARGUMENT_PACK_ARGS (op
),
15826 args
, complain
, in_decl
);
15827 --cp_unevaluated_operand
;
15828 --c_inhibit_evaluation_warnings
;
15830 if (TREE_CODE (expanded
) == TREE_VEC
)
15832 len
= TREE_VEC_LENGTH (expanded
);
15833 /* Set TREE_USED for the benefit of -Wunused. */
15834 for (int i
= 0; i
< len
; i
++)
15835 if (DECL_P (TREE_VEC_ELT (expanded
, i
)))
15836 TREE_USED (TREE_VEC_ELT (expanded
, i
)) = true;
15839 if (expanded
== error_mark_node
)
15840 return error_mark_node
;
15841 else if (PACK_EXPANSION_P (expanded
)
15842 || (TREE_CODE (expanded
) == TREE_VEC
15843 && pack_expansion_args_count (expanded
)))
15846 if (PACK_EXPANSION_P (expanded
))
15848 else if (TREE_VEC_LENGTH (expanded
) == 1)
15849 expanded
= TREE_VEC_ELT (expanded
, 0);
15851 expanded
= make_argument_pack (expanded
);
15853 if (TYPE_P (expanded
))
15854 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
15856 complain
& tf_error
);
15858 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
15859 complain
& tf_error
);
15862 return build_int_cst (size_type_node
, len
);
15864 if (SIZEOF_EXPR_TYPE_P (t
))
15866 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
15867 args
, complain
, in_decl
);
15868 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
15869 r
= build1 (SIZEOF_EXPR
,
15870 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
15871 SIZEOF_EXPR_TYPE_P (r
) = 1;
15878 case TRUTH_NOT_EXPR
:
15881 case UNARY_PLUS_EXPR
: /* Unary + */
15883 case AT_ENCODE_EXPR
:
15887 case REALPART_EXPR
:
15888 case IMAGPART_EXPR
:
15891 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15892 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15893 r
= build1 (code
, type
, op0
);
15894 if (code
== ALIGNOF_EXPR
)
15895 ALIGNOF_EXPR_STD_P (r
) = ALIGNOF_EXPR_STD_P (t
);
15899 case COMPONENT_REF
:
15904 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15905 name
= TREE_OPERAND (t
, 1);
15906 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
15908 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15909 complain
, in_decl
);
15910 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
15912 else if (TREE_CODE (name
) == SCOPE_REF
15913 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
15915 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15916 complain
, in_decl
);
15917 name
= TREE_OPERAND (name
, 1);
15918 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15919 complain
, in_decl
);
15920 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
15921 name
= build_qualified_name (/*type=*/NULL_TREE
,
15923 /*template_p=*/false);
15925 else if (BASELINK_P (name
))
15926 name
= tsubst_baselink (name
,
15927 non_reference (TREE_TYPE (object
)),
15931 name
= tsubst_copy (name
, args
, complain
, in_decl
);
15932 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
15938 case TRUNC_DIV_EXPR
:
15939 case CEIL_DIV_EXPR
:
15940 case FLOOR_DIV_EXPR
:
15941 case ROUND_DIV_EXPR
:
15942 case EXACT_DIV_EXPR
:
15946 case TRUNC_MOD_EXPR
:
15947 case FLOOR_MOD_EXPR
:
15948 case TRUTH_ANDIF_EXPR
:
15949 case TRUTH_ORIF_EXPR
:
15950 case TRUTH_AND_EXPR
:
15951 case TRUTH_OR_EXPR
:
15964 case COMPOUND_EXPR
:
15967 case PREDECREMENT_EXPR
:
15968 case PREINCREMENT_EXPR
:
15969 case POSTDECREMENT_EXPR
:
15970 case POSTINCREMENT_EXPR
:
15972 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15973 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15974 return build_nt (code
, op0
, op1
);
15979 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15980 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15981 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
15982 QUALIFIED_NAME_IS_TEMPLATE (t
));
15987 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15988 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15989 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
15994 int n
= VL_EXP_OPERAND_LENGTH (t
);
15995 tree result
= build_vl_exp (CALL_EXPR
, n
);
15997 for (i
= 0; i
< n
; i
++)
15998 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
15999 complain
, in_decl
);
16005 case PSEUDO_DTOR_EXPR
:
16006 case VEC_PERM_EXPR
:
16008 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16009 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16010 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
16011 r
= build_nt (code
, op0
, op1
, op2
);
16012 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
16018 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16019 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16020 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
16021 r
= build_nt (code
, op0
, op1
, op2
);
16022 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
16028 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16029 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16030 r
= build_nt (code
, op0
, op1
);
16031 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
16032 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
16036 case TEMPLATE_ID_EXPR
:
16038 /* Substituted template arguments */
16039 tree fn
= TREE_OPERAND (t
, 0);
16040 tree targs
= TREE_OPERAND (t
, 1);
16042 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
16044 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
16046 return lookup_template_function (fn
, targs
);
16051 tree purpose
, value
, chain
;
16053 if (t
== void_list_node
)
16056 purpose
= TREE_PURPOSE (t
);
16058 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
16059 value
= TREE_VALUE (t
);
16061 value
= tsubst_copy (value
, args
, complain
, in_decl
);
16062 chain
= TREE_CHAIN (t
);
16063 if (chain
&& chain
!= void_type_node
)
16064 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
16065 if (purpose
== TREE_PURPOSE (t
)
16066 && value
== TREE_VALUE (t
)
16067 && chain
== TREE_CHAIN (t
))
16069 return tree_cons (purpose
, value
, chain
);
16074 case ENUMERAL_TYPE
:
16076 case TEMPLATE_TYPE_PARM
:
16077 case TEMPLATE_TEMPLATE_PARM
:
16078 case BOUND_TEMPLATE_TEMPLATE_PARM
:
16079 case TEMPLATE_PARM_INDEX
:
16081 case REFERENCE_TYPE
:
16083 case FUNCTION_TYPE
:
16086 case TYPENAME_TYPE
:
16087 case UNBOUND_CLASS_TEMPLATE
:
16089 case DECLTYPE_TYPE
:
16091 return tsubst (t
, args
, complain
, in_decl
);
16095 /* Fall through. */
16096 case IDENTIFIER_NODE
:
16097 if (IDENTIFIER_CONV_OP_P (t
))
16099 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16100 return make_conv_op_name (new_type
);
16106 /* This is handled by tsubst_copy_and_build. */
16107 gcc_unreachable ();
16111 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16112 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16113 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
16116 case CLEANUP_POINT_EXPR
:
16117 /* We shouldn't have built any of these during initial template
16118 generation. Instead, they should be built during instantiation
16119 in response to the saved STMT_IS_FULL_EXPR_P setting. */
16120 gcc_unreachable ();
16124 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16125 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16126 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16127 r
= build2 (code
, type
, op0
, op1
);
16128 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
16129 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
16130 && !(complain
& tf_error
))
16131 return error_mark_node
;
16135 case EXPR_PACK_EXPANSION
:
16136 error ("invalid use of pack expansion expression");
16137 return error_mark_node
;
16139 case NONTYPE_ARGUMENT_PACK
:
16140 error ("use %<...%> to expand argument pack");
16141 return error_mark_node
;
16144 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
16152 /* Instantiate any typedefs in the type. */
16153 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16154 r
= fold_convert (type
, t
);
16155 gcc_assert (TREE_CODE (r
) == code
);
16160 /* These can sometimes show up in a partial instantiation, but never
16161 involve template parms. */
16162 gcc_assert (!uses_template_parms (t
));
16165 case UNARY_LEFT_FOLD_EXPR
:
16166 return tsubst_unary_left_fold (t
, args
, complain
, in_decl
);
16167 case UNARY_RIGHT_FOLD_EXPR
:
16168 return tsubst_unary_right_fold (t
, args
, complain
, in_decl
);
16169 case BINARY_LEFT_FOLD_EXPR
:
16170 return tsubst_binary_left_fold (t
, args
, complain
, in_decl
);
16171 case BINARY_RIGHT_FOLD_EXPR
:
16172 return tsubst_binary_right_fold (t
, args
, complain
, in_decl
);
16176 case DEBUG_BEGIN_STMT
:
16177 /* ??? There's no point in copying it for now, but maybe some
16178 day it will contain more information, such as a pointer back
16179 to the containing function, inlined copy or so. */
16183 /* We shouldn't get here, but keep going if !flag_checking. */
16185 gcc_unreachable ();
16190 /* Helper function for tsubst_omp_clauses, used for instantiation of
16191 OMP_CLAUSE_DECL of clauses. */
16194 tsubst_omp_clause_decl (tree decl
, tree args
, tsubst_flags_t complain
,
16195 tree in_decl
, tree
*iterator_cache
)
16197 if (decl
== NULL_TREE
)
16200 /* Handle OpenMP iterators. */
16201 if (TREE_CODE (decl
) == TREE_LIST
16202 && TREE_PURPOSE (decl
)
16203 && TREE_CODE (TREE_PURPOSE (decl
)) == TREE_VEC
)
16206 if (iterator_cache
[0] == TREE_PURPOSE (decl
))
16207 ret
= iterator_cache
[1];
16211 begin_scope (sk_omp
, NULL
);
16212 for (tree it
= TREE_PURPOSE (decl
); it
; it
= TREE_CHAIN (it
))
16214 *tp
= copy_node (it
);
16215 TREE_VEC_ELT (*tp
, 0)
16216 = tsubst_decl (TREE_VEC_ELT (it
, 0), args
, complain
);
16217 TREE_VEC_ELT (*tp
, 1)
16218 = tsubst_expr (TREE_VEC_ELT (it
, 1), args
, complain
, in_decl
,
16219 /*integral_constant_expression_p=*/false);
16220 TREE_VEC_ELT (*tp
, 2)
16221 = tsubst_expr (TREE_VEC_ELT (it
, 2), args
, complain
, in_decl
,
16222 /*integral_constant_expression_p=*/false);
16223 TREE_VEC_ELT (*tp
, 3)
16224 = tsubst_expr (TREE_VEC_ELT (it
, 3), args
, complain
, in_decl
,
16225 /*integral_constant_expression_p=*/false);
16226 TREE_CHAIN (*tp
) = NULL_TREE
;
16227 tp
= &TREE_CHAIN (*tp
);
16229 TREE_VEC_ELT (ret
, 5) = poplevel (1, 1, 0);
16230 iterator_cache
[0] = TREE_PURPOSE (decl
);
16231 iterator_cache
[1] = ret
;
16233 return build_tree_list (ret
, tsubst_omp_clause_decl (TREE_VALUE (decl
),
16238 /* Handle an OpenMP array section represented as a TREE_LIST (or
16239 OMP_CLAUSE_DEPEND_KIND). An OMP_CLAUSE_DEPEND (with a depend
16240 kind of OMP_CLAUSE_DEPEND_SINK) can also be represented as a
16241 TREE_LIST. We can handle it exactly the same as an array section
16242 (purpose, value, and a chain), even though the nomenclature
16243 (low_bound, length, etc) is different. */
16244 if (TREE_CODE (decl
) == TREE_LIST
)
16247 = tsubst_expr (TREE_PURPOSE (decl
), args
, complain
, in_decl
,
16248 /*integral_constant_expression_p=*/false);
16249 tree length
= tsubst_expr (TREE_VALUE (decl
), args
, complain
, in_decl
,
16250 /*integral_constant_expression_p=*/false);
16251 tree chain
= tsubst_omp_clause_decl (TREE_CHAIN (decl
), args
, complain
,
16253 if (TREE_PURPOSE (decl
) == low_bound
16254 && TREE_VALUE (decl
) == length
16255 && TREE_CHAIN (decl
) == chain
)
16257 tree ret
= tree_cons (low_bound
, length
, chain
);
16258 OMP_CLAUSE_DEPEND_SINK_NEGATIVE (ret
)
16259 = OMP_CLAUSE_DEPEND_SINK_NEGATIVE (decl
);
16262 tree ret
= tsubst_expr (decl
, args
, complain
, in_decl
,
16263 /*integral_constant_expression_p=*/false);
16264 /* Undo convert_from_reference tsubst_expr could have called. */
16266 && REFERENCE_REF_P (ret
)
16267 && !REFERENCE_REF_P (decl
))
16268 ret
= TREE_OPERAND (ret
, 0);
16272 /* Like tsubst_copy, but specifically for OpenMP clauses. */
16275 tsubst_omp_clauses (tree clauses
, enum c_omp_region_type ort
,
16276 tree args
, tsubst_flags_t complain
, tree in_decl
)
16278 tree new_clauses
= NULL_TREE
, nc
, oc
;
16279 tree linear_no_step
= NULL_TREE
;
16280 tree iterator_cache
[2] = { NULL_TREE
, NULL_TREE
};
16282 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
16284 nc
= copy_node (oc
);
16285 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
16288 switch (OMP_CLAUSE_CODE (nc
))
16290 case OMP_CLAUSE_LASTPRIVATE
:
16291 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
16293 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
16294 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
16295 in_decl
, /*integral_constant_expression_p=*/false);
16296 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
16297 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
16300 case OMP_CLAUSE_PRIVATE
:
16301 case OMP_CLAUSE_SHARED
:
16302 case OMP_CLAUSE_FIRSTPRIVATE
:
16303 case OMP_CLAUSE_COPYIN
:
16304 case OMP_CLAUSE_COPYPRIVATE
:
16305 case OMP_CLAUSE_UNIFORM
:
16306 case OMP_CLAUSE_DEPEND
:
16307 case OMP_CLAUSE_FROM
:
16308 case OMP_CLAUSE_TO
:
16309 case OMP_CLAUSE_MAP
:
16310 case OMP_CLAUSE_NONTEMPORAL
:
16311 case OMP_CLAUSE_USE_DEVICE_PTR
:
16312 case OMP_CLAUSE_IS_DEVICE_PTR
:
16313 OMP_CLAUSE_DECL (nc
)
16314 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16315 in_decl
, iterator_cache
);
16317 case OMP_CLAUSE_TILE
:
16318 case OMP_CLAUSE_IF
:
16319 case OMP_CLAUSE_NUM_THREADS
:
16320 case OMP_CLAUSE_SCHEDULE
:
16321 case OMP_CLAUSE_COLLAPSE
:
16322 case OMP_CLAUSE_FINAL
:
16323 case OMP_CLAUSE_DEVICE
:
16324 case OMP_CLAUSE_DIST_SCHEDULE
:
16325 case OMP_CLAUSE_NUM_TEAMS
:
16326 case OMP_CLAUSE_THREAD_LIMIT
:
16327 case OMP_CLAUSE_SAFELEN
:
16328 case OMP_CLAUSE_SIMDLEN
:
16329 case OMP_CLAUSE_NUM_TASKS
:
16330 case OMP_CLAUSE_GRAINSIZE
:
16331 case OMP_CLAUSE_PRIORITY
:
16332 case OMP_CLAUSE_ORDERED
:
16333 case OMP_CLAUSE_HINT
:
16334 case OMP_CLAUSE_NUM_GANGS
:
16335 case OMP_CLAUSE_NUM_WORKERS
:
16336 case OMP_CLAUSE_VECTOR_LENGTH
:
16337 case OMP_CLAUSE_WORKER
:
16338 case OMP_CLAUSE_VECTOR
:
16339 case OMP_CLAUSE_ASYNC
:
16340 case OMP_CLAUSE_WAIT
:
16341 OMP_CLAUSE_OPERAND (nc
, 0)
16342 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
16343 in_decl
, /*integral_constant_expression_p=*/false);
16345 case OMP_CLAUSE_REDUCTION
:
16346 case OMP_CLAUSE_IN_REDUCTION
:
16347 case OMP_CLAUSE_TASK_REDUCTION
:
16348 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
16350 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
16351 if (TREE_CODE (placeholder
) == SCOPE_REF
)
16353 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
16354 complain
, in_decl
);
16355 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
16356 = build_qualified_name (NULL_TREE
, scope
,
16357 TREE_OPERAND (placeholder
, 1),
16361 gcc_assert (identifier_p (placeholder
));
16363 OMP_CLAUSE_DECL (nc
)
16364 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16367 case OMP_CLAUSE_GANG
:
16368 case OMP_CLAUSE_ALIGNED
:
16369 OMP_CLAUSE_DECL (nc
)
16370 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16372 OMP_CLAUSE_OPERAND (nc
, 1)
16373 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
16374 in_decl
, /*integral_constant_expression_p=*/false);
16376 case OMP_CLAUSE_LINEAR
:
16377 OMP_CLAUSE_DECL (nc
)
16378 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16380 if (OMP_CLAUSE_LINEAR_STEP (oc
) == NULL_TREE
)
16382 gcc_assert (!linear_no_step
);
16383 linear_no_step
= nc
;
16385 else if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (oc
))
16386 OMP_CLAUSE_LINEAR_STEP (nc
)
16387 = tsubst_omp_clause_decl (OMP_CLAUSE_LINEAR_STEP (oc
), args
,
16388 complain
, in_decl
, NULL
);
16390 OMP_CLAUSE_LINEAR_STEP (nc
)
16391 = tsubst_expr (OMP_CLAUSE_LINEAR_STEP (oc
), args
, complain
,
16393 /*integral_constant_expression_p=*/false);
16395 case OMP_CLAUSE_NOWAIT
:
16396 case OMP_CLAUSE_DEFAULT
:
16397 case OMP_CLAUSE_UNTIED
:
16398 case OMP_CLAUSE_MERGEABLE
:
16399 case OMP_CLAUSE_INBRANCH
:
16400 case OMP_CLAUSE_NOTINBRANCH
:
16401 case OMP_CLAUSE_PROC_BIND
:
16402 case OMP_CLAUSE_FOR
:
16403 case OMP_CLAUSE_PARALLEL
:
16404 case OMP_CLAUSE_SECTIONS
:
16405 case OMP_CLAUSE_TASKGROUP
:
16406 case OMP_CLAUSE_NOGROUP
:
16407 case OMP_CLAUSE_THREADS
:
16408 case OMP_CLAUSE_SIMD
:
16409 case OMP_CLAUSE_DEFAULTMAP
:
16410 case OMP_CLAUSE_INDEPENDENT
:
16411 case OMP_CLAUSE_AUTO
:
16412 case OMP_CLAUSE_SEQ
:
16413 case OMP_CLAUSE_IF_PRESENT
:
16414 case OMP_CLAUSE_FINALIZE
:
16417 gcc_unreachable ();
16419 if ((ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
)
16420 switch (OMP_CLAUSE_CODE (nc
))
16422 case OMP_CLAUSE_SHARED
:
16423 case OMP_CLAUSE_PRIVATE
:
16424 case OMP_CLAUSE_FIRSTPRIVATE
:
16425 case OMP_CLAUSE_LASTPRIVATE
:
16426 case OMP_CLAUSE_COPYPRIVATE
:
16427 case OMP_CLAUSE_LINEAR
:
16428 case OMP_CLAUSE_REDUCTION
:
16429 case OMP_CLAUSE_IN_REDUCTION
:
16430 case OMP_CLAUSE_TASK_REDUCTION
:
16431 case OMP_CLAUSE_USE_DEVICE_PTR
:
16432 case OMP_CLAUSE_IS_DEVICE_PTR
:
16433 /* tsubst_expr on SCOPE_REF results in returning
16434 finish_non_static_data_member result. Undo that here. */
16435 if (TREE_CODE (OMP_CLAUSE_DECL (oc
)) == SCOPE_REF
16436 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (oc
), 1))
16437 == IDENTIFIER_NODE
))
16439 tree t
= OMP_CLAUSE_DECL (nc
);
16442 switch (TREE_CODE (v
))
16444 case COMPONENT_REF
:
16448 case POINTER_PLUS_EXPR
:
16449 v
= TREE_OPERAND (v
, 0);
16452 if (DECL_CONTEXT (v
) == current_function_decl
16453 && DECL_ARTIFICIAL (v
)
16454 && DECL_NAME (v
) == this_identifier
)
16455 OMP_CLAUSE_DECL (nc
) = TREE_OPERAND (t
, 1);
16462 else if (VAR_P (OMP_CLAUSE_DECL (oc
))
16463 && DECL_HAS_VALUE_EXPR_P (OMP_CLAUSE_DECL (oc
))
16464 && DECL_ARTIFICIAL (OMP_CLAUSE_DECL (oc
))
16465 && DECL_LANG_SPECIFIC (OMP_CLAUSE_DECL (oc
))
16466 && DECL_OMP_PRIVATIZED_MEMBER (OMP_CLAUSE_DECL (oc
)))
16468 tree decl
= OMP_CLAUSE_DECL (nc
);
16471 retrofit_lang_decl (decl
);
16472 DECL_OMP_PRIVATIZED_MEMBER (decl
) = 1;
16481 new_clauses
= nreverse (new_clauses
);
16482 if (ort
!= C_ORT_OMP_DECLARE_SIMD
)
16484 new_clauses
= finish_omp_clauses (new_clauses
, ort
);
16485 if (linear_no_step
)
16486 for (nc
= new_clauses
; nc
; nc
= OMP_CLAUSE_CHAIN (nc
))
16487 if (nc
== linear_no_step
)
16489 OMP_CLAUSE_LINEAR_STEP (nc
) = NULL_TREE
;
16493 return new_clauses
;
16496 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
16499 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
16502 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
16504 tree purpose
, value
, chain
;
16509 if (TREE_CODE (t
) != TREE_LIST
)
16510 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
16511 /*function_p=*/false,
16512 /*integral_constant_expression_p=*/false);
16514 if (t
== void_list_node
)
16517 purpose
= TREE_PURPOSE (t
);
16519 purpose
= RECUR (purpose
);
16520 value
= TREE_VALUE (t
);
16523 if (TREE_CODE (value
) != LABEL_DECL
)
16524 value
= RECUR (value
);
16527 value
= lookup_label (DECL_NAME (value
));
16528 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
16529 TREE_USED (value
) = 1;
16532 chain
= TREE_CHAIN (t
);
16533 if (chain
&& chain
!= void_type_node
)
16534 chain
= RECUR (chain
);
16535 return tree_cons (purpose
, value
, chain
);
16539 /* Used to temporarily communicate the list of #pragma omp parallel
16540 clauses to #pragma omp for instantiation if they are combined
16543 static tree
*omp_parallel_combined_clauses
;
16545 static tree
tsubst_decomp_names (tree
, tree
, tree
, tsubst_flags_t
, tree
,
16546 tree
*, unsigned int *);
16548 /* Substitute one OMP_FOR iterator. */
16551 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree
&orig_declv
,
16552 tree initv
, tree condv
, tree incrv
, tree
*clauses
,
16553 tree args
, tsubst_flags_t complain
, tree in_decl
,
16554 bool integral_constant_expression_p
)
16556 #define RECUR(NODE) \
16557 tsubst_expr ((NODE), args, complain, in_decl, \
16558 integral_constant_expression_p)
16559 tree decl
, init
, cond
= NULL_TREE
, incr
= NULL_TREE
;
16562 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
16563 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
16565 decl
= TREE_OPERAND (init
, 0);
16566 init
= TREE_OPERAND (init
, 1);
16567 tree decl_expr
= NULL_TREE
;
16568 bool range_for
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
) == global_namespace
;
16571 bool decomp
= false;
16572 if (decl
!= error_mark_node
&& DECL_HAS_VALUE_EXPR_P (decl
))
16574 tree v
= DECL_VALUE_EXPR (decl
);
16575 if (TREE_CODE (v
) == ARRAY_REF
16576 && VAR_P (TREE_OPERAND (v
, 0))
16577 && DECL_DECOMPOSITION_P (TREE_OPERAND (v
, 0)))
16579 tree decomp_first
= NULL_TREE
;
16580 unsigned decomp_cnt
= 0;
16581 tree d
= tsubst_decl (TREE_OPERAND (v
, 0), args
, complain
);
16582 maybe_push_decl (d
);
16583 d
= tsubst_decomp_names (d
, TREE_OPERAND (v
, 0), args
, complain
,
16584 in_decl
, &decomp_first
, &decomp_cnt
);
16586 if (d
== error_mark_node
)
16587 decl
= error_mark_node
;
16589 for (unsigned int i
= 0; i
< decomp_cnt
; i
++)
16591 if (!DECL_HAS_VALUE_EXPR_P (decomp_first
))
16593 tree v
= build_nt (ARRAY_REF
, d
,
16594 size_int (decomp_cnt
- i
- 1),
16595 NULL_TREE
, NULL_TREE
);
16596 SET_DECL_VALUE_EXPR (decomp_first
, v
);
16597 DECL_HAS_VALUE_EXPR_P (decomp_first
) = 1;
16599 fit_decomposition_lang_decl (decomp_first
, d
);
16600 decomp_first
= DECL_CHAIN (decomp_first
);
16604 decl
= tsubst_decl (decl
, args
, complain
);
16606 maybe_push_decl (decl
);
16608 else if (init
&& TREE_CODE (init
) == DECL_EXPR
)
16610 /* We need to jump through some hoops to handle declarations in the
16611 init-statement, since we might need to handle auto deduction,
16612 but we need to keep control of initialization. */
16614 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
16615 decl
= tsubst_decl (decl
, args
, complain
);
16619 if (TREE_CODE (decl
) == SCOPE_REF
)
16621 decl
= RECUR (decl
);
16622 if (TREE_CODE (decl
) == COMPONENT_REF
)
16626 switch (TREE_CODE (v
))
16628 case COMPONENT_REF
:
16632 case POINTER_PLUS_EXPR
:
16633 v
= TREE_OPERAND (v
, 0);
16636 if (DECL_CONTEXT (v
) == current_function_decl
16637 && DECL_ARTIFICIAL (v
)
16638 && DECL_NAME (v
) == this_identifier
)
16640 decl
= TREE_OPERAND (decl
, 1);
16641 decl
= omp_privatize_field (decl
, false);
16651 decl
= RECUR (decl
);
16653 init
= RECUR (init
);
16655 if (orig_declv
&& OMP_FOR_ORIG_DECLS (t
))
16657 tree o
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t
), i
);
16658 if (TREE_CODE (o
) == TREE_LIST
)
16659 TREE_VEC_ELT (orig_declv
, i
)
16660 = tree_cons (RECUR (TREE_PURPOSE (o
)),
16661 RECUR (TREE_VALUE (o
)),
16664 TREE_VEC_ELT (orig_declv
, i
) = RECUR (o
);
16669 tree this_pre_body
= NULL_TREE
;
16670 tree orig_init
= NULL_TREE
;
16671 tree orig_decl
= NULL_TREE
;
16672 cp_convert_omp_range_for (this_pre_body
, NULL
, decl
, orig_decl
, init
,
16673 orig_init
, cond
, incr
);
16676 if (orig_declv
== NULL_TREE
)
16677 orig_declv
= copy_node (declv
);
16678 TREE_VEC_ELT (orig_declv
, i
) = orig_decl
;
16681 else if (orig_declv
)
16682 TREE_VEC_ELT (orig_declv
, i
) = decl
;
16685 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
16686 if (!range_for
&& auto_node
&& init
)
16688 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
, complain
);
16690 gcc_assert (!type_dependent_expression_p (decl
));
16692 if (!CLASS_TYPE_P (TREE_TYPE (decl
)) || range_for
)
16696 /* Declare the variable, but don't let that initialize it. */
16697 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
16698 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
16700 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
16705 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
16706 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
16707 if (TREE_CODE (incr
) == MODIFY_EXPR
)
16709 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16710 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
16711 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
16712 NOP_EXPR
, rhs
, complain
);
16715 incr
= RECUR (incr
);
16716 if (orig_declv
&& !OMP_FOR_ORIG_DECLS (t
))
16717 TREE_VEC_ELT (orig_declv
, i
) = decl
;
16719 TREE_VEC_ELT (declv
, i
) = decl
;
16720 TREE_VEC_ELT (initv
, i
) = init
;
16721 TREE_VEC_ELT (condv
, i
) = cond
;
16722 TREE_VEC_ELT (incrv
, i
) = incr
;
16728 /* Declare and initialize the variable. */
16736 for (j
= (omp_parallel_combined_clauses
== NULL
? 1 : 0); j
< 2; j
++)
16738 for (pc
= j
? clauses
: omp_parallel_combined_clauses
; *pc
; )
16740 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
16741 && OMP_CLAUSE_DECL (*pc
) == decl
)
16743 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_LASTPRIVATE
16744 && OMP_CLAUSE_DECL (*pc
) == decl
)
16748 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
16750 *pc
= OMP_CLAUSE_CHAIN (c
);
16751 OMP_CLAUSE_CHAIN (c
) = *clauses
;
16754 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_FIRSTPRIVATE
16755 && OMP_CLAUSE_DECL (*pc
) == decl
)
16757 error ("iteration variable %qD should not be firstprivate",
16759 *pc
= OMP_CLAUSE_CHAIN (*pc
);
16761 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_REDUCTION
16762 && OMP_CLAUSE_DECL (*pc
) == decl
)
16764 error ("iteration variable %qD should not be reduction",
16766 *pc
= OMP_CLAUSE_CHAIN (*pc
);
16769 pc
= &OMP_CLAUSE_CHAIN (*pc
);
16774 if (*pc
== NULL_TREE
)
16776 tree c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
16777 OMP_CLAUSE_DECL (c
) = decl
;
16778 c
= finish_omp_clauses (c
, C_ORT_OMP
);
16781 OMP_CLAUSE_CHAIN (c
) = *clauses
;
16786 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
16787 if (COMPARISON_CLASS_P (cond
))
16789 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
16790 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
16791 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
16794 cond
= RECUR (cond
);
16795 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
16796 switch (TREE_CODE (incr
))
16798 case PREINCREMENT_EXPR
:
16799 case PREDECREMENT_EXPR
:
16800 case POSTINCREMENT_EXPR
:
16801 case POSTDECREMENT_EXPR
:
16802 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
16803 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
16806 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
16807 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
16809 tree rhs
= TREE_OPERAND (incr
, 1);
16810 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16811 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
16812 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
16813 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
16814 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
16818 incr
= RECUR (incr
);
16821 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
16822 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
16824 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16825 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
16826 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
16827 TREE_TYPE (decl
), lhs
,
16828 RECUR (TREE_OPERAND (incr
, 2))));
16830 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
16831 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
16832 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
16834 tree rhs
= TREE_OPERAND (incr
, 2);
16835 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16836 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
16837 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
16838 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
16839 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
16843 incr
= RECUR (incr
);
16846 incr
= RECUR (incr
);
16850 if (orig_declv
&& !OMP_FOR_ORIG_DECLS (t
))
16851 TREE_VEC_ELT (orig_declv
, i
) = decl
;
16852 TREE_VEC_ELT (declv
, i
) = decl
;
16853 TREE_VEC_ELT (initv
, i
) = init
;
16854 TREE_VEC_ELT (condv
, i
) = cond
;
16855 TREE_VEC_ELT (incrv
, i
) = incr
;
16860 /* Helper function of tsubst_expr, find OMP_TEAMS inside
16861 of OMP_TARGET's body. */
16864 tsubst_find_omp_teams (tree
*tp
, int *walk_subtrees
, void *)
16866 *walk_subtrees
= 0;
16867 switch (TREE_CODE (*tp
))
16872 case STATEMENT_LIST
:
16873 *walk_subtrees
= 1;
16881 /* Helper function for tsubst_expr. For decomposition declaration
16882 artificial base DECL, which is tsubsted PATTERN_DECL, tsubst
16883 also the corresponding decls representing the identifiers
16884 of the decomposition declaration. Return DECL if successful
16885 or error_mark_node otherwise, set *FIRST to the first decl
16886 in the list chained through DECL_CHAIN and *CNT to the number
16890 tsubst_decomp_names (tree decl
, tree pattern_decl
, tree args
,
16891 tsubst_flags_t complain
, tree in_decl
, tree
*first
,
16894 tree decl2
, decl3
, prev
= decl
;
16896 gcc_assert (DECL_NAME (decl
) == NULL_TREE
);
16897 for (decl2
= DECL_CHAIN (pattern_decl
);
16900 && DECL_DECOMPOSITION_P (decl2
)
16901 && DECL_NAME (decl2
);
16902 decl2
= DECL_CHAIN (decl2
))
16904 if (TREE_TYPE (decl2
) == error_mark_node
&& *cnt
== 0)
16906 gcc_assert (errorcount
);
16907 return error_mark_node
;
16910 gcc_assert (DECL_DECOMP_BASE (decl2
) == pattern_decl
);
16911 gcc_assert (DECL_HAS_VALUE_EXPR_P (decl2
));
16912 tree v
= DECL_VALUE_EXPR (decl2
);
16913 DECL_HAS_VALUE_EXPR_P (decl2
) = 0;
16914 SET_DECL_VALUE_EXPR (decl2
, NULL_TREE
);
16915 decl3
= tsubst (decl2
, args
, complain
, in_decl
);
16916 SET_DECL_VALUE_EXPR (decl2
, v
);
16917 DECL_HAS_VALUE_EXPR_P (decl2
) = 1;
16919 DECL_TEMPLATE_INSTANTIATED (decl3
) = 1;
16922 gcc_assert (errorcount
);
16923 decl
= error_mark_node
;
16926 maybe_push_decl (decl3
);
16927 if (error_operand_p (decl3
))
16928 decl
= error_mark_node
;
16929 else if (decl
!= error_mark_node
16930 && DECL_CHAIN (decl3
) != prev
16933 gcc_assert (errorcount
);
16934 decl
= error_mark_node
;
16943 /* Return the proper local_specialization for init-capture pack DECL. */
16946 lookup_init_capture_pack (tree decl
)
16948 /* We handle normal pack captures by forwarding to the specialization of the
16949 captured parameter. We can't do that for pack init-captures; we need them
16950 to have their own local_specialization. We created the individual
16951 VAR_DECLs (if any) under build_capture_proxy, and we need to collect them
16952 when we process the DECL_EXPR for the pack init-capture in the template.
16953 So, how do we find them? We don't know the capture proxy pack when
16954 building the individual resulting proxies, and we don't know the
16955 individual proxies when instantiating the pack. What we have in common is
16958 So...when we instantiate the FIELD_DECL, we stick the result in
16959 local_specializations. Then at the DECL_EXPR we look up that result, see
16960 how many elements it has, synthesize the names, and look them up. */
16962 tree cname
= DECL_NAME (decl
);
16963 tree val
= DECL_VALUE_EXPR (decl
);
16964 tree field
= TREE_OPERAND (val
, 1);
16965 gcc_assert (TREE_CODE (field
) == FIELD_DECL
);
16966 tree fpack
= retrieve_local_specialization (field
);
16967 if (fpack
== error_mark_node
)
16968 return error_mark_node
;
16971 tree vec
= NULL_TREE
;
16972 tree r
= NULL_TREE
;
16973 if (TREE_CODE (fpack
) == TREE_VEC
)
16975 len
= TREE_VEC_LENGTH (fpack
);
16976 vec
= make_tree_vec (len
);
16977 r
= make_node (NONTYPE_ARGUMENT_PACK
);
16978 SET_ARGUMENT_PACK_ARGS (r
, vec
);
16980 for (int i
= 0; i
< len
; ++i
)
16982 tree ename
= vec
? make_ith_pack_parameter_name (cname
, i
) : cname
;
16983 tree elt
= lookup_name_real (ename
, 0, 0, true, 0, LOOKUP_NORMAL
);
16985 TREE_VEC_ELT (vec
, i
) = elt
;
16992 /* Like tsubst_copy for expressions, etc. but also does semantic
16996 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
16997 bool integral_constant_expression_p
)
16999 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
17000 #define RECUR(NODE) \
17001 tsubst_expr ((NODE), args, complain, in_decl, \
17002 integral_constant_expression_p)
17008 if (t
== NULL_TREE
|| t
== error_mark_node
)
17011 loc
= input_location
;
17012 if (location_t eloc
= cp_expr_location (t
))
17013 input_location
= eloc
;
17014 if (STATEMENT_CODE_P (TREE_CODE (t
)))
17015 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
17017 switch (TREE_CODE (t
))
17019 case STATEMENT_LIST
:
17021 tree_stmt_iterator i
;
17022 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
17023 RECUR (tsi_stmt (i
));
17027 case CTOR_INITIALIZER
:
17028 finish_mem_initializers (tsubst_initializer_list
17029 (TREE_OPERAND (t
, 0), args
));
17033 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
17037 tmp
= RECUR (EXPR_STMT_EXPR (t
));
17038 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
17039 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
17041 finish_expr_stmt (tmp
);
17045 finish_local_using_directive (USING_STMT_NAMESPACE (t
),
17046 /*attribs=*/NULL_TREE
);
17051 tree decl
, pattern_decl
;
17054 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
17055 if (TREE_CODE (decl
) == LABEL_DECL
)
17056 finish_label_decl (DECL_NAME (decl
));
17057 else if (TREE_CODE (decl
) == USING_DECL
)
17059 tree scope
= USING_DECL_SCOPE (decl
);
17060 tree name
= DECL_NAME (decl
);
17062 scope
= tsubst (scope
, args
, complain
, in_decl
);
17063 decl
= lookup_qualified_name (scope
, name
,
17064 /*is_type_p=*/false,
17065 /*complain=*/false);
17066 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
17067 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
17069 finish_local_using_decl (decl
, scope
, name
);
17071 else if (is_capture_proxy (decl
)
17072 && !DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
17074 /* We're in tsubst_lambda_expr, we've already inserted a new
17075 capture proxy, so look it up and register it. */
17077 if (!DECL_PACK_P (decl
))
17079 inst
= lookup_name_real (DECL_NAME (decl
), /*prefer_type*/0,
17080 /*nonclass*/1, /*block_p=*/true,
17081 /*ns_only*/0, LOOKUP_HIDDEN
);
17082 gcc_assert (inst
!= decl
&& is_capture_proxy (inst
));
17084 else if (is_normal_capture_proxy (decl
))
17086 inst
= (retrieve_local_specialization
17087 (DECL_CAPTURED_VARIABLE (decl
)));
17088 gcc_assert (TREE_CODE (inst
) == NONTYPE_ARGUMENT_PACK
);
17091 inst
= lookup_init_capture_pack (decl
);
17093 register_local_specialization (inst
, decl
);
17096 else if (DECL_PRETTY_FUNCTION_P (decl
))
17097 decl
= make_fname_decl (DECL_SOURCE_LOCATION (decl
),
17099 true/*DECL_PRETTY_FUNCTION_P (decl)*/);
17100 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
17101 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
17102 /* Don't copy the old closure; we'll create a new one in
17103 tsubst_lambda_expr. */
17107 init
= DECL_INITIAL (decl
);
17108 decl
= tsubst (decl
, args
, complain
, in_decl
);
17109 if (decl
!= error_mark_node
)
17111 /* By marking the declaration as instantiated, we avoid
17112 trying to instantiate it. Since instantiate_decl can't
17113 handle local variables, and since we've already done
17114 all that needs to be done, that's the right thing to
17117 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
17118 if (VAR_P (decl
) && !DECL_NAME (decl
)
17119 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
17120 /* Anonymous aggregates are a special case. */
17121 finish_anon_union (decl
);
17122 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
17124 DECL_CONTEXT (decl
) = current_function_decl
;
17125 if (DECL_NAME (decl
) == this_identifier
)
17127 tree lam
= DECL_CONTEXT (current_function_decl
);
17128 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
17129 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
17131 insert_capture_proxy (decl
);
17133 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
17134 /* We already did a pushtag. */;
17135 else if (TREE_CODE (decl
) == FUNCTION_DECL
17136 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
17137 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
17139 DECL_CONTEXT (decl
) = NULL_TREE
;
17141 DECL_CONTEXT (decl
) = current_function_decl
;
17142 cp_check_omp_declare_reduction (decl
);
17146 int const_init
= false;
17147 unsigned int cnt
= 0;
17148 tree first
= NULL_TREE
, ndecl
= error_mark_node
;
17149 maybe_push_decl (decl
);
17152 && DECL_DECOMPOSITION_P (decl
)
17153 && TREE_TYPE (pattern_decl
) != error_mark_node
)
17154 ndecl
= tsubst_decomp_names (decl
, pattern_decl
, args
,
17155 complain
, in_decl
, &first
,
17158 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
17161 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
17164 if (ndecl
!= error_mark_node
)
17165 cp_maybe_mangle_decomp (ndecl
, first
, cnt
);
17167 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
17169 if (ndecl
!= error_mark_node
)
17170 cp_finish_decomp (ndecl
, first
, cnt
);
17179 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
17180 RECUR (FOR_INIT_STMT (t
));
17181 finish_init_stmt (stmt
);
17182 tmp
= RECUR (FOR_COND (t
));
17183 finish_for_cond (tmp
, stmt
, false, 0);
17184 tmp
= RECUR (FOR_EXPR (t
));
17185 finish_for_expr (tmp
, stmt
);
17187 bool prev
= note_iteration_stmt_body_start ();
17188 RECUR (FOR_BODY (t
));
17189 note_iteration_stmt_body_end (prev
);
17191 finish_for_stmt (stmt
);
17194 case RANGE_FOR_STMT
:
17196 /* Construct another range_for, if this is not a final
17197 substitution (for inside inside a generic lambda of a
17198 template). Otherwise convert to a regular for. */
17200 stmt
= (processing_template_decl
17201 ? begin_range_for_stmt (NULL_TREE
, NULL_TREE
)
17202 : begin_for_stmt (NULL_TREE
, NULL_TREE
));
17203 RECUR (RANGE_FOR_INIT_STMT (t
));
17204 decl
= RANGE_FOR_DECL (t
);
17205 decl
= tsubst (decl
, args
, complain
, in_decl
);
17206 maybe_push_decl (decl
);
17207 expr
= RECUR (RANGE_FOR_EXPR (t
));
17209 tree decomp_first
= NULL_TREE
;
17210 unsigned decomp_cnt
= 0;
17211 if (VAR_P (decl
) && DECL_DECOMPOSITION_P (decl
))
17212 decl
= tsubst_decomp_names (decl
, RANGE_FOR_DECL (t
), args
,
17214 &decomp_first
, &decomp_cnt
);
17216 if (processing_template_decl
)
17218 RANGE_FOR_IVDEP (stmt
) = RANGE_FOR_IVDEP (t
);
17219 RANGE_FOR_UNROLL (stmt
) = RANGE_FOR_UNROLL (t
);
17220 finish_range_for_decl (stmt
, decl
, expr
);
17221 if (decomp_first
&& decl
!= error_mark_node
)
17222 cp_finish_decomp (decl
, decomp_first
, decomp_cnt
);
17226 unsigned short unroll
= (RANGE_FOR_UNROLL (t
)
17227 ? tree_to_uhwi (RANGE_FOR_UNROLL (t
)) : 0);
17228 stmt
= cp_convert_range_for (stmt
, decl
, expr
,
17229 decomp_first
, decomp_cnt
,
17230 RANGE_FOR_IVDEP (t
), unroll
);
17233 bool prev
= note_iteration_stmt_body_start ();
17234 RECUR (RANGE_FOR_BODY (t
));
17235 note_iteration_stmt_body_end (prev
);
17236 finish_for_stmt (stmt
);
17241 stmt
= begin_while_stmt ();
17242 tmp
= RECUR (WHILE_COND (t
));
17243 finish_while_stmt_cond (tmp
, stmt
, false, 0);
17245 bool prev
= note_iteration_stmt_body_start ();
17246 RECUR (WHILE_BODY (t
));
17247 note_iteration_stmt_body_end (prev
);
17249 finish_while_stmt (stmt
);
17253 stmt
= begin_do_stmt ();
17255 bool prev
= note_iteration_stmt_body_start ();
17256 RECUR (DO_BODY (t
));
17257 note_iteration_stmt_body_end (prev
);
17259 finish_do_body (stmt
);
17260 tmp
= RECUR (DO_COND (t
));
17261 finish_do_stmt (tmp
, stmt
, false, 0);
17265 stmt
= begin_if_stmt ();
17266 IF_STMT_CONSTEXPR_P (stmt
) = IF_STMT_CONSTEXPR_P (t
);
17267 if (IF_STMT_CONSTEXPR_P (t
))
17268 args
= add_extra_args (IF_STMT_EXTRA_ARGS (t
), args
);
17269 tmp
= RECUR (IF_COND (t
));
17270 tmp
= finish_if_stmt_cond (tmp
, stmt
);
17271 if (IF_STMT_CONSTEXPR_P (t
)
17272 && instantiation_dependent_expression_p (tmp
))
17274 /* We're partially instantiating a generic lambda, but the condition
17275 of the constexpr if is still dependent. Don't substitute into the
17276 branches now, just remember the template arguments. */
17277 do_poplevel (IF_SCOPE (stmt
));
17278 IF_COND (stmt
) = IF_COND (t
);
17279 THEN_CLAUSE (stmt
) = THEN_CLAUSE (t
);
17280 ELSE_CLAUSE (stmt
) = ELSE_CLAUSE (t
);
17281 IF_STMT_EXTRA_ARGS (stmt
) = build_extra_args (t
, args
, complain
);
17285 if (IF_STMT_CONSTEXPR_P (t
) && integer_zerop (tmp
))
17286 /* Don't instantiate the THEN_CLAUSE. */;
17289 tree folded
= fold_non_dependent_expr (tmp
, complain
);
17290 bool inhibit
= integer_zerop (folded
);
17292 ++c_inhibit_evaluation_warnings
;
17293 RECUR (THEN_CLAUSE (t
));
17295 --c_inhibit_evaluation_warnings
;
17297 finish_then_clause (stmt
);
17299 if (IF_STMT_CONSTEXPR_P (t
) && integer_nonzerop (tmp
))
17300 /* Don't instantiate the ELSE_CLAUSE. */;
17301 else if (ELSE_CLAUSE (t
))
17303 tree folded
= fold_non_dependent_expr (tmp
, complain
);
17304 bool inhibit
= integer_nonzerop (folded
);
17305 begin_else_clause (stmt
);
17307 ++c_inhibit_evaluation_warnings
;
17308 RECUR (ELSE_CLAUSE (t
));
17310 --c_inhibit_evaluation_warnings
;
17311 finish_else_clause (stmt
);
17314 finish_if_stmt (stmt
);
17318 if (BIND_EXPR_BODY_BLOCK (t
))
17319 stmt
= begin_function_body ();
17321 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
17322 ? BCS_TRY_BLOCK
: 0);
17324 RECUR (BIND_EXPR_BODY (t
));
17326 if (BIND_EXPR_BODY_BLOCK (t
))
17327 finish_function_body (stmt
);
17329 finish_compound_stmt (stmt
);
17333 finish_break_stmt ();
17336 case CONTINUE_STMT
:
17337 finish_continue_stmt ();
17341 stmt
= begin_switch_stmt ();
17342 tmp
= RECUR (SWITCH_STMT_COND (t
));
17343 finish_switch_cond (tmp
, stmt
);
17344 RECUR (SWITCH_STMT_BODY (t
));
17345 finish_switch_stmt (stmt
);
17348 case CASE_LABEL_EXPR
:
17350 tree decl
= CASE_LABEL (t
);
17351 tree low
= RECUR (CASE_LOW (t
));
17352 tree high
= RECUR (CASE_HIGH (t
));
17353 tree l
= finish_case_label (EXPR_LOCATION (t
), low
, high
);
17354 if (l
&& TREE_CODE (l
) == CASE_LABEL_EXPR
)
17356 tree label
= CASE_LABEL (l
);
17357 FALLTHROUGH_LABEL_P (label
) = FALLTHROUGH_LABEL_P (decl
);
17358 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
17359 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
17366 tree decl
= LABEL_EXPR_LABEL (t
);
17369 label
= finish_label_stmt (DECL_NAME (decl
));
17370 if (TREE_CODE (label
) == LABEL_DECL
)
17371 FALLTHROUGH_LABEL_P (label
) = FALLTHROUGH_LABEL_P (decl
);
17372 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
17373 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
17378 tmp
= GOTO_DESTINATION (t
);
17379 if (TREE_CODE (tmp
) != LABEL_DECL
)
17380 /* Computed goto's must be tsubst'd into. On the other hand,
17381 non-computed gotos must not be; the identifier in question
17382 will have no binding. */
17385 tmp
= DECL_NAME (tmp
);
17386 finish_goto_stmt (tmp
);
17391 tree string
= RECUR (ASM_STRING (t
));
17392 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
17393 complain
, in_decl
);
17394 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
17395 complain
, in_decl
);
17396 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
17397 complain
, in_decl
);
17398 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
17399 complain
, in_decl
);
17400 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
17401 clobbers
, labels
, ASM_INLINE_P (t
));
17402 tree asm_expr
= tmp
;
17403 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
17404 asm_expr
= TREE_OPERAND (asm_expr
, 0);
17405 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
17412 stmt
= begin_try_block ();
17413 RECUR (TRY_STMTS (t
));
17414 finish_cleanup_try_block (stmt
);
17415 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
17419 tree compound_stmt
= NULL_TREE
;
17421 if (FN_TRY_BLOCK_P (t
))
17422 stmt
= begin_function_try_block (&compound_stmt
);
17424 stmt
= begin_try_block ();
17426 RECUR (TRY_STMTS (t
));
17428 if (FN_TRY_BLOCK_P (t
))
17429 finish_function_try_block (stmt
);
17431 finish_try_block (stmt
);
17433 RECUR (TRY_HANDLERS (t
));
17434 if (FN_TRY_BLOCK_P (t
))
17435 finish_function_handler_sequence (stmt
, compound_stmt
);
17437 finish_handler_sequence (stmt
);
17443 tree decl
= HANDLER_PARMS (t
);
17447 decl
= tsubst (decl
, args
, complain
, in_decl
);
17448 /* Prevent instantiate_decl from trying to instantiate
17449 this variable. We've already done all that needs to be
17451 if (decl
!= error_mark_node
)
17452 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
17454 stmt
= begin_handler ();
17455 finish_handler_parms (decl
, stmt
);
17456 RECUR (HANDLER_BODY (t
));
17457 finish_handler (stmt
);
17462 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
17463 if (CLASS_TYPE_P (tmp
))
17465 /* Local classes are not independent templates; they are
17466 instantiated along with their containing function. And this
17467 way we don't have to deal with pushing out of one local class
17468 to instantiate a member of another local class. */
17469 /* Closures are handled by the LAMBDA_EXPR. */
17470 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
17471 complete_type (tmp
);
17472 for (tree fld
= TYPE_FIELDS (tmp
); fld
; fld
= DECL_CHAIN (fld
))
17474 || (TREE_CODE (fld
) == FUNCTION_DECL
17475 && !DECL_ARTIFICIAL (fld
)))
17476 && DECL_TEMPLATE_INSTANTIATION (fld
))
17477 instantiate_decl (fld
, /*defer_ok=*/false,
17478 /*expl_inst_class=*/false);
17482 case STATIC_ASSERT
:
17486 ++c_inhibit_evaluation_warnings
;
17488 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
17491 /*integral_constant_expression_p=*/true);
17492 --c_inhibit_evaluation_warnings
;
17494 finish_static_assert (condition
,
17495 STATIC_ASSERT_MESSAGE (t
),
17496 STATIC_ASSERT_SOURCE_LOCATION (t
),
17497 /*member_p=*/false);
17502 case OACC_PARALLEL
:
17503 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_ACC
, args
, complain
,
17505 stmt
= begin_omp_parallel ();
17506 RECUR (OMP_BODY (t
));
17507 finish_omp_construct (TREE_CODE (t
), stmt
, tmp
);
17511 r
= push_omp_privatization_clauses (OMP_PARALLEL_COMBINED (t
));
17512 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), C_ORT_OMP
, args
,
17513 complain
, in_decl
);
17514 if (OMP_PARALLEL_COMBINED (t
))
17515 omp_parallel_combined_clauses
= &tmp
;
17516 stmt
= begin_omp_parallel ();
17517 RECUR (OMP_PARALLEL_BODY (t
));
17518 gcc_assert (omp_parallel_combined_clauses
== NULL
);
17519 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
17520 = OMP_PARALLEL_COMBINED (t
);
17521 pop_omp_privatization_clauses (r
);
17525 if (OMP_TASK_BODY (t
) == NULL_TREE
)
17527 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), C_ORT_OMP
, args
,
17528 complain
, in_decl
);
17530 OMP_TASK_CLAUSES (t
) = tmp
;
17534 r
= push_omp_privatization_clauses (false);
17535 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), C_ORT_OMP
, args
,
17536 complain
, in_decl
);
17537 stmt
= begin_omp_task ();
17538 RECUR (OMP_TASK_BODY (t
));
17539 finish_omp_task (tmp
, stmt
);
17540 pop_omp_privatization_clauses (r
);
17545 case OMP_DISTRIBUTE
:
17549 tree clauses
, body
, pre_body
;
17550 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
17551 tree orig_declv
= NULL_TREE
;
17552 tree incrv
= NULL_TREE
;
17553 enum c_omp_region_type ort
= C_ORT_OMP
;
17554 bool any_range_for
= false;
17557 if (TREE_CODE (t
) == OACC_LOOP
)
17560 r
= push_omp_privatization_clauses (OMP_FOR_INIT (t
) == NULL_TREE
);
17561 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), ort
, args
, complain
,
17563 if (OMP_FOR_INIT (t
) != NULL_TREE
)
17565 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17566 if (OMP_FOR_ORIG_DECLS (t
))
17567 orig_declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17568 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17569 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17570 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17573 keep_next_level (true);
17574 stmt
= begin_omp_structured_block ();
17576 pre_body
= push_stmt_list ();
17577 RECUR (OMP_FOR_PRE_BODY (t
));
17578 pre_body
= pop_stmt_list (pre_body
);
17580 if (OMP_FOR_INIT (t
) != NULL_TREE
)
17581 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
17583 |= tsubst_omp_for_iterator (t
, i
, declv
, orig_declv
, initv
,
17584 condv
, incrv
, &clauses
, args
,
17586 integral_constant_expression_p
);
17587 omp_parallel_combined_clauses
= NULL
;
17591 gcc_assert (orig_declv
);
17592 body
= begin_omp_structured_block ();
17593 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
17594 if (TREE_VEC_ELT (orig_declv
, i
) != TREE_VEC_ELT (declv
, i
)
17595 && TREE_CODE (TREE_VEC_ELT (orig_declv
, i
)) == TREE_LIST
17596 && TREE_CHAIN (TREE_VEC_ELT (orig_declv
, i
)))
17597 cp_finish_omp_range_for (TREE_VEC_ELT (orig_declv
, i
),
17598 TREE_VEC_ELT (declv
, i
));
17601 body
= push_stmt_list ();
17602 RECUR (OMP_FOR_BODY (t
));
17604 body
= finish_omp_structured_block (body
);
17606 body
= pop_stmt_list (body
);
17608 if (OMP_FOR_INIT (t
) != NULL_TREE
)
17609 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
,
17610 orig_declv
, initv
, condv
, incrv
, body
, pre_body
,
17614 t
= make_node (TREE_CODE (t
));
17615 TREE_TYPE (t
) = void_type_node
;
17616 OMP_FOR_BODY (t
) = body
;
17617 OMP_FOR_PRE_BODY (t
) = pre_body
;
17618 OMP_FOR_CLAUSES (t
) = clauses
;
17619 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
17623 add_stmt (finish_omp_for_block (finish_omp_structured_block (stmt
),
17625 pop_omp_privatization_clauses (r
);
17630 omp_parallel_combined_clauses
= NULL
;
17635 case OMP_TASKGROUP
:
17636 r
= push_omp_privatization_clauses (TREE_CODE (t
) == OMP_TEAMS
17637 && OMP_TEAMS_COMBINED (t
));
17638 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_OMP
, args
, complain
,
17640 if (TREE_CODE (t
) == OMP_TEAMS
)
17642 keep_next_level (true);
17643 stmt
= begin_omp_structured_block ();
17644 RECUR (OMP_BODY (t
));
17645 stmt
= finish_omp_structured_block (stmt
);
17649 stmt
= push_stmt_list ();
17650 RECUR (OMP_BODY (t
));
17651 stmt
= pop_stmt_list (stmt
);
17655 OMP_BODY (t
) = stmt
;
17656 OMP_CLAUSES (t
) = tmp
;
17658 pop_omp_privatization_clauses (r
);
17662 r
= RECUR (OMP_DEPOBJ_DEPOBJ (t
));
17663 if (OMP_DEPOBJ_CLAUSES (t
) && OMP_DEPOBJ_CLAUSES (t
) != error_mark_node
)
17665 enum omp_clause_depend_kind kind
= OMP_CLAUSE_DEPEND_SOURCE
;
17666 if (TREE_CODE (OMP_DEPOBJ_CLAUSES (t
)) == OMP_CLAUSE
)
17668 tmp
= tsubst_omp_clauses (OMP_DEPOBJ_CLAUSES (t
), C_ORT_OMP
,
17669 args
, complain
, in_decl
);
17670 if (tmp
== NULL_TREE
)
17671 tmp
= error_mark_node
;
17675 kind
= (enum omp_clause_depend_kind
)
17676 tree_to_uhwi (OMP_DEPOBJ_CLAUSES (t
));
17679 finish_omp_depobj (EXPR_LOCATION (t
), r
, kind
, tmp
);
17682 finish_omp_depobj (EXPR_LOCATION (t
), r
,
17683 OMP_CLAUSE_DEPEND_SOURCE
,
17684 OMP_DEPOBJ_CLAUSES (t
));
17688 case OMP_TARGET_DATA
:
17690 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), (TREE_CODE (t
) == OACC_DATA
)
17691 ? C_ORT_ACC
: C_ORT_OMP
, args
, complain
,
17693 keep_next_level (true);
17694 stmt
= begin_omp_structured_block ();
17696 RECUR (OMP_BODY (t
));
17697 stmt
= finish_omp_structured_block (stmt
);
17700 OMP_BODY (t
) = stmt
;
17701 OMP_CLAUSES (t
) = tmp
;
17702 if (TREE_CODE (t
) == OMP_TARGET
&& OMP_TARGET_COMBINED (t
))
17704 tree teams
= cp_walk_tree (&stmt
, tsubst_find_omp_teams
, NULL
, NULL
);
17707 /* For combined target teams, ensure the num_teams and
17708 thread_limit clause expressions are evaluated on the host,
17709 before entering the target construct. */
17711 for (c
= OMP_TEAMS_CLAUSES (teams
);
17712 c
; c
= OMP_CLAUSE_CHAIN (c
))
17713 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
17714 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
17715 && TREE_CODE (OMP_CLAUSE_OPERAND (c
, 0)) != INTEGER_CST
)
17717 tree expr
= OMP_CLAUSE_OPERAND (c
, 0);
17718 expr
= force_target_expr (TREE_TYPE (expr
), expr
, tf_none
);
17719 if (expr
== error_mark_node
)
17721 tmp
= TARGET_EXPR_SLOT (expr
);
17723 OMP_CLAUSE_OPERAND (c
, 0) = expr
;
17724 tree tc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
17725 OMP_CLAUSE_FIRSTPRIVATE
);
17726 OMP_CLAUSE_DECL (tc
) = tmp
;
17727 OMP_CLAUSE_CHAIN (tc
) = OMP_TARGET_CLAUSES (t
);
17728 OMP_TARGET_CLAUSES (t
) = tc
;
17737 tmp
= tsubst_omp_clauses (OACC_DECLARE_CLAUSES (t
), C_ORT_ACC
, args
,
17738 complain
, in_decl
);
17739 OACC_DECLARE_CLAUSES (t
) = tmp
;
17743 case OMP_TARGET_UPDATE
:
17744 case OMP_TARGET_ENTER_DATA
:
17745 case OMP_TARGET_EXIT_DATA
:
17746 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_OMP
, args
,
17747 complain
, in_decl
);
17749 OMP_STANDALONE_CLAUSES (t
) = tmp
;
17753 case OACC_ENTER_DATA
:
17754 case OACC_EXIT_DATA
:
17756 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_ACC
, args
,
17757 complain
, in_decl
);
17759 OMP_STANDALONE_CLAUSES (t
) = tmp
;
17764 tmp
= tsubst_omp_clauses (OMP_ORDERED_CLAUSES (t
), C_ORT_OMP
, args
,
17765 complain
, in_decl
);
17766 stmt
= push_stmt_list ();
17767 RECUR (OMP_BODY (t
));
17768 stmt
= pop_stmt_list (stmt
);
17771 OMP_BODY (t
) = stmt
;
17772 OMP_ORDERED_CLAUSES (t
) = tmp
;
17778 stmt
= push_stmt_list ();
17779 RECUR (OMP_BODY (t
));
17780 stmt
= pop_stmt_list (stmt
);
17783 OMP_BODY (t
) = stmt
;
17788 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
17790 if (TREE_CODE (TREE_OPERAND (t
, 0)) == OMP_CLAUSE
)
17791 tmp
= tsubst_omp_clauses (TREE_OPERAND (t
, 0), C_ORT_OMP
, args
,
17792 complain
, in_decl
);
17793 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
17795 tree op1
= TREE_OPERAND (t
, 1);
17796 tree rhs1
= NULL_TREE
;
17798 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
17800 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
17801 op1
= TREE_OPERAND (op1
, 1);
17803 lhs
= RECUR (TREE_OPERAND (op1
, 0));
17804 rhs
= RECUR (TREE_OPERAND (op1
, 1));
17805 finish_omp_atomic (EXPR_LOCATION (t
), OMP_ATOMIC
, TREE_CODE (op1
),
17806 lhs
, rhs
, NULL_TREE
, NULL_TREE
, rhs1
, tmp
,
17807 OMP_ATOMIC_MEMORY_ORDER (t
));
17811 tree op1
= TREE_OPERAND (t
, 1);
17812 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
17813 tree rhs1
= NULL_TREE
;
17814 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
17815 enum tree_code opcode
= NOP_EXPR
;
17816 if (code
== OMP_ATOMIC_READ
)
17818 v
= RECUR (TREE_OPERAND (op1
, 0));
17819 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
17821 else if (code
== OMP_ATOMIC_CAPTURE_OLD
17822 || code
== OMP_ATOMIC_CAPTURE_NEW
)
17824 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
17825 v
= RECUR (TREE_OPERAND (op1
, 0));
17826 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
17827 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
17829 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
17830 op11
= TREE_OPERAND (op11
, 1);
17832 lhs
= RECUR (TREE_OPERAND (op11
, 0));
17833 rhs
= RECUR (TREE_OPERAND (op11
, 1));
17834 opcode
= TREE_CODE (op11
);
17835 if (opcode
== MODIFY_EXPR
)
17841 lhs
= RECUR (TREE_OPERAND (op1
, 0));
17842 rhs
= RECUR (TREE_OPERAND (op1
, 1));
17844 finish_omp_atomic (EXPR_LOCATION (t
), code
, opcode
, lhs
, rhs
, v
,
17845 lhs1
, rhs1
, tmp
, OMP_ATOMIC_MEMORY_ORDER (t
));
17849 case TRANSACTION_EXPR
:
17852 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
17853 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
17855 if (TRANSACTION_EXPR_IS_STMT (t
))
17857 tree body
= TRANSACTION_EXPR_BODY (t
);
17858 tree noex
= NULL_TREE
;
17859 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
17861 noex
= MUST_NOT_THROW_COND (body
);
17862 if (noex
== NULL_TREE
)
17863 noex
= boolean_true_node
;
17864 body
= TREE_OPERAND (body
, 0);
17866 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
17868 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
17872 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
17873 RECUR (TRANSACTION_EXPR_BODY (t
)),
17880 case MUST_NOT_THROW_EXPR
:
17882 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17883 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
17884 RETURN (build_must_not_throw_expr (op0
, cond
));
17887 case EXPR_PACK_EXPANSION
:
17888 error ("invalid use of pack expansion expression");
17889 RETURN (error_mark_node
);
17891 case NONTYPE_ARGUMENT_PACK
:
17892 error ("use %<...%> to expand argument pack");
17893 RETURN (error_mark_node
);
17895 case COMPOUND_EXPR
:
17896 tmp
= RECUR (TREE_OPERAND (t
, 0));
17897 if (tmp
== NULL_TREE
)
17898 /* If the first operand was a statement, we're done with it. */
17899 RETURN (RECUR (TREE_OPERAND (t
, 1)));
17900 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
17901 RECUR (TREE_OPERAND (t
, 1)),
17904 case ANNOTATE_EXPR
:
17905 tmp
= RECUR (TREE_OPERAND (t
, 0));
17906 RETURN (build3_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
17907 TREE_TYPE (tmp
), tmp
,
17908 RECUR (TREE_OPERAND (t
, 1)),
17909 RECUR (TREE_OPERAND (t
, 2))));
17912 RETURN (add_stmt (copy_node (t
)));
17915 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
17917 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
17918 /*function_p=*/false,
17919 integral_constant_expression_p
));
17922 RETURN (NULL_TREE
);
17924 input_location
= loc
;
17930 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
17931 function. For description of the body see comment above
17932 cp_parser_omp_declare_reduction_exprs. */
17935 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
17937 if (t
== NULL_TREE
|| t
== error_mark_node
)
17940 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
17942 tree_stmt_iterator tsi
;
17945 memset (stmts
, 0, sizeof stmts
);
17946 for (i
= 0, tsi
= tsi_start (t
);
17947 i
< 7 && !tsi_end_p (tsi
);
17948 i
++, tsi_next (&tsi
))
17949 stmts
[i
] = tsi_stmt (tsi
);
17950 gcc_assert (tsi_end_p (tsi
));
17954 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
17955 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
17956 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
17957 args
, complain
, in_decl
);
17958 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
17959 args
, complain
, in_decl
);
17960 DECL_CONTEXT (omp_out
) = current_function_decl
;
17961 DECL_CONTEXT (omp_in
) = current_function_decl
;
17962 keep_next_level (true);
17963 tree block
= begin_omp_structured_block ();
17964 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
17965 block
= finish_omp_structured_block (block
);
17966 block
= maybe_cleanup_point_expr_void (block
);
17967 add_decl_expr (omp_out
);
17968 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
17969 TREE_NO_WARNING (omp_out
) = 1;
17970 add_decl_expr (omp_in
);
17971 finish_expr_stmt (block
);
17975 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
17976 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
17977 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
17978 args
, complain
, in_decl
);
17979 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
17980 args
, complain
, in_decl
);
17981 DECL_CONTEXT (omp_priv
) = current_function_decl
;
17982 DECL_CONTEXT (omp_orig
) = current_function_decl
;
17983 keep_next_level (true);
17984 tree block
= begin_omp_structured_block ();
17985 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
17986 block
= finish_omp_structured_block (block
);
17987 block
= maybe_cleanup_point_expr_void (block
);
17988 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
17989 add_decl_expr (omp_priv
);
17990 add_decl_expr (omp_orig
);
17991 finish_expr_stmt (block
);
17993 add_decl_expr (omp_orig
);
17997 /* T is a postfix-expression that is not being used in a function
17998 call. Return the substituted version of T. */
18001 tsubst_non_call_postfix_expression (tree t
, tree args
,
18002 tsubst_flags_t complain
,
18005 if (TREE_CODE (t
) == SCOPE_REF
)
18006 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
18007 /*done=*/false, /*address_p=*/false);
18009 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
18010 /*function_p=*/false,
18011 /*integral_constant_expression_p=*/false);
18016 /* T is a LAMBDA_EXPR. Generate a new LAMBDA_EXPR for the current
18017 instantiation context. Instantiating a pack expansion containing a lambda
18018 might result in multiple lambdas all based on the same lambda in the
18022 tsubst_lambda_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
18024 tree oldfn
= lambda_function (t
);
18027 /* If we have already specialized this lambda expr, reuse it. See
18029 if (local_specializations
)
18030 if (tree r
= retrieve_local_specialization (t
))
18033 tree r
= build_lambda_expr ();
18035 if (local_specializations
)
18036 register_local_specialization (r
, t
);
18038 LAMBDA_EXPR_LOCATION (r
)
18039 = LAMBDA_EXPR_LOCATION (t
);
18040 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
18041 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
18042 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
18043 LAMBDA_EXPR_INSTANTIATED (r
) = true;
18045 if (LAMBDA_EXPR_EXTRA_SCOPE (t
) == NULL_TREE
)
18046 /* A lambda in a default argument outside a class gets no
18047 LAMBDA_EXPR_EXTRA_SCOPE, as specified by the ABI. But
18048 tsubst_default_argument calls start_lambda_scope, so we need to
18049 specifically ignore it here, and use the global scope. */
18050 record_null_lambda_scope (r
);
18052 record_lambda_scope (r
);
18054 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
18055 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
18057 vec
<tree
,va_gc
>* field_packs
= NULL
;
18059 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
); cap
;
18060 cap
= TREE_CHAIN (cap
))
18062 tree ofield
= TREE_PURPOSE (cap
);
18063 if (PACK_EXPANSION_P (ofield
))
18064 ofield
= PACK_EXPANSION_PATTERN (ofield
);
18065 tree field
= tsubst_decl (ofield
, args
, complain
);
18067 if (DECL_PACK_P (ofield
) && !DECL_NORMAL_CAPTURE_P (ofield
))
18069 /* Remember these for when we've pushed local_specializations. */
18070 vec_safe_push (field_packs
, ofield
);
18071 vec_safe_push (field_packs
, field
);
18074 if (field
== error_mark_node
)
18075 return error_mark_node
;
18077 tree init
= TREE_VALUE (cap
);
18078 if (PACK_EXPANSION_P (init
))
18079 init
= tsubst_pack_expansion (init
, args
, complain
, in_decl
);
18081 init
= tsubst_copy_and_build (init
, args
, complain
, in_decl
,
18082 /*fn*/false, /*constexpr*/false);
18084 if (TREE_CODE (field
) == TREE_VEC
)
18086 int len
= TREE_VEC_LENGTH (field
);
18087 gcc_assert (TREE_CODE (init
) == TREE_VEC
18088 && TREE_VEC_LENGTH (init
) == len
);
18089 for (int i
= 0; i
< len
; ++i
)
18090 LAMBDA_EXPR_CAPTURE_LIST (r
)
18091 = tree_cons (TREE_VEC_ELT (field
, i
),
18092 TREE_VEC_ELT (init
, i
),
18093 LAMBDA_EXPR_CAPTURE_LIST (r
));
18097 LAMBDA_EXPR_CAPTURE_LIST (r
)
18098 = tree_cons (field
, init
, LAMBDA_EXPR_CAPTURE_LIST (r
));
18100 if (id_equal (DECL_NAME (field
), "__this"))
18101 LAMBDA_EXPR_THIS_CAPTURE (r
) = field
;
18105 tree type
= begin_lambda_type (r
);
18106 if (type
== error_mark_node
)
18107 return error_mark_node
;
18109 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
18110 determine_visibility (TYPE_NAME (type
));
18112 register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (r
));
18114 tree oldtmpl
= (generic_lambda_fn_p (oldfn
)
18115 ? DECL_TI_TEMPLATE (oldfn
)
18118 tree fntype
= static_fn_type (oldfn
);
18120 ++processing_template_decl
;
18121 fntype
= tsubst (fntype
, args
, complain
, in_decl
);
18123 --processing_template_decl
;
18125 if (fntype
== error_mark_node
)
18126 r
= error_mark_node
;
18129 /* The body of a lambda-expression is not a subexpression of the
18130 enclosing expression. Parms are to have DECL_CHAIN tsubsted,
18131 which would be skipped if cp_unevaluated_operand. */
18134 /* Fix the type of 'this'. */
18135 fntype
= build_memfn_type (fntype
, type
,
18136 type_memfn_quals (fntype
),
18137 type_memfn_rqual (fntype
));
18141 tmpl
= tsubst_template_decl (oldtmpl
, args
, complain
, fntype
);
18142 fn
= DECL_TEMPLATE_RESULT (tmpl
);
18143 finish_member_declaration (tmpl
);
18148 fn
= tsubst_function_decl (oldfn
, args
, complain
, fntype
);
18149 finish_member_declaration (fn
);
18152 /* Let finish_function set this. */
18153 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
18155 bool nested
= cfun
;
18157 push_function_context ();
18159 /* Still increment function_depth so that we don't GC in the
18160 middle of an expression. */
18163 local_specialization_stack
s (lss_copy
);
18165 tree body
= start_lambda_function (fn
, r
);
18167 /* Now record them for lookup_init_capture_pack. */
18168 int fplen
= vec_safe_length (field_packs
);
18169 for (int i
= 0; i
< fplen
; )
18171 tree pack
= (*field_packs
)[i
++];
18172 tree inst
= (*field_packs
)[i
++];
18173 register_local_specialization (inst
, pack
);
18175 release_tree_vector (field_packs
);
18177 register_parameter_specializations (oldfn
, fn
);
18181 /* We might not partially instantiate some parts of the function, so
18182 copy these flags from the original template. */
18183 language_function
*ol
= DECL_STRUCT_FUNCTION (oldfn
)->language
;
18184 current_function_returns_value
= ol
->returns_value
;
18185 current_function_returns_null
= ol
->returns_null
;
18186 current_function_returns_abnormally
= ol
->returns_abnormally
;
18187 current_function_infinite_loop
= ol
->infinite_loop
;
18190 /* [temp.deduct] A lambda-expression appearing in a function type or a
18191 template parameter is not considered part of the immediate context for
18192 the purposes of template argument deduction. */
18193 complain
= tf_warning_or_error
;
18195 tsubst_expr (DECL_SAVED_TREE (oldfn
), args
, complain
, r
,
18196 /*constexpr*/false);
18198 finish_lambda_function (body
);
18201 pop_function_context ();
18205 /* The capture list was built up in reverse order; fix that now. */
18206 LAMBDA_EXPR_CAPTURE_LIST (r
)
18207 = nreverse (LAMBDA_EXPR_CAPTURE_LIST (r
));
18209 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
18211 maybe_add_lambda_conv_op (type
);
18214 finish_struct (type
, /*attr*/NULL_TREE
);
18216 insert_pending_capture_proxies ();
18221 /* Like tsubst but deals with expressions and performs semantic
18222 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
18225 tsubst_copy_and_build (tree t
,
18227 tsubst_flags_t complain
,
18230 bool integral_constant_expression_p
)
18232 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
18233 #define RECUR(NODE) \
18234 tsubst_copy_and_build (NODE, args, complain, in_decl, \
18235 /*function_p=*/false, \
18236 integral_constant_expression_p)
18241 if (t
== NULL_TREE
|| t
== error_mark_node
)
18244 loc
= input_location
;
18245 if (location_t eloc
= cp_expr_location (t
))
18246 input_location
= eloc
;
18248 /* N3276 decltype magic only applies to calls at the top level or on the
18249 right side of a comma. */
18250 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
18251 complain
&= ~tf_decltype
;
18253 switch (TREE_CODE (t
))
18257 /* Fall through. */
18258 case IDENTIFIER_NODE
:
18262 bool non_integral_constant_expression_p
;
18263 const char *error_msg
;
18265 if (IDENTIFIER_CONV_OP_P (t
))
18267 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18268 t
= make_conv_op_name (new_type
);
18271 /* Look up the name. */
18272 decl
= lookup_name (t
);
18274 /* By convention, expressions use ERROR_MARK_NODE to indicate
18275 failure, not NULL_TREE. */
18276 if (decl
== NULL_TREE
)
18277 decl
= error_mark_node
;
18279 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
18281 integral_constant_expression_p
,
18282 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
18283 &non_integral_constant_expression_p
,
18284 /*template_p=*/false,
18286 /*address_p=*/false,
18287 /*template_arg_p=*/false,
18292 if (!function_p
&& identifier_p (decl
))
18294 if (complain
& tf_error
)
18295 unqualified_name_lookup_error (decl
);
18296 decl
= error_mark_node
;
18301 case TEMPLATE_ID_EXPR
:
18304 tree templ
= RECUR (TREE_OPERAND (t
, 0));
18305 tree targs
= TREE_OPERAND (t
, 1);
18308 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
18309 if (targs
== error_mark_node
)
18310 RETURN (error_mark_node
);
18312 if (TREE_CODE (templ
) == SCOPE_REF
)
18314 tree name
= TREE_OPERAND (templ
, 1);
18315 tree tid
= lookup_template_function (name
, targs
);
18316 TREE_OPERAND (templ
, 1) = tid
;
18320 if (variable_template_p (templ
))
18321 RETURN (lookup_and_finish_template_variable (templ
, targs
, complain
));
18323 if (TREE_CODE (templ
) == COMPONENT_REF
)
18325 object
= TREE_OPERAND (templ
, 0);
18326 templ
= TREE_OPERAND (templ
, 1);
18329 object
= NULL_TREE
;
18330 templ
= lookup_template_function (templ
, targs
);
18333 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
18334 object
, templ
, NULL_TREE
));
18336 RETURN (baselink_for_fns (templ
));
18341 tree r
= RECUR (TREE_OPERAND (t
, 0));
18343 if (REFERENCE_REF_P (t
))
18345 /* A type conversion to reference type will be enclosed in
18346 such an indirect ref, but the substitution of the cast
18347 will have also added such an indirect ref. */
18348 r
= convert_from_reference (r
);
18351 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
18352 complain
|decltype_flag
);
18354 if (REF_PARENTHESIZED_P (t
))
18355 r
= force_paren_expr (r
);
18362 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18363 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18364 RETURN (build_nop (type
, op0
));
18367 case IMPLICIT_CONV_EXPR
:
18369 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18370 tree expr
= RECUR (TREE_OPERAND (t
, 0));
18371 if (dependent_type_p (type
) || type_dependent_expression_p (expr
))
18373 retval
= copy_node (t
);
18374 TREE_TYPE (retval
) = type
;
18375 TREE_OPERAND (retval
, 0) = expr
;
18378 if (IMPLICIT_CONV_EXPR_NONTYPE_ARG (t
))
18379 /* We'll pass this to convert_nontype_argument again, we don't need
18380 to actually perform any conversion here. */
18382 int flags
= LOOKUP_IMPLICIT
;
18383 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
18384 flags
= LOOKUP_NORMAL
;
18385 if (IMPLICIT_CONV_EXPR_BRACED_INIT (t
))
18386 flags
|= LOOKUP_NO_NARROWING
;
18387 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
18393 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18394 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18395 if (op0
== error_mark_node
)
18396 RETURN (error_mark_node
);
18397 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
18401 case REINTERPRET_CAST_EXPR
:
18402 case CONST_CAST_EXPR
:
18403 case DYNAMIC_CAST_EXPR
:
18404 case STATIC_CAST_EXPR
:
18407 tree op
, r
= NULL_TREE
;
18409 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18410 if (integral_constant_expression_p
18411 && !cast_valid_in_integral_constant_expression_p (type
))
18413 if (complain
& tf_error
)
18414 error ("a cast to a type other than an integral or "
18415 "enumeration type cannot appear in a constant-expression");
18416 RETURN (error_mark_node
);
18419 op
= RECUR (TREE_OPERAND (t
, 0));
18421 warning_sentinel
s(warn_useless_cast
);
18422 warning_sentinel
s2(warn_ignored_qualifiers
);
18423 switch (TREE_CODE (t
))
18426 r
= build_functional_cast (type
, op
, complain
);
18428 case REINTERPRET_CAST_EXPR
:
18429 r
= build_reinterpret_cast (type
, op
, complain
);
18431 case CONST_CAST_EXPR
:
18432 r
= build_const_cast (type
, op
, complain
);
18434 case DYNAMIC_CAST_EXPR
:
18435 r
= build_dynamic_cast (type
, op
, complain
);
18437 case STATIC_CAST_EXPR
:
18438 r
= build_static_cast (type
, op
, complain
);
18441 gcc_unreachable ();
18447 case POSTDECREMENT_EXPR
:
18448 case POSTINCREMENT_EXPR
:
18449 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
18450 args
, complain
, in_decl
);
18451 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
18452 complain
|decltype_flag
));
18454 case PREDECREMENT_EXPR
:
18455 case PREINCREMENT_EXPR
:
18459 case TRUTH_NOT_EXPR
:
18460 case UNARY_PLUS_EXPR
: /* Unary + */
18461 case REALPART_EXPR
:
18462 case IMAGPART_EXPR
:
18463 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
18464 RECUR (TREE_OPERAND (t
, 0)),
18465 complain
|decltype_flag
));
18467 case FIX_TRUNC_EXPR
:
18468 gcc_unreachable ();
18471 op1
= TREE_OPERAND (t
, 0);
18472 if (TREE_CODE (op1
) == LABEL_DECL
)
18473 RETURN (finish_label_address_expr (DECL_NAME (op1
),
18474 EXPR_LOCATION (op1
)));
18475 if (TREE_CODE (op1
) == SCOPE_REF
)
18476 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
18477 /*done=*/true, /*address_p=*/true);
18479 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
18481 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
18482 complain
|decltype_flag
));
18487 case TRUNC_DIV_EXPR
:
18488 case CEIL_DIV_EXPR
:
18489 case FLOOR_DIV_EXPR
:
18490 case ROUND_DIV_EXPR
:
18491 case EXACT_DIV_EXPR
:
18495 case TRUNC_MOD_EXPR
:
18496 case FLOOR_MOD_EXPR
:
18497 case TRUTH_ANDIF_EXPR
:
18498 case TRUTH_ORIF_EXPR
:
18499 case TRUTH_AND_EXPR
:
18500 case TRUTH_OR_EXPR
:
18516 warning_sentinel
s1(warn_type_limits
);
18517 warning_sentinel
s2(warn_div_by_zero
);
18518 warning_sentinel
s3(warn_logical_op
);
18519 warning_sentinel
s4(warn_tautological_compare
);
18520 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18521 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18522 tree r
= build_x_binary_op
18523 (input_location
, TREE_CODE (t
),
18525 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
18527 : TREE_CODE (TREE_OPERAND (t
, 0))),
18529 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
18531 : TREE_CODE (TREE_OPERAND (t
, 1))),
18533 complain
|decltype_flag
);
18534 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
18535 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
18540 case POINTER_PLUS_EXPR
:
18542 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18543 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18544 RETURN (fold_build_pointer_plus (op0
, op1
));
18548 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
18549 /*address_p=*/false));
18551 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
18552 args
, complain
, in_decl
);
18553 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
18554 RECUR (TREE_OPERAND (t
, 1)),
18555 complain
|decltype_flag
));
18558 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
18559 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
18560 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
18567 op1
= TREE_OPERAND (t
, 0);
18568 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
18569 op1
= TREE_TYPE (op1
);
18570 bool std_alignof
= (TREE_CODE (t
) == ALIGNOF_EXPR
18571 && ALIGNOF_EXPR_STD_P (t
));
18574 /* When there are no ARGS, we are trying to evaluate a
18575 non-dependent expression from the parser. Trying to do
18576 the substitutions may not work. */
18578 op1
= TREE_TYPE (op1
);
18582 ++cp_unevaluated_operand
;
18583 ++c_inhibit_evaluation_warnings
;
18585 op1
= tsubst (op1
, args
, complain
, in_decl
);
18587 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
18588 /*function_p=*/false,
18589 /*integral_constant_expression_p=*/
18591 --cp_unevaluated_operand
;
18592 --c_inhibit_evaluation_warnings
;
18595 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
), std_alignof
,
18596 complain
& tf_error
);
18598 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
18599 complain
& tf_error
);
18600 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
18602 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
18604 if (!processing_template_decl
&& TYPE_P (op1
))
18606 r
= build_min (SIZEOF_EXPR
, size_type_node
,
18607 build1 (NOP_EXPR
, op1
, error_mark_node
));
18608 SIZEOF_EXPR_TYPE_P (r
) = 1;
18611 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
18612 TREE_SIDE_EFFECTS (r
) = 0;
18613 TREE_READONLY (r
) = 1;
18615 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
18620 case AT_ENCODE_EXPR
:
18622 op1
= TREE_OPERAND (t
, 0);
18623 ++cp_unevaluated_operand
;
18624 ++c_inhibit_evaluation_warnings
;
18625 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
18626 /*function_p=*/false,
18627 /*integral_constant_expression_p=*/false);
18628 --cp_unevaluated_operand
;
18629 --c_inhibit_evaluation_warnings
;
18630 RETURN (objc_build_encode_expr (op1
));
18633 case NOEXCEPT_EXPR
:
18634 op1
= TREE_OPERAND (t
, 0);
18635 ++cp_unevaluated_operand
;
18636 ++c_inhibit_evaluation_warnings
;
18637 ++cp_noexcept_operand
;
18638 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
18639 /*function_p=*/false,
18640 /*integral_constant_expression_p=*/false);
18641 --cp_unevaluated_operand
;
18642 --c_inhibit_evaluation_warnings
;
18643 --cp_noexcept_operand
;
18644 RETURN (finish_noexcept_expr (op1
, complain
));
18648 warning_sentinel
s(warn_div_by_zero
);
18649 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
18650 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
18651 tree r
= build_x_modify_expr
18652 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
18653 complain
|decltype_flag
);
18654 /* TREE_NO_WARNING must be set if either the expression was
18655 parenthesized or it uses an operator such as >>= rather
18656 than plain assignment. In the former case, it was already
18657 set and must be copied. In the latter case,
18658 build_x_modify_expr sets it and it must not be reset
18660 if (TREE_NO_WARNING (t
))
18661 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
18667 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
18668 args
, complain
, in_decl
);
18669 /* Remember that there was a reference to this entity. */
18671 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
18672 RETURN (error_mark_node
);
18673 RETURN (build_x_arrow (input_location
, op1
, complain
));
18677 tree placement
= RECUR (TREE_OPERAND (t
, 0));
18678 tree init
= RECUR (TREE_OPERAND (t
, 3));
18679 vec
<tree
, va_gc
> *placement_vec
;
18680 vec
<tree
, va_gc
> *init_vec
;
18683 if (placement
== NULL_TREE
)
18684 placement_vec
= NULL
;
18687 placement_vec
= make_tree_vector ();
18688 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
18689 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
18692 /* If there was an initializer in the original tree, but it
18693 instantiated to an empty list, then we should pass a
18694 non-NULL empty vector to tell build_new that it was an
18695 empty initializer() rather than no initializer. This can
18696 only happen when the initializer is a pack expansion whose
18697 parameter packs are of length zero. */
18698 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
18702 init_vec
= make_tree_vector ();
18703 if (init
== void_node
)
18704 gcc_assert (init_vec
!= NULL
);
18707 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
18708 vec_safe_push (init_vec
, TREE_VALUE (init
));
18712 /* Avoid passing an enclosing decl to valid_array_size_p. */
18713 in_decl
= NULL_TREE
;
18715 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
18716 tree op2
= RECUR (TREE_OPERAND (t
, 2));
18717 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
18718 NEW_EXPR_USE_GLOBAL (t
),
18721 if (placement_vec
!= NULL
)
18722 release_tree_vector (placement_vec
);
18723 if (init_vec
!= NULL
)
18724 release_tree_vector (init_vec
);
18731 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18732 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18733 RETURN (delete_sanity (op0
, op1
,
18734 DELETE_EXPR_USE_VEC (t
),
18735 DELETE_EXPR_USE_GLOBAL (t
),
18739 case COMPOUND_EXPR
:
18741 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
18742 complain
& ~tf_decltype
, in_decl
,
18743 /*function_p=*/false,
18744 integral_constant_expression_p
);
18745 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
18747 RECUR (TREE_OPERAND (t
, 1)),
18748 complain
|decltype_flag
));
18754 vec
<tree
, va_gc
> *call_args
;
18755 unsigned int nargs
, i
;
18760 function
= CALL_EXPR_FN (t
);
18761 /* Internal function with no arguments. */
18762 if (function
== NULL_TREE
&& call_expr_nargs (t
) == 0)
18765 /* When we parsed the expression, we determined whether or
18766 not Koenig lookup should be performed. */
18767 koenig_p
= KOENIG_LOOKUP_P (t
);
18768 if (function
== NULL_TREE
)
18771 qualified_p
= false;
18773 else if (TREE_CODE (function
) == SCOPE_REF
)
18775 qualified_p
= true;
18776 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
18778 /*address_p=*/false);
18780 else if (koenig_p
&& identifier_p (function
))
18782 /* Do nothing; calling tsubst_copy_and_build on an identifier
18783 would incorrectly perform unqualified lookup again.
18785 Note that we can also have an IDENTIFIER_NODE if the earlier
18786 unqualified lookup found a member function; in that case
18787 koenig_p will be false and we do want to do the lookup
18788 again to find the instantiated member function.
18790 FIXME but doing that causes c++/15272, so we need to stop
18791 using IDENTIFIER_NODE in that situation. */
18792 qualified_p
= false;
18796 if (TREE_CODE (function
) == COMPONENT_REF
)
18798 tree op
= TREE_OPERAND (function
, 1);
18800 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
18801 || (BASELINK_P (op
)
18802 && BASELINK_QUALIFIED_P (op
)));
18805 qualified_p
= false;
18807 if (TREE_CODE (function
) == ADDR_EXPR
18808 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
18809 /* Avoid error about taking the address of a constructor. */
18810 function
= TREE_OPERAND (function
, 0);
18812 function
= tsubst_copy_and_build (function
, args
, complain
,
18815 integral_constant_expression_p
);
18817 if (BASELINK_P (function
))
18818 qualified_p
= true;
18821 nargs
= call_expr_nargs (t
);
18822 call_args
= make_tree_vector ();
18823 for (i
= 0; i
< nargs
; ++i
)
18825 tree arg
= CALL_EXPR_ARG (t
, i
);
18827 if (!PACK_EXPANSION_P (arg
))
18828 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
18831 /* Expand the pack expansion and push each entry onto
18833 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
18834 if (TREE_CODE (arg
) == TREE_VEC
)
18836 unsigned int len
, j
;
18838 len
= TREE_VEC_LENGTH (arg
);
18839 for (j
= 0; j
< len
; ++j
)
18841 tree value
= TREE_VEC_ELT (arg
, j
);
18842 if (value
!= NULL_TREE
)
18843 value
= convert_from_reference (value
);
18844 vec_safe_push (call_args
, value
);
18849 /* A partial substitution. Add one entry. */
18850 vec_safe_push (call_args
, arg
);
18855 /* Stripped-down processing for a call in a thunk. Specifically, in
18856 the thunk template for a generic lambda. */
18857 if (CALL_FROM_THUNK_P (t
))
18859 tree thisarg
= NULL_TREE
;
18860 if (TREE_CODE (function
) == COMPONENT_REF
)
18862 thisarg
= TREE_OPERAND (function
, 0);
18863 if (TREE_CODE (thisarg
) == INDIRECT_REF
)
18864 thisarg
= TREE_OPERAND (thisarg
, 0);
18865 function
= TREE_OPERAND (function
, 1);
18866 if (TREE_CODE (function
) == BASELINK
)
18867 function
= BASELINK_FUNCTIONS (function
);
18869 /* We aren't going to do normal overload resolution, so force the
18870 template-id to resolve. */
18871 function
= resolve_nondeduced_context (function
, complain
);
18872 for (unsigned i
= 0; i
< nargs
; ++i
)
18874 /* In a thunk, pass through args directly, without any
18876 tree arg
= (*call_args
)[i
];
18877 while (TREE_CODE (arg
) != PARM_DECL
)
18878 arg
= TREE_OPERAND (arg
, 0);
18879 (*call_args
)[i
] = arg
;
18883 /* Shift the other args over to make room. */
18884 vec_safe_push (call_args
, (*call_args
)[nargs
-1]);
18885 for (int i
= nargs
-1; i
> 0; --i
)
18886 (*call_args
)[i
] = (*call_args
)[i
-1];
18887 (*call_args
)[0] = thisarg
;
18889 ret
= build_call_a (function
, call_args
->length (),
18890 call_args
->address ());
18891 /* The thunk location is not interesting. */
18892 SET_EXPR_LOCATION (ret
, UNKNOWN_LOCATION
);
18893 CALL_FROM_THUNK_P (ret
) = true;
18894 if (CLASS_TYPE_P (TREE_TYPE (ret
)))
18895 CALL_EXPR_RETURN_SLOT_OPT (ret
) = true;
18897 release_tree_vector (call_args
);
18901 /* We do not perform argument-dependent lookup if normal
18902 lookup finds a non-function, in accordance with the
18903 expected resolution of DR 218. */
18905 && ((is_overloaded_fn (function
)
18906 /* If lookup found a member function, the Koenig lookup is
18907 not appropriate, even if an unqualified-name was used
18908 to denote the function. */
18909 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
18910 || identifier_p (function
))
18911 /* Only do this when substitution turns a dependent call
18912 into a non-dependent call. */
18913 && type_dependent_expression_p_push (t
)
18914 && !any_type_dependent_arguments_p (call_args
))
18915 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
18917 if (function
!= NULL_TREE
18918 && identifier_p (function
)
18919 && !any_type_dependent_arguments_p (call_args
))
18921 if (koenig_p
&& (complain
& tf_warning_or_error
))
18923 /* For backwards compatibility and good diagnostics, try
18924 the unqualified lookup again if we aren't in SFINAE
18926 tree unq
= (tsubst_copy_and_build
18927 (function
, args
, complain
, in_decl
, true,
18928 integral_constant_expression_p
));
18929 if (unq
== error_mark_node
)
18931 release_tree_vector (call_args
);
18932 RETURN (error_mark_node
);
18935 if (unq
!= function
)
18937 /* In a lambda fn, we have to be careful to not
18938 introduce new this captures. Legacy code can't
18939 be using lambdas anyway, so it's ok to be
18941 bool in_lambda
= (current_class_type
18942 && LAMBDA_TYPE_P (current_class_type
));
18943 char const *const msg
18944 = G_("%qD was not declared in this scope, "
18945 "and no declarations were found by "
18946 "argument-dependent lookup at the point "
18947 "of instantiation");
18951 error_at (cp_expr_loc_or_loc (t
, input_location
),
18954 diag
= permerror (cp_expr_loc_or_loc (t
, input_location
),
18960 if (INDIRECT_REF_P (fn
))
18961 fn
= TREE_OPERAND (fn
, 0);
18962 if (is_overloaded_fn (fn
))
18963 fn
= get_first_fn (fn
);
18966 /* Can't say anything more. */;
18967 else if (DECL_CLASS_SCOPE_P (fn
))
18969 location_t loc
= cp_expr_loc_or_loc (t
,
18972 "declarations in dependent base %qT are "
18973 "not found by unqualified lookup",
18974 DECL_CLASS_CONTEXT (fn
));
18975 if (current_class_ptr
)
18977 "use %<this->%D%> instead", function
);
18980 "use %<%T::%D%> instead",
18981 current_class_name
, function
);
18984 inform (DECL_SOURCE_LOCATION (fn
),
18985 "%qD declared here, later in the "
18986 "translation unit", fn
);
18989 release_tree_vector (call_args
);
18990 RETURN (error_mark_node
);
18997 if (identifier_p (function
))
18999 if (complain
& tf_error
)
19000 unqualified_name_lookup_error (function
);
19001 release_tree_vector (call_args
);
19002 RETURN (error_mark_node
);
19006 /* Remember that there was a reference to this entity. */
19007 if (function
!= NULL_TREE
19008 && DECL_P (function
)
19009 && !mark_used (function
, complain
) && !(complain
& tf_error
))
19011 release_tree_vector (call_args
);
19012 RETURN (error_mark_node
);
19015 /* Put back tf_decltype for the actual call. */
19016 complain
|= decltype_flag
;
19018 if (function
== NULL_TREE
)
19019 switch (CALL_EXPR_IFN (t
))
19022 gcc_assert (nargs
== 1);
19023 if (vec_safe_length (call_args
) != 1)
19025 error_at (cp_expr_loc_or_loc (t
, input_location
),
19026 "wrong number of arguments to "
19027 "%<__builtin_launder%>");
19028 ret
= error_mark_node
;
19031 ret
= finish_builtin_launder (cp_expr_loc_or_loc (t
,
19033 (*call_args
)[0], complain
);
19036 case IFN_VEC_CONVERT
:
19037 gcc_assert (nargs
== 1);
19038 if (vec_safe_length (call_args
) != 1)
19040 error_at (cp_expr_loc_or_loc (t
, input_location
),
19041 "wrong number of arguments to "
19042 "%<__builtin_convertvector%>");
19043 ret
= error_mark_node
;
19046 ret
= cp_build_vec_convert ((*call_args
)[0], input_location
,
19047 tsubst (TREE_TYPE (t
), args
,
19048 complain
, in_decl
),
19050 if (TREE_CODE (ret
) == VIEW_CONVERT_EXPR
)
19052 release_tree_vector (call_args
);
19058 /* Unsupported internal function with arguments. */
19059 gcc_unreachable ();
19061 else if (TREE_CODE (function
) == OFFSET_REF
19062 || TREE_CODE (function
) == DOTSTAR_EXPR
19063 || TREE_CODE (function
) == MEMBER_REF
)
19064 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
19066 else if (TREE_CODE (function
) == COMPONENT_REF
)
19068 tree instance
= TREE_OPERAND (function
, 0);
19069 tree fn
= TREE_OPERAND (function
, 1);
19071 if (processing_template_decl
19072 && (type_dependent_expression_p (instance
)
19073 || (!BASELINK_P (fn
)
19074 && TREE_CODE (fn
) != FIELD_DECL
)
19075 || type_dependent_expression_p (fn
)
19076 || any_type_dependent_arguments_p (call_args
)))
19077 ret
= build_min_nt_call_vec (function
, call_args
);
19078 else if (!BASELINK_P (fn
))
19079 ret
= finish_call_expr (function
, &call_args
,
19080 /*disallow_virtual=*/false,
19081 /*koenig_p=*/false,
19084 ret
= (build_new_method_call
19086 &call_args
, NULL_TREE
,
19087 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
19092 ret
= finish_call_expr (function
, &call_args
,
19093 /*disallow_virtual=*/qualified_p
,
19097 release_tree_vector (call_args
);
19099 if (ret
!= error_mark_node
)
19101 bool op
= CALL_EXPR_OPERATOR_SYNTAX (t
);
19102 bool ord
= CALL_EXPR_ORDERED_ARGS (t
);
19103 bool rev
= CALL_EXPR_REVERSE_ARGS (t
);
19104 if (op
|| ord
|| rev
)
19106 function
= extract_call_expr (ret
);
19107 CALL_EXPR_OPERATOR_SYNTAX (function
) = op
;
19108 CALL_EXPR_ORDERED_ARGS (function
) = ord
;
19109 CALL_EXPR_REVERSE_ARGS (function
) = rev
;
19118 tree cond
= RECUR (TREE_OPERAND (t
, 0));
19119 cond
= mark_rvalue_use (cond
);
19120 tree folded_cond
= fold_non_dependent_expr (cond
, complain
);
19123 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
19125 if (integer_zerop (folded_cond
))
19127 ++c_inhibit_evaluation_warnings
;
19128 exp1
= RECUR (TREE_OPERAND (t
, 1));
19129 --c_inhibit_evaluation_warnings
;
19130 exp2
= RECUR (TREE_OPERAND (t
, 2));
19134 exp1
= RECUR (TREE_OPERAND (t
, 1));
19135 ++c_inhibit_evaluation_warnings
;
19136 exp2
= RECUR (TREE_OPERAND (t
, 2));
19137 --c_inhibit_evaluation_warnings
;
19139 cond
= folded_cond
;
19143 exp1
= RECUR (TREE_OPERAND (t
, 1));
19144 exp2
= RECUR (TREE_OPERAND (t
, 2));
19147 warning_sentinel
s(warn_duplicated_branches
);
19148 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
19149 cond
, exp1
, exp2
, complain
));
19152 case PSEUDO_DTOR_EXPR
:
19154 tree op0
= RECUR (TREE_OPERAND (t
, 0));
19155 tree op1
= RECUR (TREE_OPERAND (t
, 1));
19156 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
19157 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
19163 tree purpose
, value
, chain
;
19165 if (t
== void_list_node
)
19168 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
19169 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
19171 /* We have pack expansions, so expand those and
19172 create a new list out of it. */
19173 tree purposevec
= NULL_TREE
;
19174 tree valuevec
= NULL_TREE
;
19178 /* Expand the argument expressions. */
19179 if (TREE_PURPOSE (t
))
19180 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
19181 complain
, in_decl
);
19182 if (TREE_VALUE (t
))
19183 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
19184 complain
, in_decl
);
19186 /* Build the rest of the list. */
19187 chain
= TREE_CHAIN (t
);
19188 if (chain
&& chain
!= void_type_node
)
19189 chain
= RECUR (chain
);
19191 /* Determine the number of arguments. */
19192 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
19194 len
= TREE_VEC_LENGTH (purposevec
);
19195 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
19197 else if (TREE_CODE (valuevec
) == TREE_VEC
)
19198 len
= TREE_VEC_LENGTH (valuevec
);
19201 /* Since we only performed a partial substitution into
19202 the argument pack, we only RETURN (a single list
19204 if (purposevec
== TREE_PURPOSE (t
)
19205 && valuevec
== TREE_VALUE (t
)
19206 && chain
== TREE_CHAIN (t
))
19209 RETURN (tree_cons (purposevec
, valuevec
, chain
));
19212 /* Convert the argument vectors into a TREE_LIST */
19216 /* Grab the Ith values. */
19218 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
19221 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
19224 /* Build the list (backwards). */
19225 chain
= tree_cons (purpose
, value
, chain
);
19231 purpose
= TREE_PURPOSE (t
);
19233 purpose
= RECUR (purpose
);
19234 value
= TREE_VALUE (t
);
19236 value
= RECUR (value
);
19237 chain
= TREE_CHAIN (t
);
19238 if (chain
&& chain
!= void_type_node
)
19239 chain
= RECUR (chain
);
19240 if (purpose
== TREE_PURPOSE (t
)
19241 && value
== TREE_VALUE (t
)
19242 && chain
== TREE_CHAIN (t
))
19244 RETURN (tree_cons (purpose
, value
, chain
));
19247 case COMPONENT_REF
:
19254 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
19255 args
, complain
, in_decl
);
19256 /* Remember that there was a reference to this entity. */
19257 if (DECL_P (object
)
19258 && !mark_used (object
, complain
) && !(complain
& tf_error
))
19259 RETURN (error_mark_node
);
19260 object_type
= TREE_TYPE (object
);
19262 member
= TREE_OPERAND (t
, 1);
19263 if (BASELINK_P (member
))
19264 member
= tsubst_baselink (member
,
19265 non_reference (TREE_TYPE (object
)),
19266 args
, complain
, in_decl
);
19268 member
= tsubst_copy (member
, args
, complain
, in_decl
);
19269 if (member
== error_mark_node
)
19270 RETURN (error_mark_node
);
19272 if (TREE_CODE (member
) == FIELD_DECL
)
19274 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
19275 if (TREE_CODE (r
) == COMPONENT_REF
)
19276 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
19279 else if (type_dependent_expression_p (object
))
19280 /* We can't do much here. */;
19281 else if (!CLASS_TYPE_P (object_type
))
19283 if (scalarish_type_p (object_type
))
19285 tree s
= NULL_TREE
;
19286 tree dtor
= member
;
19288 if (TREE_CODE (dtor
) == SCOPE_REF
)
19290 s
= TREE_OPERAND (dtor
, 0);
19291 dtor
= TREE_OPERAND (dtor
, 1);
19293 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
19295 dtor
= TREE_OPERAND (dtor
, 0);
19297 RETURN (finish_pseudo_destructor_expr
19298 (object
, s
, dtor
, input_location
));
19302 else if (TREE_CODE (member
) == SCOPE_REF
19303 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
19305 /* Lookup the template functions now that we know what the
19307 tree scope
= TREE_OPERAND (member
, 0);
19308 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
19309 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
19310 member
= lookup_qualified_name (scope
, tmpl
,
19311 /*is_type_p=*/false,
19312 /*complain=*/false);
19313 if (BASELINK_P (member
))
19315 BASELINK_FUNCTIONS (member
)
19316 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
19318 member
= (adjust_result_of_qualified_name_lookup
19319 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
19324 qualified_name_lookup_error (scope
, tmpl
, member
,
19326 RETURN (error_mark_node
);
19329 else if (TREE_CODE (member
) == SCOPE_REF
19330 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
19331 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
19333 if (complain
& tf_error
)
19335 if (TYPE_P (TREE_OPERAND (member
, 0)))
19336 error ("%qT is not a class or namespace",
19337 TREE_OPERAND (member
, 0));
19339 error ("%qD is not a class or namespace",
19340 TREE_OPERAND (member
, 0));
19342 RETURN (error_mark_node
);
19345 r
= finish_class_member_access_expr (object
, member
,
19346 /*template_p=*/false,
19348 if (TREE_CODE (r
) == COMPONENT_REF
)
19349 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
19354 RETURN (build_throw
19355 (RECUR (TREE_OPERAND (t
, 0))));
19359 vec
<constructor_elt
, va_gc
> *n
;
19360 constructor_elt
*ce
;
19361 unsigned HOST_WIDE_INT idx
;
19362 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
19363 bool process_index_p
;
19365 bool need_copy_p
= false;
19368 if (type
== error_mark_node
)
19369 RETURN (error_mark_node
);
19371 /* We do not want to process the index of aggregate
19372 initializers as they are identifier nodes which will be
19373 looked up by digest_init. */
19374 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
19376 if (null_member_pointer_value_p (t
))
19378 gcc_assert (same_type_p (type
, TREE_TYPE (t
)));
19382 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
19383 newlen
= vec_safe_length (n
);
19384 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
19386 if (ce
->index
&& process_index_p
19387 /* An identifier index is looked up in the type
19388 being initialized, not the current scope. */
19389 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
19390 ce
->index
= RECUR (ce
->index
);
19392 if (PACK_EXPANSION_P (ce
->value
))
19394 /* Substitute into the pack expansion. */
19395 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
19398 if (ce
->value
== error_mark_node
19399 || PACK_EXPANSION_P (ce
->value
))
19401 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
19402 /* Just move the argument into place. */
19403 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
19406 /* Update the length of the final CONSTRUCTOR
19407 arguments vector, and note that we will need to
19409 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
19410 need_copy_p
= true;
19414 ce
->value
= RECUR (ce
->value
);
19419 vec
<constructor_elt
, va_gc
> *old_n
= n
;
19421 vec_alloc (n
, newlen
);
19422 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
19424 if (TREE_CODE (ce
->value
) == TREE_VEC
)
19426 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
19427 for (i
= 0; i
< len
; ++i
)
19428 CONSTRUCTOR_APPEND_ELT (n
, 0,
19429 TREE_VEC_ELT (ce
->value
, i
));
19432 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
19436 r
= build_constructor (init_list_type_node
, n
);
19437 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
19438 CONSTRUCTOR_IS_DESIGNATED_INIT (r
)
19439 = CONSTRUCTOR_IS_DESIGNATED_INIT (t
);
19441 if (TREE_HAS_CONSTRUCTOR (t
))
19443 fcl_t cl
= fcl_functional
;
19444 if (CONSTRUCTOR_C99_COMPOUND_LITERAL (t
))
19446 RETURN (finish_compound_literal (type
, r
, complain
, cl
));
19449 TREE_TYPE (r
) = type
;
19455 tree operand_0
= TREE_OPERAND (t
, 0);
19456 if (TYPE_P (operand_0
))
19458 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
19459 RETURN (get_typeid (operand_0
, complain
));
19463 operand_0
= RECUR (operand_0
);
19464 RETURN (build_typeid (operand_0
, complain
));
19475 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
19476 /* ??? We're doing a subset of finish_id_expression here. */
19477 if (tree wrap
= maybe_get_tls_wrapper_call (r
))
19478 /* Replace an evaluated use of the thread_local variable with
19479 a call to its wrapper. */
19481 else if (outer_automatic_var_p (r
))
19482 r
= process_outer_var_ref (r
, complain
);
19484 if (!TYPE_REF_P (TREE_TYPE (t
)))
19485 /* If the original type was a reference, we'll be wrapped in
19486 the appropriate INDIRECT_REF. */
19487 r
= convert_from_reference (r
);
19493 tree op0
= RECUR (TREE_OPERAND (t
, 0));
19494 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
19495 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
19498 case OFFSETOF_EXPR
:
19501 = tsubst_copy_and_build (TREE_OPERAND (t
, 1), args
, complain
,
19502 in_decl
, /*function_p=*/false,
19503 /*integral_constant_expression_p=*/false);
19504 RETURN (finish_offsetof (object_ptr
,
19505 RECUR (TREE_OPERAND (t
, 0)),
19506 EXPR_LOCATION (t
)));
19509 case ADDRESSOF_EXPR
:
19510 RETURN (cp_build_addressof (EXPR_LOCATION (t
),
19511 RECUR (TREE_OPERAND (t
, 0)), complain
));
19515 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
19516 complain
, in_decl
);
19518 tree type2
= TRAIT_EXPR_TYPE2 (t
);
19519 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
19520 type2
= RECUR (type2
);
19522 type2
= tsubst (type2
, args
, complain
, in_decl
);
19524 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
19529 tree old_stmt_expr
= cur_stmt_expr
;
19530 tree stmt_expr
= begin_stmt_expr ();
19532 cur_stmt_expr
= stmt_expr
;
19533 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
19534 integral_constant_expression_p
);
19535 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
19536 cur_stmt_expr
= old_stmt_expr
;
19538 /* If the resulting list of expression statement is empty,
19539 fold it further into void_node. */
19540 if (empty_expr_stmt_p (stmt_expr
))
19541 stmt_expr
= void_node
;
19543 RETURN (stmt_expr
);
19548 if (complain
& tf_partial
)
19550 /* We don't have a full set of template arguments yet; don't touch
19551 the lambda at all. */
19552 gcc_assert (processing_template_decl
);
19555 tree r
= tsubst_lambda_expr (t
, args
, complain
, in_decl
);
19557 RETURN (build_lambda_object (r
));
19561 /* We can get here for a constant initializer of non-dependent type.
19562 FIXME stop folding in cp_parser_initializer_clause. */
19564 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
19569 case TRANSACTION_EXPR
:
19570 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
19571 integral_constant_expression_p
));
19574 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
19576 case VEC_PERM_EXPR
:
19578 tree op0
= RECUR (TREE_OPERAND (t
, 0));
19579 tree op1
= RECUR (TREE_OPERAND (t
, 1));
19580 tree op2
= RECUR (TREE_OPERAND (t
, 2));
19581 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
19585 case REQUIRES_EXPR
:
19586 RETURN (tsubst_requires_expr (t
, args
, complain
, in_decl
));
19589 /* No need to substitute further, a RANGE_EXPR will always be built
19590 with constant operands. */
19593 case NON_LVALUE_EXPR
:
19594 case VIEW_CONVERT_EXPR
:
19595 if (location_wrapper_p (t
))
19596 /* We need to do this here as well as in tsubst_copy so we get the
19597 other tsubst_copy_and_build semantics for a PARM_DECL operand. */
19598 RETURN (maybe_wrap_with_location (RECUR (TREE_OPERAND (t
, 0)),
19599 EXPR_LOCATION (t
)));
19603 /* Handle Objective-C++ constructs, if appropriate. */
19606 = objcp_tsubst_copy_and_build (t
, args
, complain
,
19607 in_decl
, /*function_p=*/false);
19611 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
19617 input_location
= loc
;
19621 /* Verify that the instantiated ARGS are valid. For type arguments,
19622 make sure that the type's linkage is ok. For non-type arguments,
19623 make sure they are constants if they are integral or enumerations.
19624 Emit an error under control of COMPLAIN, and return TRUE on error. */
19627 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
19629 if (dependent_template_arg_p (t
))
19631 if (ARGUMENT_PACK_P (t
))
19633 tree vec
= ARGUMENT_PACK_ARGS (t
);
19634 int len
= TREE_VEC_LENGTH (vec
);
19635 bool result
= false;
19638 for (i
= 0; i
< len
; ++i
)
19639 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
19643 else if (TYPE_P (t
))
19645 /* [basic.link]: A name with no linkage (notably, the name
19646 of a class or enumeration declared in a local scope)
19647 shall not be used to declare an entity with linkage.
19648 This implies that names with no linkage cannot be used as
19651 DR 757 relaxes this restriction for C++0x. */
19652 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
19653 : no_linkage_check (t
, /*relaxed_p=*/false));
19657 /* DR 488 makes use of a type with no linkage cause
19658 type deduction to fail. */
19659 if (complain
& tf_error
)
19661 if (TYPE_UNNAMED_P (nt
))
19662 error ("%qT is/uses unnamed type", t
);
19664 error ("template argument for %qD uses local type %qT",
19669 /* In order to avoid all sorts of complications, we do not
19670 allow variably-modified types as template arguments. */
19671 else if (variably_modified_type_p (t
, NULL_TREE
))
19673 if (complain
& tf_error
)
19674 error ("%qT is a variably modified type", t
);
19678 /* Class template and alias template arguments should be OK. */
19679 else if (DECL_TYPE_TEMPLATE_P (t
))
19681 /* A non-type argument of integral or enumerated type must be a
19683 else if (TREE_TYPE (t
)
19684 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
19685 && !REFERENCE_REF_P (t
)
19686 && !TREE_CONSTANT (t
))
19688 if (complain
& tf_error
)
19689 error ("integral expression %qE is not constant", t
);
19696 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
19698 int ix
, len
= DECL_NTPARMS (tmpl
);
19699 bool result
= false;
19701 for (ix
= 0; ix
!= len
; ix
++)
19703 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
19706 if (result
&& (complain
& tf_error
))
19707 error (" trying to instantiate %qD", tmpl
);
19711 /* We're out of SFINAE context now, so generate diagnostics for the access
19712 errors we saw earlier when instantiating D from TMPL and ARGS. */
19715 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
19717 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19718 tree type
= TREE_TYPE (pattern
);
19719 location_t loc
= input_location
;
19721 push_access_scope (d
);
19722 push_deferring_access_checks (dk_no_deferred
);
19723 input_location
= DECL_SOURCE_LOCATION (pattern
);
19724 tsubst (type
, args
, tf_warning_or_error
, d
);
19725 input_location
= loc
;
19726 pop_deferring_access_checks ();
19727 pop_access_scope (d
);
19730 /* Instantiate the indicated variable, function, or alias template TMPL with
19731 the template arguments in TARG_PTR. */
19734 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
19736 tree targ_ptr
= orig_args
;
19740 bool access_ok
= true;
19742 if (tmpl
== error_mark_node
)
19743 return error_mark_node
;
19745 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
19747 /* If this function is a clone, handle it specially. */
19748 if (DECL_CLONED_FUNCTION_P (tmpl
))
19753 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
19754 DECL_CLONED_FUNCTION. */
19755 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
19756 targ_ptr
, complain
);
19757 if (spec
== error_mark_node
)
19758 return error_mark_node
;
19760 /* Look for the clone. */
19761 FOR_EACH_CLONE (clone
, spec
)
19762 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
19764 /* We should always have found the clone by now. */
19765 gcc_unreachable ();
19769 if (targ_ptr
== error_mark_node
)
19770 return error_mark_node
;
19772 /* Check to see if we already have this specialization. */
19773 gen_tmpl
= most_general_template (tmpl
);
19774 if (TMPL_ARGS_DEPTH (targ_ptr
)
19775 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
)))
19776 /* targ_ptr only has the innermost template args, so add the outer ones
19777 from tmpl, which could be either a partial instantiation or gen_tmpl (in
19778 the case of a non-dependent call within a template definition). */
19779 targ_ptr
= (add_outermost_template_args
19780 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (tmpl
)),
19783 /* It would be nice to avoid hashing here and then again in tsubst_decl,
19784 but it doesn't seem to be on the hot path. */
19785 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
19787 gcc_assert (tmpl
== gen_tmpl
19788 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
19790 || fndecl
== NULL_TREE
);
19792 if (spec
!= NULL_TREE
)
19794 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
19796 if (complain
& tf_error
)
19797 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
19798 return error_mark_node
;
19803 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
19805 return error_mark_node
;
19807 /* We are building a FUNCTION_DECL, during which the access of its
19808 parameters and return types have to be checked. However this
19809 FUNCTION_DECL which is the desired context for access checking
19810 is not built yet. We solve this chicken-and-egg problem by
19811 deferring all checks until we have the FUNCTION_DECL. */
19812 push_deferring_access_checks (dk_deferred
);
19814 /* Instantiation of the function happens in the context of the function
19815 template, not the context of the overload resolution we're doing. */
19816 push_to_top_level ();
19817 /* If there are dependent arguments, e.g. because we're doing partial
19818 ordering, make sure processing_template_decl stays set. */
19819 if (uses_template_parms (targ_ptr
))
19820 ++processing_template_decl
;
19821 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
19823 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
19824 complain
, gen_tmpl
, true);
19825 push_nested_class (ctx
);
19828 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
19830 fndecl
= NULL_TREE
;
19831 if (VAR_P (pattern
))
19833 /* We need to determine if we're using a partial or explicit
19834 specialization now, because the type of the variable could be
19836 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
19837 tree elt
= most_specialized_partial_spec (tid
, complain
);
19838 if (elt
== error_mark_node
)
19839 pattern
= error_mark_node
;
19842 tree partial_tmpl
= TREE_VALUE (elt
);
19843 tree partial_args
= TREE_PURPOSE (elt
);
19844 tree partial_pat
= DECL_TEMPLATE_RESULT (partial_tmpl
);
19845 fndecl
= tsubst (partial_pat
, partial_args
, complain
, gen_tmpl
);
19849 /* Substitute template parameters to obtain the specialization. */
19850 if (fndecl
== NULL_TREE
)
19851 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
19852 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
19853 pop_nested_class ();
19854 pop_from_top_level ();
19856 if (fndecl
== error_mark_node
)
19858 pop_deferring_access_checks ();
19859 return error_mark_node
;
19862 /* The DECL_TI_TEMPLATE should always be the immediate parent
19863 template, not the most general template. */
19864 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
19865 DECL_TI_ARGS (fndecl
) = targ_ptr
;
19867 /* Now we know the specialization, compute access previously
19868 deferred. Do no access control for inheriting constructors,
19869 as we already checked access for the inherited constructor. */
19870 if (!(flag_new_inheriting_ctors
19871 && DECL_INHERITED_CTOR (fndecl
)))
19873 push_access_scope (fndecl
);
19874 if (!perform_deferred_access_checks (complain
))
19876 pop_access_scope (fndecl
);
19878 pop_deferring_access_checks ();
19880 /* If we've just instantiated the main entry point for a function,
19881 instantiate all the alternate entry points as well. We do this
19882 by cloning the instantiation of the main entry point, not by
19883 instantiating the template clones. */
19884 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
19885 clone_function_decl (fndecl
, /*update_methods=*/false);
19889 if (!(complain
& tf_error
))
19891 /* Remember to reinstantiate when we're out of SFINAE so the user
19892 can see the errors. */
19893 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
19895 return error_mark_node
;
19900 /* Wrapper for instantiate_template_1. */
19903 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
19906 timevar_push (TV_TEMPLATE_INST
);
19907 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
19908 timevar_pop (TV_TEMPLATE_INST
);
19912 /* Instantiate the alias template TMPL with ARGS. Also push a template
19913 instantiation level, which instantiate_template doesn't do because
19914 functions and variables have sufficient context established by the
19918 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
19920 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
19921 return error_mark_node
;
19922 if (!push_tinst_level (tmpl
, args
))
19923 return error_mark_node
;
19926 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
19927 args
, tmpl
, complain
,
19928 /*require_all_args=*/true,
19929 /*use_default_args=*/true);
19931 tree r
= instantiate_template (tmpl
, args
, complain
);
19932 pop_tinst_level ();
19937 /* PARM is a template parameter pack for FN. Returns true iff
19938 PARM is used in a deducible way in the argument list of FN. */
19941 pack_deducible_p (tree parm
, tree fn
)
19943 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
19944 for (; t
; t
= TREE_CHAIN (t
))
19946 tree type
= TREE_VALUE (t
);
19948 if (!PACK_EXPANSION_P (type
))
19950 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
19951 packs
; packs
= TREE_CHAIN (packs
))
19952 if (template_args_equal (TREE_VALUE (packs
), parm
))
19954 /* The template parameter pack is used in a function parameter
19955 pack. If this is the end of the parameter list, the
19956 template parameter pack is deducible. */
19957 if (TREE_CHAIN (t
) == void_list_node
)
19960 /* Otherwise, not. Well, it could be deduced from
19961 a non-pack parameter, but doing so would end up with
19962 a deduction mismatch, so don't bother. */
19966 /* The template parameter pack isn't used in any function parameter
19967 packs, but it might be used deeper, e.g. tuple<Args...>. */
19971 /* Subroutine of fn_type_unification: check non-dependent parms for
19975 check_non_deducible_conversions (tree parms
, const tree
*args
, unsigned nargs
,
19976 tree fn
, unification_kind_t strict
, int flags
,
19977 struct conversion
**convs
, bool explain_p
)
19979 /* Non-constructor methods need to leave a conversion for 'this', which
19980 isn't included in nargs here. */
19981 unsigned offset
= (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
19982 && !DECL_CONSTRUCTOR_P (fn
));
19984 for (unsigned ia
= 0;
19985 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
19987 tree parm
= TREE_VALUE (parms
);
19989 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
19990 && (!TREE_CHAIN (parms
)
19991 || TREE_CHAIN (parms
) == void_list_node
))
19992 /* For a function parameter pack that occurs at the end of the
19993 parameter-declaration-list, the type A of each remaining
19994 argument of the call is compared with the type P of the
19995 declarator-id of the function parameter pack. */
19998 parms
= TREE_CHAIN (parms
);
20000 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
20001 /* For a function parameter pack that does not occur at the
20002 end of the parameter-declaration-list, the type of the
20003 parameter pack is a non-deduced context. */
20006 if (!uses_template_parms (parm
))
20008 tree arg
= args
[ia
];
20009 conversion
**conv_p
= convs
? &convs
[ia
+offset
] : NULL
;
20010 int lflags
= conv_flags (ia
, nargs
, fn
, arg
, flags
);
20012 if (check_non_deducible_conversion (parm
, arg
, strict
, lflags
,
20013 conv_p
, explain_p
))
20023 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
20024 NARGS elements of the arguments that are being used when calling
20025 it. TARGS is a vector into which the deduced template arguments
20028 Returns either a FUNCTION_DECL for the matching specialization of FN or
20029 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
20030 true, diagnostics will be printed to explain why it failed.
20032 If FN is a conversion operator, or we are trying to produce a specific
20033 specialization, RETURN_TYPE is the return type desired.
20035 The EXPLICIT_TARGS are explicit template arguments provided via a
20038 The parameter STRICT is one of:
20041 We are deducing arguments for a function call, as in
20042 [temp.deduct.call]. If RETURN_TYPE is non-null, we are
20043 deducing arguments for a call to the result of a conversion
20044 function template, as in [over.call.object].
20047 We are deducing arguments for a conversion function, as in
20048 [temp.deduct.conv].
20051 We are deducing arguments when doing an explicit instantiation
20052 as in [temp.explicit], when determining an explicit specialization
20053 as in [temp.expl.spec], or when taking the address of a function
20054 template, as in [temp.deduct.funcaddr]. */
20057 fn_type_unification (tree fn
,
20058 tree explicit_targs
,
20061 unsigned int nargs
,
20063 unification_kind_t strict
,
20065 struct conversion
**convs
,
20071 tree decl
= NULL_TREE
;
20072 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
20074 static int deduction_depth
;
20075 /* type_unification_real will pass back any access checks from default
20076 template argument substitution. */
20077 vec
<deferred_access_check
, va_gc
> *checks
= NULL
;
20078 /* We don't have all the template args yet. */
20079 bool incomplete
= true;
20082 if (flag_new_inheriting_ctors
)
20083 fn
= strip_inheriting_ctors (fn
);
20085 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
20086 tree r
= error_mark_node
;
20088 tree full_targs
= targs
;
20089 if (TMPL_ARGS_DEPTH (targs
)
20090 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (fn
)))
20091 full_targs
= (add_outermost_template_args
20092 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (fn
)),
20096 complain
|= tf_decltype
;
20098 /* In C++0x, it's possible to have a function template whose type depends
20099 on itself recursively. This is most obvious with decltype, but can also
20100 occur with enumeration scope (c++/48969). So we need to catch infinite
20101 recursion and reject the substitution at deduction time; this function
20102 will return error_mark_node for any repeated substitution.
20104 This also catches excessive recursion such as when f<N> depends on
20105 f<N-1> across all integers, and returns error_mark_node for all the
20106 substitutions back up to the initial one.
20108 This is, of course, not reentrant. */
20109 if (excessive_deduction_depth
)
20110 return error_mark_node
;
20113 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
20115 fntype
= TREE_TYPE (fn
);
20116 if (explicit_targs
)
20120 The specified template arguments must match the template
20121 parameters in kind (i.e., type, nontype, template), and there
20122 must not be more arguments than there are parameters;
20123 otherwise type deduction fails.
20125 Nontype arguments must match the types of the corresponding
20126 nontype template parameters, or must be convertible to the
20127 types of the corresponding nontype parameters as specified in
20128 _temp.arg.nontype_, otherwise type deduction fails.
20130 All references in the function type of the function template
20131 to the corresponding template parameters are replaced by the
20132 specified template argument values. If a substitution in a
20133 template parameter or in the function type of the function
20134 template results in an invalid type, type deduction fails. */
20135 int i
, len
= TREE_VEC_LENGTH (tparms
);
20136 location_t loc
= input_location
;
20137 incomplete
= false;
20139 if (explicit_targs
== error_mark_node
)
20142 if (TMPL_ARGS_DEPTH (explicit_targs
)
20143 < TMPL_ARGS_DEPTH (full_targs
))
20144 explicit_targs
= add_outermost_template_args (full_targs
,
20147 /* Adjust any explicit template arguments before entering the
20148 substitution context. */
20150 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
20151 complain
|tf_partial
,
20152 /*require_all_args=*/false,
20153 /*use_default_args=*/false));
20154 if (explicit_targs
== error_mark_node
)
20157 /* Substitute the explicit args into the function type. This is
20158 necessary so that, for instance, explicitly declared function
20159 arguments can match null pointed constants. If we were given
20160 an incomplete set of explicit args, we must not do semantic
20161 processing during substitution as we could create partial
20163 for (i
= 0; i
< len
; i
++)
20165 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
20166 bool parameter_pack
= false;
20167 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
20169 /* Dig out the actual parm. */
20170 if (TREE_CODE (parm
) == TYPE_DECL
20171 || TREE_CODE (parm
) == TEMPLATE_DECL
)
20173 parm
= TREE_TYPE (parm
);
20174 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
20176 else if (TREE_CODE (parm
) == PARM_DECL
)
20178 parm
= DECL_INITIAL (parm
);
20179 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
20182 if (!parameter_pack
&& targ
== NULL_TREE
)
20183 /* No explicit argument for this template parameter. */
20186 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
20188 /* Mark the argument pack as "incomplete". We could
20189 still deduce more arguments during unification.
20190 We remove this mark in type_unification_real. */
20193 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
20194 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
20195 = 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 (TREE_CODE (type
) == FUNCTION_TYPE
20674 || TREE_CODE (type
) == METHOD_TYPE
)
20676 if (uses_deducible_template_parms (TREE_TYPE (type
)))
20678 tree parm
= TYPE_ARG_TYPES (type
);
20679 if (TREE_CODE (type
) == METHOD_TYPE
)
20680 parm
= TREE_CHAIN (parm
);
20681 for (; parm
; parm
= TREE_CHAIN (parm
))
20682 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
20689 /* Subroutine of type_unification_real and unify_pack_expansion to
20690 handle unification of a single P/A pair. Parameters are as
20691 for those functions. */
20694 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
20695 int subr
, unification_kind_t strict
,
20698 tree arg_expr
= NULL_TREE
;
20701 if (arg
== error_mark_node
|| parm
== error_mark_node
)
20702 return unify_invalid (explain_p
);
20703 if (arg
== unknown_type_node
)
20704 /* We can't deduce anything from this, but we might get all the
20705 template args from other function args. */
20706 return unify_success (explain_p
);
20708 /* Implicit conversions (Clause 4) will be performed on a function
20709 argument to convert it to the type of the corresponding function
20710 parameter if the parameter type contains no template-parameters that
20711 participate in template argument deduction. */
20712 if (strict
!= DEDUCE_EXACT
20713 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
20714 /* For function parameters with no deducible template parameters,
20715 just return. We'll check non-dependent conversions later. */
20716 return unify_success (explain_p
);
20721 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
20722 | UNIFY_ALLOW_MORE_CV_QUAL
20723 | UNIFY_ALLOW_DERIVED
);
20727 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
20731 arg_strict
= UNIFY_ALLOW_NONE
;
20735 gcc_unreachable ();
20738 /* We only do these transformations if this is the top-level
20739 parameter_type_list in a call or declaration matching; in other
20740 situations (nested function declarators, template argument lists) we
20741 won't be comparing a type to an expression, and we don't do any type
20747 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
20748 if (type_unknown_p (arg
))
20750 /* [temp.deduct.type] A template-argument can be
20751 deduced from a pointer to function or pointer
20752 to member function argument if the set of
20753 overloaded functions does not contain function
20754 templates and at most one of a set of
20755 overloaded functions provides a unique
20757 resolve_overloaded_unification (tparms
, targs
, parm
,
20759 arg_strict
, explain_p
);
20760 /* If a unique match was not found, this is a
20761 non-deduced context, so we still succeed. */
20762 return unify_success (explain_p
);
20766 arg
= unlowered_expr_type (arg
);
20767 if (arg
== error_mark_node
)
20768 return unify_invalid (explain_p
);
20772 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
20775 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
20776 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
20777 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
20779 /* For deduction from an init-list we need the actual list. */
20780 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
20782 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
20785 /* for_each_template_parm callback that always returns 0. */
20788 zero_r (tree
, void *)
20793 /* for_each_template_parm any_fn callback to handle deduction of a template
20794 type argument from the type of an array bound. */
20797 array_deduction_r (tree t
, void *data
)
20799 tree_pair_p d
= (tree_pair_p
)data
;
20800 tree
&tparms
= d
->purpose
;
20801 tree
&targs
= d
->value
;
20803 if (TREE_CODE (t
) == ARRAY_TYPE
)
20804 if (tree dom
= TYPE_DOMAIN (t
))
20805 if (tree max
= TYPE_MAX_VALUE (dom
))
20807 if (TREE_CODE (max
) == MINUS_EXPR
)
20808 max
= TREE_OPERAND (max
, 0);
20809 if (TREE_CODE (max
) == TEMPLATE_PARM_INDEX
)
20810 unify (tparms
, targs
, TREE_TYPE (max
), size_type_node
,
20811 UNIFY_ALLOW_NONE
, /*explain*/false);
20814 /* Keep walking. */
20818 /* Try to deduce any not-yet-deduced template type arguments from the type of
20819 an array bound. This is handled separately from unify because 14.8.2.5 says
20820 "The type of a type parameter is only deduced from an array bound if it is
20821 not otherwise deduced." */
20824 try_array_deduction (tree tparms
, tree targs
, tree parm
)
20826 tree_pair_s data
= { tparms
, targs
};
20827 hash_set
<tree
> visited
;
20828 for_each_template_parm (parm
, zero_r
, &data
, &visited
,
20829 /*nondeduced*/false, array_deduction_r
);
20832 /* Most parms like fn_type_unification.
20834 If SUBR is 1, we're being called recursively (to unify the
20835 arguments of a function or method parameter of a function
20838 CHECKS is a pointer to a vector of access checks encountered while
20839 substituting default template arguments. */
20842 type_unification_real (tree tparms
,
20846 unsigned int xnargs
,
20848 unification_kind_t strict
,
20849 vec
<deferred_access_check
, va_gc
> **checks
,
20854 int ntparms
= TREE_VEC_LENGTH (tparms
);
20855 int saw_undeduced
= 0;
20858 unsigned int nargs
;
20861 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
20862 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
20863 gcc_assert (ntparms
> 0);
20865 tree targs
= INNERMOST_TEMPLATE_ARGS (full_targs
);
20867 /* Reset the number of non-defaulted template arguments contained
20869 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
20877 while (parms
&& parms
!= void_list_node
20880 parm
= TREE_VALUE (parms
);
20882 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
20883 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
20884 /* For a function parameter pack that occurs at the end of the
20885 parameter-declaration-list, the type A of each remaining
20886 argument of the call is compared with the type P of the
20887 declarator-id of the function parameter pack. */
20890 parms
= TREE_CHAIN (parms
);
20892 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
20893 /* For a function parameter pack that does not occur at the
20894 end of the parameter-declaration-list, the type of the
20895 parameter pack is a non-deduced context. */
20901 if (unify_one_argument (tparms
, full_targs
, parm
, arg
, subr
, strict
,
20907 && parms
!= void_list_node
20908 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
20910 /* Unify the remaining arguments with the pack expansion type. */
20912 tree parmvec
= make_tree_vec (1);
20914 /* Allocate a TREE_VEC and copy in all of the arguments */
20915 argvec
= make_tree_vec (nargs
- ia
);
20916 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
20917 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
20919 /* Copy the parameter into parmvec. */
20920 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
20921 if (unify_pack_expansion (tparms
, full_targs
, parmvec
, argvec
, strict
,
20922 /*subr=*/subr
, explain_p
))
20925 /* Advance to the end of the list of parameters. */
20926 parms
= TREE_CHAIN (parms
);
20929 /* Fail if we've reached the end of the parm list, and more args
20930 are present, and the parm list isn't variadic. */
20931 if (ia
< nargs
&& parms
== void_list_node
)
20932 return unify_too_many_arguments (explain_p
, nargs
, ia
);
20933 /* Fail if parms are left and they don't have default values and
20934 they aren't all deduced as empty packs (c++/57397). This is
20935 consistent with sufficient_parms_p. */
20936 if (parms
&& parms
!= void_list_node
20937 && TREE_PURPOSE (parms
) == NULL_TREE
)
20939 unsigned int count
= nargs
;
20944 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
20947 p
= TREE_CHAIN (p
);
20949 while (p
&& p
!= void_list_node
);
20950 if (count
!= nargs
)
20951 return unify_too_few_arguments (explain_p
, ia
, count
,
20957 tsubst_flags_t complain
= (explain_p
20958 ? tf_warning_or_error
20960 bool tried_array_deduction
= (cxx_dialect
< cxx17
);
20962 for (i
= 0; i
< ntparms
; i
++)
20964 tree targ
= TREE_VEC_ELT (targs
, i
);
20965 tree tparm
= TREE_VEC_ELT (tparms
, i
);
20967 /* Clear the "incomplete" flags on all argument packs now so that
20968 substituting them into later default arguments works. */
20969 if (targ
&& ARGUMENT_PACK_P (targ
))
20971 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
20972 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
20975 if (targ
|| tparm
== error_mark_node
)
20977 tparm
= TREE_VALUE (tparm
);
20979 if (TREE_CODE (tparm
) == TYPE_DECL
20980 && !tried_array_deduction
)
20982 try_array_deduction (tparms
, targs
, xparms
);
20983 tried_array_deduction
= true;
20984 if (TREE_VEC_ELT (targs
, i
))
20988 /* If this is an undeduced nontype parameter that depends on
20989 a type parameter, try another pass; its type may have been
20990 deduced from a later argument than the one from which
20991 this parameter can be deduced. */
20992 if (TREE_CODE (tparm
) == PARM_DECL
20993 && uses_template_parms (TREE_TYPE (tparm
))
20994 && saw_undeduced
< 2)
21000 /* Core issue #226 (C++0x) [temp.deduct]:
21002 If a template argument has not been deduced, its
21003 default template argument, if any, is used.
21005 When we are in C++98 mode, TREE_PURPOSE will either
21006 be NULL_TREE or ERROR_MARK_NODE, so we do not need
21007 to explicitly check cxx_dialect here. */
21008 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
21009 /* OK, there is a default argument. Wait until after the
21010 conversion check to do substitution. */
21013 /* If the type parameter is a parameter pack, then it will
21014 be deduced to an empty parameter pack. */
21015 if (template_parameter_pack_p (tparm
))
21019 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
21021 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
21022 TREE_CONSTANT (arg
) = 1;
21025 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
21027 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
21029 TREE_VEC_ELT (targs
, i
) = arg
;
21033 return unify_parameter_deduction_failure (explain_p
, tparm
);
21036 /* Now substitute into the default template arguments. */
21037 for (i
= 0; i
< ntparms
; i
++)
21039 tree targ
= TREE_VEC_ELT (targs
, i
);
21040 tree tparm
= TREE_VEC_ELT (tparms
, i
);
21042 if (targ
|| tparm
== error_mark_node
)
21044 tree parm
= TREE_VALUE (tparm
);
21045 tree arg
= TREE_PURPOSE (tparm
);
21046 reopen_deferring_access_checks (*checks
);
21047 location_t save_loc
= input_location
;
21049 input_location
= DECL_SOURCE_LOCATION (parm
);
21051 if (saw_undeduced
== 1
21052 && TREE_CODE (parm
) == PARM_DECL
21053 && uses_template_parms (TREE_TYPE (parm
)))
21055 /* The type of this non-type parameter depends on undeduced
21056 parameters. Don't try to use its default argument yet,
21057 since we might deduce an argument for it on the next pass,
21058 but do check whether the arguments we already have cause
21059 substitution failure, so that that happens before we try
21060 later default arguments (78489). */
21061 ++processing_template_decl
;
21062 tree type
= tsubst (TREE_TYPE (parm
), full_targs
, complain
,
21064 --processing_template_decl
;
21065 if (type
== error_mark_node
)
21066 arg
= error_mark_node
;
21072 /* Even if the call is happening in template context, getting
21073 here means it's non-dependent, and a default argument is
21074 considered a separate definition under [temp.decls], so we can
21075 do this substitution without processing_template_decl. This
21076 is important if the default argument contains something that
21077 might be instantiation-dependent like access (87480). */
21078 processing_template_decl_sentinel s
;
21079 tree substed
= NULL_TREE
;
21080 if (saw_undeduced
== 1)
21082 /* First instatiate in template context, in case we still
21083 depend on undeduced template parameters. */
21084 ++processing_template_decl
;
21085 substed
= tsubst_template_arg (arg
, full_targs
, complain
,
21087 --processing_template_decl
;
21088 if (substed
!= error_mark_node
21089 && !uses_template_parms (substed
))
21090 /* We replaced all the tparms, substitute again out of
21091 template context. */
21092 substed
= NULL_TREE
;
21095 substed
= tsubst_template_arg (arg
, full_targs
, complain
,
21098 if (!uses_template_parms (substed
))
21099 arg
= convert_template_argument (parm
, substed
, full_targs
,
21100 complain
, i
, NULL_TREE
);
21101 else if (saw_undeduced
== 1)
21104 arg
= error_mark_node
;
21107 input_location
= save_loc
;
21108 *checks
= get_deferred_access_checks ();
21109 pop_deferring_access_checks ();
21111 if (arg
== error_mark_node
)
21115 TREE_VEC_ELT (targs
, i
) = arg
;
21116 /* The position of the first default template argument,
21117 is also the number of non-defaulted arguments in TARGS.
21119 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
21120 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
21124 if (saw_undeduced
++ == 1)
21128 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
21129 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
21131 return unify_success (explain_p
);
21134 /* Subroutine of type_unification_real. Args are like the variables
21135 at the call site. ARG is an overloaded function (or template-id);
21136 we try deducing template args from each of the overloads, and if
21137 only one succeeds, we go with that. Modifies TARGS and returns
21138 true on success. */
21141 resolve_overloaded_unification (tree tparms
,
21145 unification_kind_t strict
,
21149 tree tempargs
= copy_node (targs
);
21151 tree goodfn
= NULL_TREE
;
21154 if (TREE_CODE (arg
) == ADDR_EXPR
)
21156 arg
= TREE_OPERAND (arg
, 0);
21162 if (TREE_CODE (arg
) == COMPONENT_REF
)
21163 /* Handle `&x' where `x' is some static or non-static member
21165 arg
= TREE_OPERAND (arg
, 1);
21167 if (TREE_CODE (arg
) == OFFSET_REF
)
21168 arg
= TREE_OPERAND (arg
, 1);
21170 /* Strip baselink information. */
21171 if (BASELINK_P (arg
))
21172 arg
= BASELINK_FUNCTIONS (arg
);
21174 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
21176 /* If we got some explicit template args, we need to plug them into
21177 the affected templates before we try to unify, in case the
21178 explicit args will completely resolve the templates in question. */
21181 tree expl_subargs
= TREE_OPERAND (arg
, 1);
21182 arg
= TREE_OPERAND (arg
, 0);
21184 for (lkp_iterator
iter (arg
); iter
; ++iter
)
21187 tree subargs
, elem
;
21189 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
21192 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
21193 expl_subargs
, NULL_TREE
, tf_none
,
21194 /*require_all_args=*/true,
21195 /*use_default_args=*/true);
21196 if (subargs
!= error_mark_node
21197 && !any_dependent_template_arguments_p (subargs
))
21199 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
21200 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
21201 elem
, strict
, sub_strict
, addr_p
, explain_p
)
21202 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
21211 /* If no templates (or more than one) are fully resolved by the
21212 explicit arguments, this template-id is a non-deduced context; it
21213 could still be OK if we deduce all template arguments for the
21214 enclosing call through other arguments. */
21218 else if (TREE_CODE (arg
) != OVERLOAD
21219 && TREE_CODE (arg
) != FUNCTION_DECL
)
21220 /* If ARG is, for example, "(0, &f)" then its type will be unknown
21221 -- but the deduction does not succeed because the expression is
21222 not just the function on its own. */
21225 for (lkp_iterator
iter (arg
); iter
; ++iter
)
21228 if (try_one_overload (tparms
, targs
, tempargs
, parm
, TREE_TYPE (fn
),
21229 strict
, sub_strict
, addr_p
, explain_p
)
21230 && (!goodfn
|| !decls_match (goodfn
, fn
)))
21237 /* [temp.deduct.type] A template-argument can be deduced from a pointer
21238 to function or pointer to member function argument if the set of
21239 overloaded functions does not contain function templates and at most
21240 one of a set of overloaded functions provides a unique match.
21242 So if we found multiple possibilities, we return success but don't
21243 deduce anything. */
21247 int i
= TREE_VEC_LENGTH (targs
);
21249 if (TREE_VEC_ELT (tempargs
, i
))
21251 tree old
= TREE_VEC_ELT (targs
, i
);
21252 tree new_
= TREE_VEC_ELT (tempargs
, i
);
21253 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
21254 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
21255 /* Don't forget explicit template arguments in a pack. */
21256 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
21257 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
21258 TREE_VEC_ELT (targs
, i
) = new_
;
21267 /* Core DR 115: In contexts where deduction is done and fails, or in
21268 contexts where deduction is not done, if a template argument list is
21269 specified and it, along with any default template arguments, identifies
21270 a single function template specialization, then the template-id is an
21271 lvalue for the function template specialization. */
21274 resolve_nondeduced_context (tree orig_expr
, tsubst_flags_t complain
)
21276 tree expr
, offset
, baselink
;
21279 if (!type_unknown_p (orig_expr
))
21284 offset
= NULL_TREE
;
21285 baselink
= NULL_TREE
;
21287 if (TREE_CODE (expr
) == ADDR_EXPR
)
21289 expr
= TREE_OPERAND (expr
, 0);
21292 if (TREE_CODE (expr
) == OFFSET_REF
)
21295 expr
= TREE_OPERAND (expr
, 1);
21297 if (BASELINK_P (expr
))
21300 expr
= BASELINK_FUNCTIONS (expr
);
21303 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
21306 tree goodfn
= NULL_TREE
;
21308 /* If we got some explicit template args, we need to plug them into
21309 the affected templates before we try to unify, in case the
21310 explicit args will completely resolve the templates in question. */
21312 tree expl_subargs
= TREE_OPERAND (expr
, 1);
21313 tree arg
= TREE_OPERAND (expr
, 0);
21314 tree badfn
= NULL_TREE
;
21315 tree badargs
= NULL_TREE
;
21317 for (lkp_iterator
iter (arg
); iter
; ++iter
)
21320 tree subargs
, elem
;
21322 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
21325 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
21326 expl_subargs
, NULL_TREE
, tf_none
,
21327 /*require_all_args=*/true,
21328 /*use_default_args=*/true);
21329 if (subargs
!= error_mark_node
21330 && !any_dependent_template_arguments_p (subargs
))
21332 elem
= instantiate_template (fn
, subargs
, tf_none
);
21333 if (elem
== error_mark_node
)
21338 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
21347 mark_used (goodfn
);
21350 expr
= build_baselink (BASELINK_BINFO (baselink
),
21351 BASELINK_ACCESS_BINFO (baselink
),
21352 expr
, BASELINK_OPTYPE (baselink
));
21356 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
21357 expr
= build_offset_ref (base
, expr
, addr
, complain
);
21360 expr
= cp_build_addr_expr (expr
, complain
);
21363 else if (good
== 0 && badargs
&& (complain
& tf_error
))
21364 /* There were no good options and at least one bad one, so let the
21365 user know what the problem is. */
21366 instantiate_template (badfn
, badargs
, complain
);
21371 /* As above, but error out if the expression remains overloaded. */
21374 resolve_nondeduced_context_or_error (tree exp
, tsubst_flags_t complain
)
21376 exp
= resolve_nondeduced_context (exp
, complain
);
21377 if (type_unknown_p (exp
))
21379 if (complain
& tf_error
)
21380 cxx_incomplete_type_error (exp
, TREE_TYPE (exp
));
21381 return error_mark_node
;
21386 /* Subroutine of resolve_overloaded_unification; does deduction for a single
21387 overload. Fills TARGS with any deduced arguments, or error_mark_node if
21388 different overloads deduce different arguments for a given parm.
21389 ADDR_P is true if the expression for which deduction is being
21390 performed was of the form "& fn" rather than simply "fn".
21392 Returns 1 on success. */
21395 try_one_overload (tree tparms
,
21400 unification_kind_t strict
,
21409 if (arg
== error_mark_node
)
21412 /* [temp.deduct.type] A template-argument can be deduced from a pointer
21413 to function or pointer to member function argument if the set of
21414 overloaded functions does not contain function templates and at most
21415 one of a set of overloaded functions provides a unique match.
21417 So if this is a template, just return success. */
21419 if (uses_template_parms (arg
))
21422 if (TREE_CODE (arg
) == METHOD_TYPE
)
21423 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
21425 arg
= build_pointer_type (arg
);
21427 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
21429 /* We don't copy orig_targs for this because if we have already deduced
21430 some template args from previous args, unify would complain when we
21431 try to deduce a template parameter for the same argument, even though
21432 there isn't really a conflict. */
21433 nargs
= TREE_VEC_LENGTH (targs
);
21434 tempargs
= make_tree_vec (nargs
);
21436 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
21439 /* First make sure we didn't deduce anything that conflicts with
21440 explicitly specified args. */
21441 for (i
= nargs
; i
--; )
21443 tree elt
= TREE_VEC_ELT (tempargs
, i
);
21444 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
21448 else if (uses_template_parms (elt
))
21449 /* Since we're unifying against ourselves, we will fill in
21450 template args used in the function parm list with our own
21451 template parms. Discard them. */
21452 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
21453 else if (oldelt
&& ARGUMENT_PACK_P (oldelt
))
21455 /* Check that the argument at each index of the deduced argument pack
21456 is equivalent to the corresponding explicitly specified argument.
21457 We may have deduced more arguments than were explicitly specified,
21460 /* We used to assert ARGUMENT_PACK_INCOMPLETE_P (oldelt) here, but
21461 that's wrong if we deduce the same argument pack from multiple
21462 function arguments: it's only incomplete the first time. */
21464 tree explicit_pack
= ARGUMENT_PACK_ARGS (oldelt
);
21465 tree deduced_pack
= ARGUMENT_PACK_ARGS (elt
);
21467 if (TREE_VEC_LENGTH (deduced_pack
)
21468 < TREE_VEC_LENGTH (explicit_pack
))
21471 for (int j
= 0; j
< TREE_VEC_LENGTH (explicit_pack
); j
++)
21472 if (!template_args_equal (TREE_VEC_ELT (explicit_pack
, j
),
21473 TREE_VEC_ELT (deduced_pack
, j
)))
21476 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
21480 for (i
= nargs
; i
--; )
21482 tree elt
= TREE_VEC_ELT (tempargs
, i
);
21485 TREE_VEC_ELT (targs
, i
) = elt
;
21491 /* PARM is a template class (perhaps with unbound template
21492 parameters). ARG is a fully instantiated type. If ARG can be
21493 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
21494 TARGS are as for unify. */
21497 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
21500 tree copy_of_targs
;
21502 if (!CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
21504 else if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21505 /* Matches anything. */;
21506 else if (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
21507 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
)))
21510 /* We need to make a new template argument vector for the call to
21511 unify. If we used TARGS, we'd clutter it up with the result of
21512 the attempted unification, even if this class didn't work out.
21513 We also don't want to commit ourselves to all the unifications
21514 we've already done, since unification is supposed to be done on
21515 an argument-by-argument basis. In other words, consider the
21516 following pathological case:
21518 template <int I, int J, int K>
21521 template <int I, int J>
21522 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
21524 template <int I, int J, int K>
21525 void f(S<I, J, K>, S<I, I, I>);
21534 Now, by the time we consider the unification involving `s2', we
21535 already know that we must have `f<0, 0, 0>'. But, even though
21536 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
21537 because there are two ways to unify base classes of S<0, 1, 2>
21538 with S<I, I, I>. If we kept the already deduced knowledge, we
21539 would reject the possibility I=1. */
21540 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
21542 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21544 if (unify_bound_ttp_args (tparms
, copy_of_targs
, parm
, arg
, explain_p
))
21549 /* If unification failed, we're done. */
21550 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
21551 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
21557 /* Given a template type PARM and a class type ARG, find the unique
21558 base type in ARG that is an instance of PARM. We do not examine
21559 ARG itself; only its base-classes. If there is not exactly one
21560 appropriate base class, return NULL_TREE. PARM may be the type of
21561 a partial specialization, as well as a plain template type. Used
21564 static enum template_base_result
21565 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
21566 bool explain_p
, tree
*result
)
21568 tree rval
= NULL_TREE
;
21571 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
21573 binfo
= TYPE_BINFO (complete_type (arg
));
21576 /* The type could not be completed. */
21577 *result
= NULL_TREE
;
21578 return tbr_incomplete_type
;
21581 /* Walk in inheritance graph order. The search order is not
21582 important, and this avoids multiple walks of virtual bases. */
21583 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
21585 tree r
= try_class_unification (tparms
, targs
, parm
,
21586 BINFO_TYPE (binfo
), explain_p
);
21590 /* If there is more than one satisfactory baseclass, then:
21594 If they yield more than one possible deduced A, the type
21598 if (rval
&& !same_type_p (r
, rval
))
21600 *result
= NULL_TREE
;
21601 return tbr_ambiguous_baseclass
;
21609 return tbr_success
;
21612 /* Returns the level of DECL, which declares a template parameter. */
21615 template_decl_level (tree decl
)
21617 switch (TREE_CODE (decl
))
21620 case TEMPLATE_DECL
:
21621 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
21624 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
21627 gcc_unreachable ();
21632 /* Decide whether ARG can be unified with PARM, considering only the
21633 cv-qualifiers of each type, given STRICT as documented for unify.
21634 Returns nonzero iff the unification is OK on that basis. */
21637 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
21639 int arg_quals
= cp_type_quals (arg
);
21640 int parm_quals
= cp_type_quals (parm
);
21642 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
21643 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
21645 /* Although a CVR qualifier is ignored when being applied to a
21646 substituted template parameter ([8.3.2]/1 for example), that
21647 does not allow us to unify "const T" with "int&" because both
21648 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
21649 It is ok when we're allowing additional CV qualifiers
21650 at the outer level [14.8.2.1]/3,1st bullet. */
21651 if ((TYPE_REF_P (arg
)
21652 || TREE_CODE (arg
) == FUNCTION_TYPE
21653 || TREE_CODE (arg
) == METHOD_TYPE
)
21654 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
21657 if ((!INDIRECT_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
21658 && (parm_quals
& TYPE_QUAL_RESTRICT
))
21662 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
21663 && (arg_quals
& parm_quals
) != parm_quals
)
21666 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
21667 && (parm_quals
& arg_quals
) != arg_quals
)
21673 /* Determines the LEVEL and INDEX for the template parameter PARM. */
21675 template_parm_level_and_index (tree parm
, int* level
, int* index
)
21677 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
21678 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
21679 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21681 *index
= TEMPLATE_TYPE_IDX (parm
);
21682 *level
= TEMPLATE_TYPE_LEVEL (parm
);
21686 *index
= TEMPLATE_PARM_IDX (parm
);
21687 *level
= TEMPLATE_PARM_LEVEL (parm
);
21691 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
21693 if (unify (TP, TA, P, A, S, EP)) \
21697 /* Unifies the remaining arguments in PACKED_ARGS with the pack
21698 expansion at the end of PACKED_PARMS. Returns 0 if the type
21699 deduction succeeds, 1 otherwise. STRICT is the same as in
21700 fn_type_unification. CALL_ARGS_P is true iff PACKED_ARGS is actually a
21701 function call argument list. We'll need to adjust the arguments to make them
21702 types. SUBR tells us if this is from a recursive call to
21703 type_unification_real, or for comparing two template argument
21707 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
21708 tree packed_args
, unification_kind_t strict
,
21709 bool subr
, bool explain_p
)
21712 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
21713 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
21714 tree pack
, packs
= NULL_TREE
;
21715 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
21717 /* Add in any args remembered from an earlier partial instantiation. */
21718 targs
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (parm
), targs
);
21719 int levels
= TMPL_ARGS_DEPTH (targs
);
21721 packed_args
= expand_template_argument_pack (packed_args
);
21723 int len
= TREE_VEC_LENGTH (packed_args
);
21725 /* Determine the parameter packs we will be deducing from the
21726 pattern, and record their current deductions. */
21727 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
21728 pack
; pack
= TREE_CHAIN (pack
))
21730 tree parm_pack
= TREE_VALUE (pack
);
21733 /* Only template parameter packs can be deduced, not e.g. function
21734 parameter packs or __bases or __integer_pack. */
21735 if (!TEMPLATE_PARM_P (parm_pack
))
21738 /* Determine the index and level of this parameter pack. */
21739 template_parm_level_and_index (parm_pack
, &level
, &idx
);
21740 if (level
< levels
)
21743 /* Keep track of the parameter packs and their corresponding
21745 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
21746 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
21749 /* Loop through all of the arguments that have not yet been
21750 unified and unify each with the pattern. */
21751 for (i
= start
; i
< len
; i
++)
21754 bool any_explicit
= false;
21755 tree arg
= TREE_VEC_ELT (packed_args
, i
);
21757 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
21758 or the element of its argument pack at the current index if
21759 this argument was explicitly specified. */
21760 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
21764 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
21767 if (TREE_VALUE (pack
)
21768 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
21769 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
21771 any_explicit
= true;
21772 arg
= TREE_VEC_ELT (pargs
, i
- start
);
21774 TMPL_ARG (targs
, level
, idx
) = arg
;
21777 /* If we had explicit template arguments, substitute them into the
21778 pattern before deduction. */
21781 /* Some arguments might still be unspecified or dependent. */
21783 ++processing_template_decl
;
21784 dependent
= any_dependent_template_arguments_p (targs
);
21786 --processing_template_decl
;
21787 parm
= tsubst (pattern
, targs
,
21788 explain_p
? tf_warning_or_error
: tf_none
,
21791 --processing_template_decl
;
21792 if (parm
== error_mark_node
)
21798 /* Unify the pattern with the current argument. */
21799 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
21803 /* For each parameter pack, collect the deduced value. */
21804 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
21807 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
21809 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
21810 TMPL_ARG (targs
, level
, idx
);
21814 /* Verify that the results of unification with the parameter packs
21815 produce results consistent with what we've seen before, and make
21816 the deduced argument packs available. */
21817 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
21819 tree old_pack
= TREE_VALUE (pack
);
21820 tree new_args
= TREE_TYPE (pack
);
21821 int i
, len
= TREE_VEC_LENGTH (new_args
);
21823 bool nondeduced_p
= false;
21825 /* By default keep the original deduced argument pack.
21826 If necessary, more specific code is going to update the
21827 resulting deduced argument later down in this function. */
21828 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
21829 TMPL_ARG (targs
, level
, idx
) = old_pack
;
21831 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
21832 actually deduce anything. */
21833 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
21834 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
21835 nondeduced_p
= true;
21839 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
21841 /* If we had fewer function args than explicit template args,
21842 just use the explicits. */
21843 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
21844 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
21845 if (len
< explicit_len
)
21846 new_args
= explicit_args
;
21852 /* Build the deduced *_ARGUMENT_PACK. */
21853 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
21855 result
= make_node (NONTYPE_ARGUMENT_PACK
);
21856 TREE_CONSTANT (result
) = 1;
21859 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
21861 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
21863 /* Note the deduced argument packs for this parameter
21865 TMPL_ARG (targs
, level
, idx
) = result
;
21867 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
21868 && (ARGUMENT_PACK_ARGS (old_pack
)
21869 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
21871 /* We only had the explicitly-provided arguments before, but
21872 now we have a complete set of arguments. */
21873 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
21875 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
21876 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
21877 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
21881 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
21882 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
21884 if (!comp_template_args (old_args
, new_args
,
21885 &bad_old_arg
, &bad_new_arg
))
21886 /* Inconsistent unification of this parameter pack. */
21887 return unify_parameter_pack_inconsistent (explain_p
,
21893 return unify_success (explain_p
);
21896 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
21897 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
21898 parameters and return value are as for unify. */
21901 unify_array_domain (tree tparms
, tree targs
,
21902 tree parm_dom
, tree arg_dom
,
21910 /* Our representation of array types uses "N - 1" as the
21911 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
21912 not an integer constant. We cannot unify arbitrarily
21913 complex expressions, so we eliminate the MINUS_EXPRs
21915 parm_max
= TYPE_MAX_VALUE (parm_dom
);
21916 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
21919 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
21920 parm_max
= TREE_OPERAND (parm_max
, 0);
21922 arg_max
= TYPE_MAX_VALUE (arg_dom
);
21923 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
21926 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
21927 trying to unify the type of a variable with the type
21928 of a template parameter. For example:
21930 template <unsigned int N>
21931 void f (char (&) [N]);
21938 Here, the type of the ARG will be "int [g(i)]", and
21939 may be a SAVE_EXPR, etc. */
21940 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
21941 return unify_vla_arg (explain_p
, arg_dom
);
21942 arg_max
= TREE_OPERAND (arg_max
, 0);
21945 /* If only one of the bounds used a MINUS_EXPR, compensate
21946 by adding one to the other bound. */
21947 if (parm_cst
&& !arg_cst
)
21948 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
21952 else if (arg_cst
&& !parm_cst
)
21953 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
21958 return unify (tparms
, targs
, parm_max
, arg_max
,
21959 UNIFY_ALLOW_INTEGER
, explain_p
);
21962 /* Returns whether T, a P or A in unify, is a type, template or expression. */
21964 enum pa_kind_t
{ pa_type
, pa_tmpl
, pa_expr
};
21969 if (PACK_EXPANSION_P (t
))
21970 t
= PACK_EXPANSION_PATTERN (t
);
21971 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
21972 || TREE_CODE (t
) == UNBOUND_CLASS_TEMPLATE
21973 || DECL_TYPE_TEMPLATE_P (t
))
21975 else if (TYPE_P (t
))
21981 /* Deduce the value of template parameters. TPARMS is the (innermost)
21982 set of template parameters to a template. TARGS is the bindings
21983 for those template parameters, as determined thus far; TARGS may
21984 include template arguments for outer levels of template parameters
21985 as well. PARM is a parameter to a template function, or a
21986 subcomponent of that parameter; ARG is the corresponding argument.
21987 This function attempts to match PARM with ARG in a manner
21988 consistent with the existing assignments in TARGS. If more values
21989 are deduced, then TARGS is updated.
21991 Returns 0 if the type deduction succeeds, 1 otherwise. The
21992 parameter STRICT is a bitwise or of the following flags:
21995 Require an exact match between PARM and ARG.
21996 UNIFY_ALLOW_MORE_CV_QUAL:
21997 Allow the deduced ARG to be more cv-qualified (by qualification
21998 conversion) than ARG.
21999 UNIFY_ALLOW_LESS_CV_QUAL:
22000 Allow the deduced ARG to be less cv-qualified than ARG.
22001 UNIFY_ALLOW_DERIVED:
22002 Allow the deduced ARG to be a template base class of ARG,
22003 or a pointer to a template base class of the type pointed to by
22005 UNIFY_ALLOW_INTEGER:
22006 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
22007 case for more information.
22008 UNIFY_ALLOW_OUTER_LEVEL:
22009 This is the outermost level of a deduction. Used to determine validity
22010 of qualification conversions. A valid qualification conversion must
22011 have const qualified pointers leading up to the inner type which
22012 requires additional CV quals, except at the outer level, where const
22013 is not required [conv.qual]. It would be normal to set this flag in
22014 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
22015 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
22016 This is the outermost level of a deduction, and PARM can be more CV
22017 qualified at this point.
22018 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
22019 This is the outermost level of a deduction, and PARM can be less CV
22020 qualified at this point. */
22023 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
22029 int strict_in
= strict
;
22030 tsubst_flags_t complain
= (explain_p
22031 ? tf_warning_or_error
22034 /* I don't think this will do the right thing with respect to types.
22035 But the only case I've seen it in so far has been array bounds, where
22036 signedness is the only information lost, and I think that will be
22038 while (CONVERT_EXPR_P (parm
))
22039 parm
= TREE_OPERAND (parm
, 0);
22041 if (arg
== error_mark_node
)
22042 return unify_invalid (explain_p
);
22043 if (arg
== unknown_type_node
22044 || arg
== init_list_type_node
)
22045 /* We can't deduce anything from this, but we might get all the
22046 template args from other function args. */
22047 return unify_success (explain_p
);
22049 if (parm
== any_targ_node
|| arg
== any_targ_node
)
22050 return unify_success (explain_p
);
22052 /* If PARM uses template parameters, then we can't bail out here,
22053 even if ARG == PARM, since we won't record unifications for the
22054 template parameters. We might need them if we're trying to
22055 figure out which of two things is more specialized. */
22056 if (arg
== parm
&& !uses_template_parms (parm
))
22057 return unify_success (explain_p
);
22059 /* Handle init lists early, so the rest of the function can assume
22060 we're dealing with a type. */
22061 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
22065 tree orig_parm
= parm
;
22067 /* Replace T with std::initializer_list<T> for deduction. */
22068 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
22069 && flag_deduce_init_list
)
22070 parm
= listify (parm
);
22072 if (!is_std_init_list (parm
)
22073 && TREE_CODE (parm
) != ARRAY_TYPE
)
22074 /* We can only deduce from an initializer list argument if the
22075 parameter is std::initializer_list or an array; otherwise this
22076 is a non-deduced context. */
22077 return unify_success (explain_p
);
22079 if (TREE_CODE (parm
) == ARRAY_TYPE
)
22080 elttype
= TREE_TYPE (parm
);
22083 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
22084 /* Deduction is defined in terms of a single type, so just punt
22085 on the (bizarre) std::initializer_list<T...>. */
22086 if (PACK_EXPANSION_P (elttype
))
22087 return unify_success (explain_p
);
22090 if (strict
!= DEDUCE_EXACT
22091 && TYPE_P (elttype
)
22092 && !uses_deducible_template_parms (elttype
))
22093 /* If ELTTYPE has no deducible template parms, skip deduction from
22094 the list elements. */;
22096 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
22098 int elt_strict
= strict
;
22100 if (elt
== error_mark_node
)
22101 return unify_invalid (explain_p
);
22103 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
22105 tree type
= TREE_TYPE (elt
);
22106 if (type
== error_mark_node
)
22107 return unify_invalid (explain_p
);
22108 /* It should only be possible to get here for a call. */
22109 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
22110 elt_strict
|= maybe_adjust_types_for_deduction
22111 (DEDUCE_CALL
, &elttype
, &type
, elt
);
22115 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
22119 if (TREE_CODE (parm
) == ARRAY_TYPE
22120 && deducible_array_bound (TYPE_DOMAIN (parm
)))
22122 /* Also deduce from the length of the initializer list. */
22123 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
22124 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
22125 if (idx
== error_mark_node
)
22126 return unify_invalid (explain_p
);
22127 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
22131 /* If the std::initializer_list<T> deduction worked, replace the
22132 deduced A with std::initializer_list<A>. */
22133 if (orig_parm
!= parm
)
22135 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
22136 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
22137 targ
= listify (targ
);
22138 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
22140 return unify_success (explain_p
);
22143 /* If parm and arg aren't the same kind of thing (template, type, or
22144 expression), fail early. */
22145 if (pa_kind (parm
) != pa_kind (arg
))
22146 return unify_invalid (explain_p
);
22148 /* Immediately reject some pairs that won't unify because of
22149 cv-qualification mismatches. */
22150 if (TREE_CODE (arg
) == TREE_CODE (parm
)
22152 /* It is the elements of the array which hold the cv quals of an array
22153 type, and the elements might be template type parms. We'll check
22154 when we recurse. */
22155 && TREE_CODE (arg
) != ARRAY_TYPE
22156 /* We check the cv-qualifiers when unifying with template type
22157 parameters below. We want to allow ARG `const T' to unify with
22158 PARM `T' for example, when computing which of two templates
22159 is more specialized, for example. */
22160 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
22161 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
22162 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22164 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
22165 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
22166 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
22167 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
22168 strict
&= ~UNIFY_ALLOW_DERIVED
;
22169 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
22170 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
22172 switch (TREE_CODE (parm
))
22174 case TYPENAME_TYPE
:
22176 case UNBOUND_CLASS_TEMPLATE
:
22177 /* In a type which contains a nested-name-specifier, template
22178 argument values cannot be deduced for template parameters used
22179 within the nested-name-specifier. */
22180 return unify_success (explain_p
);
22182 case TEMPLATE_TYPE_PARM
:
22183 case TEMPLATE_TEMPLATE_PARM
:
22184 case BOUND_TEMPLATE_TEMPLATE_PARM
:
22185 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
22186 if (error_operand_p (tparm
))
22187 return unify_invalid (explain_p
);
22189 if (TEMPLATE_TYPE_LEVEL (parm
)
22190 != template_decl_level (tparm
))
22191 /* The PARM is not one we're trying to unify. Just check
22192 to see if it matches ARG. */
22194 if (TREE_CODE (arg
) == TREE_CODE (parm
)
22195 && (is_auto (parm
) ? is_auto (arg
)
22196 : same_type_p (parm
, arg
)))
22197 return unify_success (explain_p
);
22199 return unify_type_mismatch (explain_p
, parm
, arg
);
22201 idx
= TEMPLATE_TYPE_IDX (parm
);
22202 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
22203 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
22204 if (error_operand_p (tparm
))
22205 return unify_invalid (explain_p
);
22207 /* Check for mixed types and values. */
22208 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
22209 && TREE_CODE (tparm
) != TYPE_DECL
)
22210 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
22211 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
22212 gcc_unreachable ();
22214 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22216 if ((strict_in
& UNIFY_ALLOW_DERIVED
)
22217 && CLASS_TYPE_P (arg
))
22219 /* First try to match ARG directly. */
22220 tree t
= try_class_unification (tparms
, targs
, parm
, arg
,
22224 /* Otherwise, look for a suitable base of ARG, as below. */
22225 enum template_base_result r
;
22226 r
= get_template_base (tparms
, targs
, parm
, arg
,
22229 return unify_no_common_base (explain_p
, r
, parm
, arg
);
22233 /* ARG must be constructed from a template class or a template
22234 template parameter. */
22235 else if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
22236 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
22237 return unify_template_deduction_failure (explain_p
, parm
, arg
);
22239 /* Deduce arguments T, i from TT<T> or TT<i>. */
22240 if (unify_bound_ttp_args (tparms
, targs
, parm
, arg
, explain_p
))
22243 arg
= TYPE_TI_TEMPLATE (arg
);
22245 /* Fall through to deduce template name. */
22248 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
22249 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22251 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
22253 /* Simple cases: Value already set, does match or doesn't. */
22254 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
22255 return unify_success (explain_p
);
22257 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
22261 /* If PARM is `const T' and ARG is only `int', we don't have
22262 a match unless we are allowing additional qualification.
22263 If ARG is `const int' and PARM is just `T' that's OK;
22264 that binds `const int' to `T'. */
22265 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
22267 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22269 /* Consider the case where ARG is `const volatile int' and
22270 PARM is `const T'. Then, T should be `volatile int'. */
22271 arg
= cp_build_qualified_type_real
22272 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
22273 if (arg
== error_mark_node
)
22274 return unify_invalid (explain_p
);
22276 /* Simple cases: Value already set, does match or doesn't. */
22277 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
22278 return unify_success (explain_p
);
22280 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
22282 /* Make sure that ARG is not a variable-sized array. (Note
22283 that were talking about variable-sized arrays (like
22284 `int[n]'), rather than arrays of unknown size (like
22285 `int[]').) We'll get very confused by such a type since
22286 the bound of the array is not constant, and therefore
22287 not mangleable. Besides, such types are not allowed in
22288 ISO C++, so we can do as we please here. We do allow
22289 them for 'auto' deduction, since that isn't ABI-exposed. */
22290 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
22291 return unify_vla_arg (explain_p
, arg
);
22293 /* Strip typedefs as in convert_template_argument. */
22294 arg
= canonicalize_type_argument (arg
, tf_none
);
22297 /* If ARG is a parameter pack or an expansion, we cannot unify
22298 against it unless PARM is also a parameter pack. */
22299 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
22300 && !template_parameter_pack_p (parm
))
22301 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
22303 /* If the argument deduction results is a METHOD_TYPE,
22304 then there is a problem.
22305 METHOD_TYPE doesn't map to any real C++ type the result of
22306 the deduction cannot be of that type. */
22307 if (TREE_CODE (arg
) == METHOD_TYPE
)
22308 return unify_method_type_error (explain_p
, arg
);
22310 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
22311 return unify_success (explain_p
);
22313 case TEMPLATE_PARM_INDEX
:
22314 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
22315 if (error_operand_p (tparm
))
22316 return unify_invalid (explain_p
);
22318 if (TEMPLATE_PARM_LEVEL (parm
)
22319 != template_decl_level (tparm
))
22321 /* The PARM is not one we're trying to unify. Just check
22322 to see if it matches ARG. */
22323 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
22324 && cp_tree_equal (parm
, arg
));
22326 unify_expression_unequal (explain_p
, parm
, arg
);
22330 idx
= TEMPLATE_PARM_IDX (parm
);
22331 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
22335 if ((strict
& UNIFY_ALLOW_INTEGER
)
22336 && TREE_TYPE (targ
) && TREE_TYPE (arg
)
22337 && CP_INTEGRAL_TYPE_P (TREE_TYPE (targ
)))
22338 /* We're deducing from an array bound, the type doesn't matter. */
22339 arg
= fold_convert (TREE_TYPE (targ
), arg
);
22340 int x
= !cp_tree_equal (targ
, arg
);
22342 unify_inconsistency (explain_p
, parm
, targ
, arg
);
22346 /* [temp.deduct.type] If, in the declaration of a function template
22347 with a non-type template-parameter, the non-type
22348 template-parameter is used in an expression in the function
22349 parameter-list and, if the corresponding template-argument is
22350 deduced, the template-argument type shall match the type of the
22351 template-parameter exactly, except that a template-argument
22352 deduced from an array bound may be of any integral type.
22353 The non-type parameter might use already deduced type parameters. */
22354 tparm
= TREE_TYPE (parm
);
22355 if (TEMPLATE_PARM_LEVEL (parm
) > TMPL_ARGS_DEPTH (targs
))
22356 /* We don't have enough levels of args to do any substitution. This
22357 can happen in the context of -fnew-ttp-matching. */;
22360 ++processing_template_decl
;
22361 tparm
= tsubst (tparm
, targs
, tf_none
, NULL_TREE
);
22362 --processing_template_decl
;
22364 if (tree a
= type_uses_auto (tparm
))
22366 tparm
= do_auto_deduction (tparm
, arg
, a
, complain
, adc_unify
);
22367 if (tparm
== error_mark_node
)
22372 if (!TREE_TYPE (arg
))
22373 /* Template-parameter dependent expression. Just accept it for now.
22374 It will later be processed in convert_template_argument. */
22376 else if (same_type_p (non_reference (TREE_TYPE (arg
)),
22377 non_reference (tparm
)))
22379 else if ((strict
& UNIFY_ALLOW_INTEGER
)
22380 && CP_INTEGRAL_TYPE_P (tparm
))
22381 /* Convert the ARG to the type of PARM; the deduced non-type
22382 template argument must exactly match the types of the
22383 corresponding parameter. */
22384 arg
= fold (build_nop (tparm
, arg
));
22385 else if (uses_template_parms (tparm
))
22387 /* We haven't deduced the type of this parameter yet. */
22388 if (cxx_dialect
>= cxx17
22389 /* We deduce from array bounds in try_array_deduction. */
22390 && !(strict
& UNIFY_ALLOW_INTEGER
))
22392 /* Deduce it from the non-type argument. */
22393 tree atype
= TREE_TYPE (arg
);
22394 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
22396 UNIFY_ALLOW_NONE
, explain_p
);
22399 /* Try again later. */
22400 return unify_success (explain_p
);
22403 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
22405 /* If ARG is a parameter pack or an expansion, we cannot unify
22406 against it unless PARM is also a parameter pack. */
22407 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
22408 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
22409 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
22412 bool removed_attr
= false;
22413 arg
= strip_typedefs_expr (arg
, &removed_attr
);
22415 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
22416 return unify_success (explain_p
);
22420 /* A pointer-to-member constant can be unified only with
22421 another constant. */
22422 if (TREE_CODE (arg
) != PTRMEM_CST
)
22423 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
22425 /* Just unify the class member. It would be useless (and possibly
22426 wrong, depending on the strict flags) to unify also
22427 PTRMEM_CST_CLASS, because we want to be sure that both parm and
22428 arg refer to the same variable, even if through different
22429 classes. For instance:
22431 struct A { int x; };
22434 Unification of &A::x and &B::x must succeed. */
22435 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
22436 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
22441 if (!TYPE_PTR_P (arg
))
22442 return unify_type_mismatch (explain_p
, parm
, arg
);
22444 /* [temp.deduct.call]
22446 A can be another pointer or pointer to member type that can
22447 be converted to the deduced A via a qualification
22448 conversion (_conv.qual_).
22450 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
22451 This will allow for additional cv-qualification of the
22452 pointed-to types if appropriate. */
22454 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
22455 /* The derived-to-base conversion only persists through one
22456 level of pointers. */
22457 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
22459 return unify (tparms
, targs
, TREE_TYPE (parm
),
22460 TREE_TYPE (arg
), strict
, explain_p
);
22463 case REFERENCE_TYPE
:
22464 if (!TYPE_REF_P (arg
))
22465 return unify_type_mismatch (explain_p
, parm
, arg
);
22466 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
22467 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
22470 if (TREE_CODE (arg
) != ARRAY_TYPE
)
22471 return unify_type_mismatch (explain_p
, parm
, arg
);
22472 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
22473 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
22474 return unify_type_mismatch (explain_p
, parm
, arg
);
22475 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
22476 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
22477 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
22478 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
22479 TYPE_DOMAIN (arg
), explain_p
);
22480 return unify_success (explain_p
);
22487 case ENUMERAL_TYPE
:
22490 if (TREE_CODE (arg
) != TREE_CODE (parm
))
22491 return unify_type_mismatch (explain_p
, parm
, arg
);
22493 /* We have already checked cv-qualification at the top of the
22495 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
22496 return unify_type_mismatch (explain_p
, parm
, arg
);
22498 /* As far as unification is concerned, this wins. Later checks
22499 will invalidate it if necessary. */
22500 return unify_success (explain_p
);
22502 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
22503 /* Type INTEGER_CST can come from ordinary constant template args. */
22505 while (CONVERT_EXPR_P (arg
))
22506 arg
= TREE_OPERAND (arg
, 0);
22508 if (TREE_CODE (arg
) != INTEGER_CST
)
22509 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22510 return (tree_int_cst_equal (parm
, arg
)
22511 ? unify_success (explain_p
)
22512 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
22516 int i
, len
, argslen
;
22517 int parm_variadic_p
= 0;
22519 if (TREE_CODE (arg
) != TREE_VEC
)
22520 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22522 len
= TREE_VEC_LENGTH (parm
);
22523 argslen
= TREE_VEC_LENGTH (arg
);
22525 /* Check for pack expansions in the parameters. */
22526 for (i
= 0; i
< len
; ++i
)
22528 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
22531 /* We can unify against something with a trailing
22533 parm_variadic_p
= 1;
22535 /* [temp.deduct.type]/9: If the template argument list of
22536 P contains a pack expansion that is not the last
22537 template argument, the entire template argument list
22538 is a non-deduced context. */
22539 return unify_success (explain_p
);
22543 /* If we don't have enough arguments to satisfy the parameters
22544 (not counting the pack expression at the end), or we have
22545 too many arguments for a parameter list that doesn't end in
22546 a pack expression, we can't unify. */
22547 if (parm_variadic_p
22548 ? argslen
< len
- parm_variadic_p
22550 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
22552 /* Unify all of the parameters that precede the (optional)
22553 pack expression. */
22554 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
22556 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
22557 TREE_VEC_ELT (parm
, i
),
22558 TREE_VEC_ELT (arg
, i
),
22559 UNIFY_ALLOW_NONE
, explain_p
);
22561 if (parm_variadic_p
)
22562 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
22564 /*subr=*/true, explain_p
);
22565 return unify_success (explain_p
);
22570 if (TREE_CODE (arg
) != TREE_CODE (parm
))
22571 return unify_type_mismatch (explain_p
, parm
, arg
);
22573 if (TYPE_PTRMEMFUNC_P (parm
))
22575 if (!TYPE_PTRMEMFUNC_P (arg
))
22576 return unify_type_mismatch (explain_p
, parm
, arg
);
22578 return unify (tparms
, targs
,
22579 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
22580 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
22581 strict
, explain_p
);
22583 else if (TYPE_PTRMEMFUNC_P (arg
))
22584 return unify_type_mismatch (explain_p
, parm
, arg
);
22586 if (CLASSTYPE_TEMPLATE_INFO (parm
))
22588 tree t
= NULL_TREE
;
22590 if (strict_in
& UNIFY_ALLOW_DERIVED
)
22592 /* First, we try to unify the PARM and ARG directly. */
22593 t
= try_class_unification (tparms
, targs
,
22594 parm
, arg
, explain_p
);
22598 /* Fallback to the special case allowed in
22599 [temp.deduct.call]:
22601 If P is a class, and P has the form
22602 template-id, then A can be a derived class of
22603 the deduced A. Likewise, if P is a pointer to
22604 a class of the form template-id, A can be a
22605 pointer to a derived class pointed to by the
22607 enum template_base_result r
;
22608 r
= get_template_base (tparms
, targs
, parm
, arg
,
22613 /* Don't give the derived diagnostic if we're
22614 already dealing with the same template. */
22616 = (CLASSTYPE_TEMPLATE_INFO (arg
)
22617 && (CLASSTYPE_TI_TEMPLATE (parm
)
22618 == CLASSTYPE_TI_TEMPLATE (arg
)));
22619 return unify_no_common_base (explain_p
&& !same_template
,
22624 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
22625 && (CLASSTYPE_TI_TEMPLATE (parm
)
22626 == CLASSTYPE_TI_TEMPLATE (arg
)))
22627 /* Perhaps PARM is something like S<U> and ARG is S<int>.
22628 Then, we should unify `int' and `U'. */
22631 /* There's no chance of unification succeeding. */
22632 return unify_type_mismatch (explain_p
, parm
, arg
);
22634 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
22635 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
22637 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
22638 return unify_type_mismatch (explain_p
, parm
, arg
);
22639 return unify_success (explain_p
);
22642 case FUNCTION_TYPE
:
22644 unsigned int nargs
;
22649 if (TREE_CODE (arg
) != TREE_CODE (parm
))
22650 return unify_type_mismatch (explain_p
, parm
, arg
);
22652 /* CV qualifications for methods can never be deduced, they must
22653 match exactly. We need to check them explicitly here,
22654 because type_unification_real treats them as any other
22655 cv-qualified parameter. */
22656 if (TREE_CODE (parm
) == METHOD_TYPE
22657 && (!check_cv_quals_for_unify
22659 class_of_this_parm (arg
),
22660 class_of_this_parm (parm
))))
22661 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22662 if (TREE_CODE (arg
) == FUNCTION_TYPE
22663 && type_memfn_quals (parm
) != type_memfn_quals (arg
))
22664 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22665 if (type_memfn_rqual (parm
) != type_memfn_rqual (arg
))
22666 return unify_type_mismatch (explain_p
, parm
, arg
);
22668 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
22669 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
22671 nargs
= list_length (TYPE_ARG_TYPES (arg
));
22672 args
= XALLOCAVEC (tree
, nargs
);
22673 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
22674 a
!= NULL_TREE
&& a
!= void_list_node
;
22675 a
= TREE_CHAIN (a
), ++i
)
22676 args
[i
] = TREE_VALUE (a
);
22679 if (type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
22680 args
, nargs
, 1, DEDUCE_EXACT
,
22684 if (flag_noexcept_type
)
22686 tree pspec
= TYPE_RAISES_EXCEPTIONS (parm
);
22687 tree aspec
= canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (arg
));
22688 if (pspec
== NULL_TREE
) pspec
= noexcept_false_spec
;
22689 if (aspec
== NULL_TREE
) aspec
= noexcept_false_spec
;
22690 if (TREE_PURPOSE (pspec
) && TREE_PURPOSE (aspec
)
22691 && uses_template_parms (TREE_PURPOSE (pspec
)))
22692 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_PURPOSE (pspec
),
22693 TREE_PURPOSE (aspec
),
22694 UNIFY_ALLOW_NONE
, explain_p
);
22695 else if (nothrow_spec_p (pspec
) && !nothrow_spec_p (aspec
))
22696 return unify_type_mismatch (explain_p
, parm
, arg
);
22703 /* Unify a pointer to member with a pointer to member function, which
22704 deduces the type of the member as a function type. */
22705 if (TYPE_PTRMEMFUNC_P (arg
))
22707 /* Check top-level cv qualifiers */
22708 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
22709 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22711 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
22712 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
22713 UNIFY_ALLOW_NONE
, explain_p
);
22715 /* Determine the type of the function we are unifying against. */
22716 tree fntype
= static_fn_type (arg
);
22718 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
22721 if (TREE_CODE (arg
) != OFFSET_TYPE
)
22722 return unify_type_mismatch (explain_p
, parm
, arg
);
22723 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
22724 TYPE_OFFSET_BASETYPE (arg
),
22725 UNIFY_ALLOW_NONE
, explain_p
);
22726 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
22727 strict
, explain_p
);
22730 if (DECL_TEMPLATE_PARM_P (parm
))
22731 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
22732 if (arg
!= scalar_constant_value (parm
))
22733 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22734 return unify_success (explain_p
);
22737 case TEMPLATE_DECL
:
22738 /* Matched cases are handled by the ARG == PARM test above. */
22739 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22742 /* We might get a variable as a non-type template argument in parm if the
22743 corresponding parameter is type-dependent. Make any necessary
22744 adjustments based on whether arg is a reference. */
22745 if (CONSTANT_CLASS_P (arg
))
22746 parm
= fold_non_dependent_expr (parm
, complain
);
22747 else if (REFERENCE_REF_P (arg
))
22749 tree sub
= TREE_OPERAND (arg
, 0);
22751 if (TREE_CODE (sub
) == ADDR_EXPR
)
22752 arg
= TREE_OPERAND (sub
, 0);
22754 /* Now use the normal expression code to check whether they match. */
22757 case TYPE_ARGUMENT_PACK
:
22758 case NONTYPE_ARGUMENT_PACK
:
22759 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
22760 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
22763 case DECLTYPE_TYPE
:
22764 case UNDERLYING_TYPE
:
22765 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
22766 or UNDERLYING_TYPE nodes. */
22767 return unify_success (explain_p
);
22770 /* Unification fails if we hit an error node. */
22771 return unify_invalid (explain_p
);
22774 if (REFERENCE_REF_P (parm
))
22776 bool pexp
= PACK_EXPANSION_P (arg
);
22778 arg
= PACK_EXPANSION_PATTERN (arg
);
22779 if (REFERENCE_REF_P (arg
))
22780 arg
= TREE_OPERAND (arg
, 0);
22782 arg
= make_pack_expansion (arg
, complain
);
22783 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
22784 strict
, explain_p
);
22789 /* An unresolved overload is a nondeduced context. */
22790 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
22791 return unify_success (explain_p
);
22792 gcc_assert (EXPR_P (parm
) || TREE_CODE (parm
) == TRAIT_EXPR
);
22794 /* We must be looking at an expression. This can happen with
22798 void foo(S<I>, S<I + 2>);
22800 This is a "nondeduced context":
22804 The nondeduced contexts are:
22806 --A type that is a template-id in which one or more of
22807 the template-arguments is an expression that references
22808 a template-parameter.
22810 In these cases, we assume deduction succeeded, but don't
22811 actually infer any unifications. */
22813 if (!uses_template_parms (parm
)
22814 && !template_args_equal (parm
, arg
))
22815 return unify_expression_unequal (explain_p
, parm
, arg
);
22817 return unify_success (explain_p
);
22820 #undef RECUR_AND_CHECK_FAILURE
22822 /* Note that DECL can be defined in this translation unit, if
22826 mark_definable (tree decl
)
22829 DECL_NOT_REALLY_EXTERN (decl
) = 1;
22830 FOR_EACH_CLONE (clone
, decl
)
22831 DECL_NOT_REALLY_EXTERN (clone
) = 1;
22834 /* Called if RESULT is explicitly instantiated, or is a member of an
22835 explicitly instantiated class. */
22838 mark_decl_instantiated (tree result
, int extern_p
)
22840 SET_DECL_EXPLICIT_INSTANTIATION (result
);
22842 /* If this entity has already been written out, it's too late to
22843 make any modifications. */
22844 if (TREE_ASM_WRITTEN (result
))
22847 /* For anonymous namespace we don't need to do anything. */
22848 if (decl_anon_ns_mem_p (result
))
22850 gcc_assert (!TREE_PUBLIC (result
));
22854 if (TREE_CODE (result
) != FUNCTION_DECL
)
22855 /* The TREE_PUBLIC flag for function declarations will have been
22856 set correctly by tsubst. */
22857 TREE_PUBLIC (result
) = 1;
22859 /* This might have been set by an earlier implicit instantiation. */
22860 DECL_COMDAT (result
) = 0;
22863 DECL_NOT_REALLY_EXTERN (result
) = 0;
22866 mark_definable (result
);
22867 mark_needed (result
);
22868 /* Always make artificials weak. */
22869 if (DECL_ARTIFICIAL (result
) && flag_weak
)
22870 comdat_linkage (result
);
22871 /* For WIN32 we also want to put explicit instantiations in
22872 linkonce sections. */
22873 else if (TREE_PUBLIC (result
))
22874 maybe_make_one_only (result
);
22875 if (TREE_CODE (result
) == FUNCTION_DECL
22876 && DECL_TEMPLATE_INSTANTIATED (result
))
22877 /* If the function has already been instantiated, clear DECL_EXTERNAL,
22878 since start_preparsed_function wouldn't have if we had an earlier
22879 extern explicit instantiation. */
22880 DECL_EXTERNAL (result
) = 0;
22883 /* If EXTERN_P, then this function will not be emitted -- unless
22884 followed by an explicit instantiation, at which point its linkage
22885 will be adjusted. If !EXTERN_P, then this function will be
22886 emitted here. In neither circumstance do we want
22887 import_export_decl to adjust the linkage. */
22888 DECL_INTERFACE_KNOWN (result
) = 1;
22891 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
22892 important template arguments. If any are missing, we check whether
22893 they're important by using error_mark_node for substituting into any
22894 args that were used for partial ordering (the ones between ARGS and END)
22895 and seeing if it bubbles up. */
22898 check_undeduced_parms (tree targs
, tree args
, tree end
)
22900 bool found
= false;
22902 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
22903 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
22906 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
22910 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
22911 if (substed
== error_mark_node
)
22917 /* Given two function templates PAT1 and PAT2, return:
22919 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
22920 -1 if PAT2 is more specialized than PAT1.
22921 0 if neither is more specialized.
22923 LEN indicates the number of parameters we should consider
22924 (defaulted parameters should not be considered).
22926 The 1998 std underspecified function template partial ordering, and
22927 DR214 addresses the issue. We take pairs of arguments, one from
22928 each of the templates, and deduce them against each other. One of
22929 the templates will be more specialized if all the *other*
22930 template's arguments deduce against its arguments and at least one
22931 of its arguments *does* *not* deduce against the other template's
22932 corresponding argument. Deduction is done as for class templates.
22933 The arguments used in deduction have reference and top level cv
22934 qualifiers removed. Iff both arguments were originally reference
22935 types *and* deduction succeeds in both directions, an lvalue reference
22936 wins against an rvalue reference and otherwise the template
22937 with the more cv-qualified argument wins for that pairing (if
22938 neither is more cv-qualified, they both are equal). Unlike regular
22939 deduction, after all the arguments have been deduced in this way,
22940 we do *not* verify the deduced template argument values can be
22941 substituted into non-deduced contexts.
22943 The logic can be a bit confusing here, because we look at deduce1 and
22944 targs1 to see if pat2 is at least as specialized, and vice versa; if we
22945 can find template arguments for pat1 to make arg1 look like arg2, that
22946 means that arg2 is at least as specialized as arg1. */
22949 more_specialized_fn (tree pat1
, tree pat2
, int len
)
22951 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
22952 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
22953 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
22954 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
22955 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
22956 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
22957 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
22958 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
22959 tree origs1
, origs2
;
22960 bool lose1
= false;
22961 bool lose2
= false;
22963 /* Remove the this parameter from non-static member functions. If
22964 one is a non-static member function and the other is not a static
22965 member function, remove the first parameter from that function
22966 also. This situation occurs for operator functions where we
22967 locate both a member function (with this pointer) and non-member
22968 operator (with explicit first operand). */
22969 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
22971 len
--; /* LEN is the number of significant arguments for DECL1 */
22972 args1
= TREE_CHAIN (args1
);
22973 if (!DECL_STATIC_FUNCTION_P (decl2
))
22974 args2
= TREE_CHAIN (args2
);
22976 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
22978 args2
= TREE_CHAIN (args2
);
22979 if (!DECL_STATIC_FUNCTION_P (decl1
))
22982 args1
= TREE_CHAIN (args1
);
22986 /* If only one is a conversion operator, they are unordered. */
22987 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
22990 /* Consider the return type for a conversion function */
22991 if (DECL_CONV_FN_P (decl1
))
22993 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
22994 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
22998 processing_template_decl
++;
23004 /* Stop when an ellipsis is seen. */
23005 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
23007 tree arg1
= TREE_VALUE (args1
);
23008 tree arg2
= TREE_VALUE (args2
);
23009 int deduce1
, deduce2
;
23015 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
23016 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
23018 /* When both arguments are pack expansions, we need only
23019 unify the patterns themselves. */
23020 arg1
= PACK_EXPANSION_PATTERN (arg1
);
23021 arg2
= PACK_EXPANSION_PATTERN (arg2
);
23023 /* This is the last comparison we need to do. */
23027 /* DR 1847: If a particular P contains no template-parameters that
23028 participate in template argument deduction, that P is not used to
23029 determine the ordering. */
23030 if (!uses_deducible_template_parms (arg1
)
23031 && !uses_deducible_template_parms (arg2
))
23034 if (TYPE_REF_P (arg1
))
23036 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
23037 arg1
= TREE_TYPE (arg1
);
23038 quals1
= cp_type_quals (arg1
);
23041 if (TYPE_REF_P (arg2
))
23043 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
23044 arg2
= TREE_TYPE (arg2
);
23045 quals2
= cp_type_quals (arg2
);
23048 arg1
= TYPE_MAIN_VARIANT (arg1
);
23049 arg2
= TYPE_MAIN_VARIANT (arg2
);
23051 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
23053 int i
, len2
= remaining_arguments (args2
);
23054 tree parmvec
= make_tree_vec (1);
23055 tree argvec
= make_tree_vec (len2
);
23058 /* Setup the parameter vector, which contains only ARG1. */
23059 TREE_VEC_ELT (parmvec
, 0) = arg1
;
23061 /* Setup the argument vector, which contains the remaining
23063 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
23064 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
23066 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
23067 argvec
, DEDUCE_EXACT
,
23068 /*subr=*/true, /*explain_p=*/false)
23071 /* We cannot deduce in the other direction, because ARG1 is
23072 a pack expansion but ARG2 is not. */
23075 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
23077 int i
, len1
= remaining_arguments (args1
);
23078 tree parmvec
= make_tree_vec (1);
23079 tree argvec
= make_tree_vec (len1
);
23082 /* Setup the parameter vector, which contains only ARG1. */
23083 TREE_VEC_ELT (parmvec
, 0) = arg2
;
23085 /* Setup the argument vector, which contains the remaining
23087 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
23088 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
23090 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
23091 argvec
, DEDUCE_EXACT
,
23092 /*subr=*/true, /*explain_p=*/false)
23095 /* We cannot deduce in the other direction, because ARG2 is
23096 a pack expansion but ARG1 is not.*/
23102 /* The normal case, where neither argument is a pack
23104 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
23105 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
23107 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
23108 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
23112 /* If we couldn't deduce arguments for tparms1 to make arg1 match
23113 arg2, then arg2 is not as specialized as arg1. */
23119 /* "If, for a given type, deduction succeeds in both directions
23120 (i.e., the types are identical after the transformations above)
23121 and both P and A were reference types (before being replaced with
23122 the type referred to above):
23123 - if the type from the argument template was an lvalue reference and
23124 the type from the parameter template was not, the argument type is
23125 considered to be more specialized than the other; otherwise,
23126 - if the type from the argument template is more cv-qualified
23127 than the type from the parameter template (as described above),
23128 the argument type is considered to be more specialized than the other;
23130 - neither type is more specialized than the other." */
23132 if (deduce1
&& deduce2
)
23134 if (ref1
&& ref2
&& ref1
!= ref2
)
23141 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
23143 if ((quals1
& quals2
) == quals2
)
23145 if ((quals1
& quals2
) == quals1
)
23150 if (lose1
&& lose2
)
23151 /* We've failed to deduce something in either direction.
23152 These must be unordered. */
23157 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
23158 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
23159 /* We have already processed all of the arguments in our
23160 handing of the pack expansion type. */
23163 args1
= TREE_CHAIN (args1
);
23164 args2
= TREE_CHAIN (args2
);
23167 /* "In most cases, all template parameters must have values in order for
23168 deduction to succeed, but for partial ordering purposes a template
23169 parameter may remain without a value provided it is not used in the
23170 types being used for partial ordering."
23172 Thus, if we are missing any of the targs1 we need to substitute into
23173 origs1, then pat2 is not as specialized as pat1. This can happen when
23174 there is a nondeduced context. */
23175 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
23177 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
23180 processing_template_decl
--;
23182 /* If both deductions succeed, the partial ordering selects the more
23183 constrained template. */
23184 if (!lose1
&& !lose2
)
23186 tree c1
= get_constraints (DECL_TEMPLATE_RESULT (pat1
));
23187 tree c2
= get_constraints (DECL_TEMPLATE_RESULT (pat2
));
23188 lose1
= !subsumes_constraints (c1
, c2
);
23189 lose2
= !subsumes_constraints (c2
, c1
);
23192 /* All things being equal, if the next argument is a pack expansion
23193 for one function but not for the other, prefer the
23194 non-variadic function. FIXME this is bogus; see c++/41958. */
23196 && args1
&& TREE_VALUE (args1
)
23197 && args2
&& TREE_VALUE (args2
))
23199 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
23200 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
23203 if (lose1
== lose2
)
23211 /* Determine which of two partial specializations of TMPL is more
23214 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
23215 to the first partial specialization. The TREE_PURPOSE is the
23216 innermost set of template parameters for the partial
23217 specialization. PAT2 is similar, but for the second template.
23219 Return 1 if the first partial specialization is more specialized;
23220 -1 if the second is more specialized; 0 if neither is more
23223 See [temp.class.order] for information about determining which of
23224 two templates is more specialized. */
23227 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
23231 bool any_deductions
= false;
23233 tree tmpl1
= TREE_VALUE (pat1
);
23234 tree tmpl2
= TREE_VALUE (pat2
);
23235 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
23236 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
23238 /* Just like what happens for functions, if we are ordering between
23239 different template specializations, we may encounter dependent
23240 types in the arguments, and we need our dependency check functions
23241 to behave correctly. */
23242 ++processing_template_decl
;
23243 targs
= get_partial_spec_bindings (tmpl
, tmpl1
, specargs2
);
23247 any_deductions
= true;
23250 targs
= get_partial_spec_bindings (tmpl
, tmpl2
, specargs1
);
23254 any_deductions
= true;
23256 --processing_template_decl
;
23258 /* If both deductions succeed, the partial ordering selects the more
23259 constrained template. */
23260 if (!winner
&& any_deductions
)
23261 return more_constrained (tmpl1
, tmpl2
);
23263 /* In the case of a tie where at least one of the templates
23264 has a parameter pack at the end, the template with the most
23265 non-packed parameters wins. */
23268 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
23269 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
23271 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
23272 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
23273 int len1
= TREE_VEC_LENGTH (args1
);
23274 int len2
= TREE_VEC_LENGTH (args2
);
23276 /* We don't count the pack expansion at the end. */
23277 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
23279 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
23284 else if (len1
< len2
)
23291 /* Return the template arguments that will produce the function signature
23292 DECL from the function template FN, with the explicit template
23293 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
23294 also match. Return NULL_TREE if no satisfactory arguments could be
23298 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
23300 int ntparms
= DECL_NTPARMS (fn
);
23301 tree targs
= make_tree_vec (ntparms
);
23302 tree decl_type
= TREE_TYPE (decl
);
23303 tree decl_arg_types
;
23305 unsigned int nargs
, ix
;
23308 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
23310 /* Never do unification on the 'this' parameter. */
23311 decl_arg_types
= skip_artificial_parms_for (decl
,
23312 TYPE_ARG_TYPES (decl_type
));
23314 nargs
= list_length (decl_arg_types
);
23315 args
= XALLOCAVEC (tree
, nargs
);
23316 for (arg
= decl_arg_types
, ix
= 0;
23317 arg
!= NULL_TREE
&& arg
!= void_list_node
;
23318 arg
= TREE_CHAIN (arg
), ++ix
)
23319 args
[ix
] = TREE_VALUE (arg
);
23321 if (fn_type_unification (fn
, explicit_args
, targs
,
23323 (check_rettype
|| DECL_CONV_FN_P (fn
)
23324 ? TREE_TYPE (decl_type
) : NULL_TREE
),
23325 DEDUCE_EXACT
, LOOKUP_NORMAL
, NULL
,
23326 /*explain_p=*/false,
23328 == error_mark_node
)
23334 /* Return the innermost template arguments that, when applied to a partial
23335 specialization SPEC_TMPL of TMPL, yield the ARGS.
23337 For example, suppose we have:
23339 template <class T, class U> struct S {};
23340 template <class T> struct S<T*, int> {};
23342 Then, suppose we want to get `S<double*, int>'. SPEC_TMPL will be the
23343 partial specialization and the ARGS will be {double*, int}. The resulting
23344 vector will be {double}, indicating that `T' is bound to `double'. */
23347 get_partial_spec_bindings (tree tmpl
, tree spec_tmpl
, tree args
)
23349 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
23351 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (spec_tmpl
)));
23352 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
23354 tree innermost_deduced_args
;
23356 innermost_deduced_args
= make_tree_vec (ntparms
);
23357 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
23359 deduced_args
= copy_node (args
);
23360 SET_TMPL_ARGS_LEVEL (deduced_args
,
23361 TMPL_ARGS_DEPTH (deduced_args
),
23362 innermost_deduced_args
);
23365 deduced_args
= innermost_deduced_args
;
23367 bool tried_array_deduction
= (cxx_dialect
< cxx17
);
23369 if (unify (tparms
, deduced_args
,
23370 INNERMOST_TEMPLATE_ARGS (spec_args
),
23371 INNERMOST_TEMPLATE_ARGS (args
),
23372 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
23375 for (i
= 0; i
< ntparms
; ++i
)
23376 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
23378 if (!tried_array_deduction
)
23380 try_array_deduction (tparms
, innermost_deduced_args
,
23381 INNERMOST_TEMPLATE_ARGS (spec_args
));
23382 tried_array_deduction
= true;
23383 if (TREE_VEC_ELT (innermost_deduced_args
, i
))
23389 if (!push_tinst_level (spec_tmpl
, deduced_args
))
23391 excessive_deduction_depth
= true;
23395 /* Verify that nondeduced template arguments agree with the type
23396 obtained from argument deduction.
23400 struct A { typedef int X; };
23401 template <class T, class U> struct C {};
23402 template <class T> struct C<T, typename T::X> {};
23404 Then with the instantiation `C<A, int>', we can deduce that
23405 `T' is `A' but unify () does not check whether `typename T::X'
23407 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
23409 if (spec_args
!= error_mark_node
)
23410 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
23411 INNERMOST_TEMPLATE_ARGS (spec_args
),
23412 tmpl
, tf_none
, false, false);
23414 pop_tinst_level ();
23416 if (spec_args
== error_mark_node
23417 /* We only need to check the innermost arguments; the other
23418 arguments will always agree. */
23419 || !comp_template_args_porder (INNERMOST_TEMPLATE_ARGS (spec_args
),
23420 INNERMOST_TEMPLATE_ARGS (args
)))
23423 /* Now that we have bindings for all of the template arguments,
23424 ensure that the arguments deduced for the template template
23425 parameters have compatible template parameter lists. See the use
23426 of template_template_parm_bindings_ok_p in fn_type_unification
23427 for more information. */
23428 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
23431 return deduced_args
;
23434 // Compare two function templates T1 and T2 by deducing bindings
23435 // from one against the other. If both deductions succeed, compare
23436 // constraints to see which is more constrained.
23438 more_specialized_inst (tree t1
, tree t2
)
23443 if (get_bindings (t1
, DECL_TEMPLATE_RESULT (t2
), NULL_TREE
, true))
23449 if (get_bindings (t2
, DECL_TEMPLATE_RESULT (t1
), NULL_TREE
, true))
23455 // If both deductions succeed, then one may be more constrained.
23456 if (count
== 2 && fate
== 0)
23457 fate
= more_constrained (t1
, t2
);
23462 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
23463 Return the TREE_LIST node with the most specialized template, if
23464 any. If there is no most specialized template, the error_mark_node
23467 Note that this function does not look at, or modify, the
23468 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
23469 returned is one of the elements of INSTANTIATIONS, callers may
23470 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
23471 and retrieve it from the value returned. */
23474 most_specialized_instantiation (tree templates
)
23478 ++processing_template_decl
;
23481 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
23483 gcc_assert (TREE_VALUE (champ
) != TREE_VALUE (fn
));
23484 int fate
= more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
));
23489 /* Equally specialized, move to next function. If there
23490 is no next function, nothing's most specialized. */
23491 fn
= TREE_CHAIN (fn
);
23499 /* Now verify that champ is better than everything earlier in the
23500 instantiation list. */
23501 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
)) {
23502 if (more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
)) != 1)
23509 processing_template_decl
--;
23512 return error_mark_node
;
23517 /* If DECL is a specialization of some template, return the most
23518 general such template. Otherwise, returns NULL_TREE.
23520 For example, given:
23522 template <class T> struct S { template <class U> void f(U); };
23524 if TMPL is `template <class U> void S<int>::f(U)' this will return
23525 the full template. This function will not trace past partial
23526 specializations, however. For example, given in addition:
23528 template <class T> struct S<T*> { template <class U> void f(U); };
23530 if TMPL is `template <class U> void S<int*>::f(U)' this will return
23531 `template <class T> template <class U> S<T*>::f(U)'. */
23534 most_general_template (tree decl
)
23536 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
23538 if (tree tinfo
= get_template_info (decl
))
23539 decl
= TI_TEMPLATE (tinfo
);
23540 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
23541 template friend, or a FIELD_DECL for a capture pack. */
23542 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
23546 /* Look for more and more general templates. */
23547 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
23549 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
23550 (See cp-tree.h for details.) */
23551 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
23554 if (CLASS_TYPE_P (TREE_TYPE (decl
))
23555 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
23556 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
23559 /* Stop if we run into an explicitly specialized class template. */
23560 if (!DECL_NAMESPACE_SCOPE_P (decl
)
23561 && DECL_CONTEXT (decl
)
23562 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
23565 decl
= DECL_TI_TEMPLATE (decl
);
23571 /* Return the most specialized of the template partial specializations
23572 which can produce TARGET, a specialization of some class or variable
23573 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
23574 a TEMPLATE_DECL node corresponding to the partial specialization, while
23575 the TREE_PURPOSE is the set of template arguments that must be
23576 substituted into the template pattern in order to generate TARGET.
23578 If the choice of partial specialization is ambiguous, a diagnostic
23579 is issued, and the error_mark_node is returned. If there are no
23580 partial specializations matching TARGET, then NULL_TREE is
23581 returned, indicating that the primary template should be used. */
23584 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
23586 tree list
= NULL_TREE
;
23591 tree outer_args
= NULL_TREE
;
23594 if (TYPE_P (target
))
23596 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
23597 tmpl
= TI_TEMPLATE (tinfo
);
23598 args
= TI_ARGS (tinfo
);
23600 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
23602 tmpl
= TREE_OPERAND (target
, 0);
23603 args
= TREE_OPERAND (target
, 1);
23605 else if (VAR_P (target
))
23607 tree tinfo
= DECL_TEMPLATE_INFO (target
);
23608 tmpl
= TI_TEMPLATE (tinfo
);
23609 args
= TI_ARGS (tinfo
);
23612 gcc_unreachable ();
23614 tree main_tmpl
= most_general_template (tmpl
);
23616 /* For determining which partial specialization to use, only the
23617 innermost args are interesting. */
23618 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
23620 outer_args
= strip_innermost_template_args (args
, 1);
23621 args
= INNERMOST_TEMPLATE_ARGS (args
);
23624 /* The caller hasn't called push_to_top_level yet, but we need
23625 get_partial_spec_bindings to be done in non-template context so that we'll
23626 fully resolve everything. */
23627 processing_template_decl_sentinel ptds
;
23629 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
23632 tree spec_tmpl
= TREE_VALUE (t
);
23636 /* Substitute in the template args from the enclosing class. */
23637 ++processing_template_decl
;
23638 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
23639 --processing_template_decl
;
23642 if (spec_tmpl
== error_mark_node
)
23643 return error_mark_node
;
23645 spec_args
= get_partial_spec_bindings (tmpl
, spec_tmpl
, args
);
23649 spec_args
= add_to_template_args (outer_args
, spec_args
);
23651 /* Keep the candidate only if the constraints are satisfied,
23652 or if we're not compiling with concepts. */
23654 || constraints_satisfied_p (spec_tmpl
, spec_args
))
23656 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
23657 TREE_TYPE (list
) = TREE_TYPE (t
);
23665 ambiguous_p
= false;
23668 t
= TREE_CHAIN (t
);
23669 for (; t
; t
= TREE_CHAIN (t
))
23671 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
23678 t
= TREE_CHAIN (t
);
23681 ambiguous_p
= true;
23690 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
23692 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
23695 ambiguous_p
= true;
23703 char *spaces
= NULL
;
23704 if (!(complain
& tf_error
))
23705 return error_mark_node
;
23706 if (TYPE_P (target
))
23707 error ("ambiguous template instantiation for %q#T", target
);
23709 error ("ambiguous template instantiation for %q#D", target
);
23710 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
23711 for (t
= list
; t
; t
= TREE_CHAIN (t
))
23713 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
23714 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
23715 "%s %#qS", spaces
? spaces
: str
, subst
);
23716 spaces
= spaces
? spaces
: get_spaces (str
);
23719 return error_mark_node
;
23725 /* Explicitly instantiate DECL. */
23728 do_decl_instantiation (tree decl
, tree storage
)
23730 tree result
= NULL_TREE
;
23733 if (!decl
|| decl
== error_mark_node
)
23734 /* An error occurred, for which grokdeclarator has already issued
23735 an appropriate message. */
23737 else if (! DECL_LANG_SPECIFIC (decl
))
23739 error ("explicit instantiation of non-template %q#D", decl
);
23742 else if (DECL_DECLARED_CONCEPT_P (decl
))
23745 error ("explicit instantiation of variable concept %q#D", decl
);
23747 error ("explicit instantiation of function concept %q#D", decl
);
23751 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
23752 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
23754 if (VAR_P (decl
) && !var_templ
)
23756 /* There is an asymmetry here in the way VAR_DECLs and
23757 FUNCTION_DECLs are handled by grokdeclarator. In the case of
23758 the latter, the DECL we get back will be marked as a
23759 template instantiation, and the appropriate
23760 DECL_TEMPLATE_INFO will be set up. This does not happen for
23761 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
23762 should handle VAR_DECLs as it currently handles
23764 if (!DECL_CLASS_SCOPE_P (decl
))
23766 error ("%qD is not a static data member of a class template", decl
);
23769 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
23770 if (!result
|| !VAR_P (result
))
23772 error ("no matching template for %qD found", decl
);
23775 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
23777 error ("type %qT for explicit instantiation %qD does not match "
23778 "declared type %qT", TREE_TYPE (result
), decl
,
23783 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
23785 error ("explicit instantiation of %q#D", decl
);
23791 /* Check for various error cases. Note that if the explicit
23792 instantiation is valid the RESULT will currently be marked as an
23793 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
23794 until we get here. */
23796 if (DECL_TEMPLATE_SPECIALIZATION (result
))
23798 /* DR 259 [temp.spec].
23800 Both an explicit instantiation and a declaration of an explicit
23801 specialization shall not appear in a program unless the explicit
23802 instantiation follows a declaration of the explicit specialization.
23804 For a given set of template parameters, if an explicit
23805 instantiation of a template appears after a declaration of an
23806 explicit specialization for that template, the explicit
23807 instantiation has no effect. */
23810 else if (DECL_EXPLICIT_INSTANTIATION (result
))
23814 No program shall explicitly instantiate any template more
23817 We check DECL_NOT_REALLY_EXTERN so as not to complain when
23818 the first instantiation was `extern' and the second is not,
23819 and EXTERN_P for the opposite case. */
23820 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
23821 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
23822 /* If an "extern" explicit instantiation follows an ordinary
23823 explicit instantiation, the template is instantiated. */
23827 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
23829 error ("no matching template for %qD found", result
);
23832 else if (!DECL_TEMPLATE_INFO (result
))
23834 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
23838 if (storage
== NULL_TREE
)
23840 else if (storage
== ridpointers
[(int) RID_EXTERN
])
23842 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
23843 pedwarn (input_location
, OPT_Wpedantic
,
23844 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
23849 error ("storage class %qD applied to template instantiation", storage
);
23851 check_explicit_instantiation_namespace (result
);
23852 mark_decl_instantiated (result
, extern_p
);
23854 instantiate_decl (result
, /*defer_ok=*/true,
23855 /*expl_inst_class_mem_p=*/false);
23859 mark_class_instantiated (tree t
, int extern_p
)
23861 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
23862 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
23863 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
23864 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
23867 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
23868 rest_of_type_compilation (t
, 1);
23872 /* Called from do_type_instantiation through binding_table_foreach to
23873 do recursive instantiation for the type bound in ENTRY. */
23875 bt_instantiate_type_proc (binding_entry entry
, void *data
)
23877 tree storage
= *(tree
*) data
;
23879 if (MAYBE_CLASS_TYPE_P (entry
->type
)
23880 && CLASSTYPE_TEMPLATE_INFO (entry
->type
)
23881 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
23882 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
23885 /* Perform an explicit instantiation of template class T. STORAGE, if
23886 non-null, is the RID for extern, inline or static. COMPLAIN is
23887 nonzero if this is called from the parser, zero if called recursively,
23888 since the standard is unclear (as detailed below). */
23891 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
23896 int previous_instantiation_extern_p
= 0;
23898 if (TREE_CODE (t
) == TYPE_DECL
)
23901 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
23904 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
23906 error ("explicit instantiation of non-class template %qD", tmpl
);
23908 error ("explicit instantiation of non-template type %qT", t
);
23914 if (!COMPLETE_TYPE_P (t
))
23916 if (complain
& tf_error
)
23917 error ("explicit instantiation of %q#T before definition of template",
23922 if (storage
!= NULL_TREE
)
23924 if (!in_system_header_at (input_location
))
23926 if (storage
== ridpointers
[(int) RID_EXTERN
])
23928 if (cxx_dialect
== cxx98
)
23929 pedwarn (input_location
, OPT_Wpedantic
,
23930 "ISO C++ 1998 forbids the use of %<extern%> on "
23931 "explicit instantiations");
23934 pedwarn (input_location
, OPT_Wpedantic
,
23935 "ISO C++ forbids the use of %qE"
23936 " on explicit instantiations", storage
);
23939 if (storage
== ridpointers
[(int) RID_INLINE
])
23941 else if (storage
== ridpointers
[(int) RID_EXTERN
])
23943 else if (storage
== ridpointers
[(int) RID_STATIC
])
23947 error ("storage class %qD applied to template instantiation",
23953 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
23955 /* DR 259 [temp.spec].
23957 Both an explicit instantiation and a declaration of an explicit
23958 specialization shall not appear in a program unless the explicit
23959 instantiation follows a declaration of the explicit specialization.
23961 For a given set of template parameters, if an explicit
23962 instantiation of a template appears after a declaration of an
23963 explicit specialization for that template, the explicit
23964 instantiation has no effect. */
23967 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
23971 No program shall explicitly instantiate any template more
23974 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
23975 instantiation was `extern'. If EXTERN_P then the second is.
23976 These cases are OK. */
23977 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
23979 if (!previous_instantiation_extern_p
&& !extern_p
23980 && (complain
& tf_error
))
23981 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
23983 /* If we've already instantiated the template, just return now. */
23984 if (!CLASSTYPE_INTERFACE_ONLY (t
))
23988 check_explicit_instantiation_namespace (TYPE_NAME (t
));
23989 mark_class_instantiated (t
, extern_p
);
23994 /* In contrast to implicit instantiation, where only the
23995 declarations, and not the definitions, of members are
23996 instantiated, we have here:
24000 The explicit instantiation of a class template specialization
24001 implies the instantiation of all of its members not
24002 previously explicitly specialized in the translation unit
24003 containing the explicit instantiation.
24005 Of course, we can't instantiate member template classes, since we
24006 don't have any arguments for them. Note that the standard is
24007 unclear on whether the instantiation of the members are
24008 *explicit* instantiations or not. However, the most natural
24009 interpretation is that it should be an explicit
24011 for (tree fld
= TYPE_FIELDS (t
); fld
; fld
= DECL_CHAIN (fld
))
24013 || (TREE_CODE (fld
) == FUNCTION_DECL
24015 && user_provided_p (fld
)))
24016 && DECL_TEMPLATE_INSTANTIATION (fld
))
24018 mark_decl_instantiated (fld
, extern_p
);
24020 instantiate_decl (fld
, /*defer_ok=*/true,
24021 /*expl_inst_class_mem_p=*/true);
24024 if (CLASSTYPE_NESTED_UTDS (t
))
24025 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
24026 bt_instantiate_type_proc
, &storage
);
24029 /* Given a function DECL, which is a specialization of TMPL, modify
24030 DECL to be a re-instantiation of TMPL with the same template
24031 arguments. TMPL should be the template into which tsubst'ing
24032 should occur for DECL, not the most general template.
24034 One reason for doing this is a scenario like this:
24037 void f(const T&, int i);
24039 void g() { f(3, 7); }
24042 void f(const T& t, const int i) { }
24044 Note that when the template is first instantiated, with
24045 instantiate_template, the resulting DECL will have no name for the
24046 first parameter, and the wrong type for the second. So, when we go
24047 to instantiate the DECL, we regenerate it. */
24050 regenerate_decl_from_template (tree decl
, tree tmpl
, tree args
)
24052 /* The arguments used to instantiate DECL, from the most general
24056 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
24058 /* Make sure that we can see identifiers, and compute access
24060 push_access_scope (decl
);
24062 if (TREE_CODE (decl
) == FUNCTION_DECL
)
24070 args_depth
= TMPL_ARGS_DEPTH (args
);
24071 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
24072 if (args_depth
> parms_depth
)
24073 args
= get_innermost_template_args (args
, parms_depth
);
24075 /* Instantiate a dynamic exception-specification. noexcept will be
24077 if (tree raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (code_pattern
)))
24078 if (TREE_VALUE (raises
))
24080 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
24081 args
, tf_error
, NULL_TREE
,
24082 /*defer_ok*/false);
24083 if (specs
&& specs
!= error_mark_node
)
24084 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
24088 /* Merge parameter declarations. */
24089 decl_parm
= skip_artificial_parms_for (decl
,
24090 DECL_ARGUMENTS (decl
));
24092 = skip_artificial_parms_for (code_pattern
,
24093 DECL_ARGUMENTS (code_pattern
));
24094 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
24099 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
24100 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
24101 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
24103 parm_type
= type_decays_to (parm_type
);
24104 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
24105 TREE_TYPE (decl_parm
) = parm_type
;
24106 attributes
= DECL_ATTRIBUTES (pattern_parm
);
24107 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
24109 DECL_ATTRIBUTES (decl_parm
) = attributes
;
24110 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
24112 decl_parm
= DECL_CHAIN (decl_parm
);
24113 pattern_parm
= DECL_CHAIN (pattern_parm
);
24115 /* Merge any parameters that match with the function parameter
24117 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
24120 tree expanded_types
;
24121 /* Expand the TYPE_PACK_EXPANSION that provides the types for
24122 the parameters in this function parameter pack. */
24123 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
24124 args
, tf_error
, NULL_TREE
);
24125 len
= TREE_VEC_LENGTH (expanded_types
);
24126 for (i
= 0; i
< len
; i
++)
24131 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
24132 /* Rename the parameter to include the index. */
24133 DECL_NAME (decl_parm
) =
24134 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
24135 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
24136 parm_type
= type_decays_to (parm_type
);
24137 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
24138 TREE_TYPE (decl_parm
) = parm_type
;
24139 attributes
= DECL_ATTRIBUTES (pattern_parm
);
24140 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
24142 DECL_ATTRIBUTES (decl_parm
) = attributes
;
24143 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
24145 decl_parm
= DECL_CHAIN (decl_parm
);
24148 /* Merge additional specifiers from the CODE_PATTERN. */
24149 if (DECL_DECLARED_INLINE_P (code_pattern
)
24150 && !DECL_DECLARED_INLINE_P (decl
))
24151 DECL_DECLARED_INLINE_P (decl
) = 1;
24153 maybe_instantiate_noexcept (decl
, tf_error
);
24155 else if (VAR_P (decl
))
24157 start_lambda_scope (decl
);
24158 DECL_INITIAL (decl
) =
24159 tsubst_init (DECL_INITIAL (code_pattern
), decl
, args
,
24160 tf_error
, DECL_TI_TEMPLATE (decl
));
24161 finish_lambda_scope ();
24162 if (VAR_HAD_UNKNOWN_BOUND (decl
))
24163 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
24164 tf_error
, DECL_TI_TEMPLATE (decl
));
24167 gcc_unreachable ();
24169 pop_access_scope (decl
);
24172 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
24173 substituted to get DECL. */
24176 template_for_substitution (tree decl
)
24178 tree tmpl
= DECL_TI_TEMPLATE (decl
);
24180 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
24181 for the instantiation. This is not always the most general
24182 template. Consider, for example:
24185 struct S { template <class U> void f();
24186 template <> void f<int>(); };
24188 and an instantiation of S<double>::f<int>. We want TD to be the
24189 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
24190 while (/* An instantiation cannot have a definition, so we need a
24191 more general template. */
24192 DECL_TEMPLATE_INSTANTIATION (tmpl
)
24193 /* We must also deal with friend templates. Given:
24195 template <class T> struct S {
24196 template <class U> friend void f() {};
24199 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
24200 so far as the language is concerned, but that's still
24201 where we get the pattern for the instantiation from. On
24202 other hand, if the definition comes outside the class, say:
24204 template <class T> struct S {
24205 template <class U> friend void f();
24207 template <class U> friend void f() {}
24209 we don't need to look any further. That's what the check for
24210 DECL_INITIAL is for. */
24211 || (TREE_CODE (decl
) == FUNCTION_DECL
24212 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
24213 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
24215 /* The present template, TD, should not be a definition. If it
24216 were a definition, we should be using it! Note that we
24217 cannot restructure the loop to just keep going until we find
24218 a template with a definition, since that might go too far if
24219 a specialization was declared, but not defined. */
24221 /* Fetch the more general template. */
24222 tmpl
= DECL_TI_TEMPLATE (tmpl
);
24228 /* Returns true if we need to instantiate this template instance even if we
24229 know we aren't going to emit it. */
24232 always_instantiate_p (tree decl
)
24234 /* We always instantiate inline functions so that we can inline them. An
24235 explicit instantiation declaration prohibits implicit instantiation of
24236 non-inline functions. With high levels of optimization, we would
24237 normally inline non-inline functions -- but we're not allowed to do
24238 that for "extern template" functions. Therefore, we check
24239 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
24240 return ((TREE_CODE (decl
) == FUNCTION_DECL
24241 && (DECL_DECLARED_INLINE_P (decl
)
24242 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
24243 /* And we need to instantiate static data members so that
24244 their initializers are available in integral constant
24247 && decl_maybe_constant_var_p (decl
)));
24250 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
24251 instantiate it now, modifying TREE_TYPE (fn). Returns false on
24252 error, true otherwise. */
24255 maybe_instantiate_noexcept (tree fn
, tsubst_flags_t complain
)
24257 tree fntype
, spec
, noex
, clone
;
24259 /* Don't instantiate a noexcept-specification from template context. */
24260 if (processing_template_decl
24261 && (!flag_noexcept_type
|| type_dependent_expression_p (fn
)))
24264 if (DECL_CLONED_FUNCTION_P (fn
))
24265 fn
= DECL_CLONED_FUNCTION (fn
);
24267 tree orig_fn
= NULL_TREE
;
24268 /* For a member friend template we can get a TEMPLATE_DECL. Let's use
24269 its FUNCTION_DECL for the rest of this function -- push_access_scope
24270 doesn't accept TEMPLATE_DECLs. */
24271 if (DECL_FUNCTION_TEMPLATE_P (fn
))
24274 fn
= DECL_TEMPLATE_RESULT (fn
);
24277 fntype
= TREE_TYPE (fn
);
24278 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
24280 if (!spec
|| !TREE_PURPOSE (spec
))
24283 noex
= TREE_PURPOSE (spec
);
24285 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
24287 static hash_set
<tree
>* fns
= new hash_set
<tree
>;
24288 bool added
= false;
24289 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
24291 spec
= get_defaulted_eh_spec (fn
, complain
);
24292 if (spec
== error_mark_node
)
24293 /* This might have failed because of an unparsed DMI, so
24294 let's try again later. */
24297 else if (!(added
= !fns
->add (fn
)))
24299 /* If hash_set::add returns true, the element was already there. */
24300 location_t loc
= cp_expr_loc_or_loc (DEFERRED_NOEXCEPT_PATTERN (noex
),
24301 DECL_SOURCE_LOCATION (fn
));
24303 "exception specification of %qD depends on itself",
24305 spec
= noexcept_false_spec
;
24307 else if (push_tinst_level (fn
))
24309 push_access_scope (fn
);
24310 push_deferring_access_checks (dk_no_deferred
);
24311 input_location
= DECL_SOURCE_LOCATION (fn
);
24313 tree save_ccp
= current_class_ptr
;
24314 tree save_ccr
= current_class_ref
;
24315 /* If needed, set current_class_ptr for the benefit of
24316 tsubst_copy/PARM_DECL. */
24317 tree tdecl
= DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (fn
));
24318 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tdecl
))
24320 tree this_parm
= DECL_ARGUMENTS (tdecl
);
24321 current_class_ptr
= NULL_TREE
;
24322 current_class_ref
= cp_build_fold_indirect_ref (this_parm
);
24323 current_class_ptr
= this_parm
;
24326 /* If this function is represented by a TEMPLATE_DECL, then
24327 the deferred noexcept-specification might still contain
24328 dependent types, even after substitution. And we need the
24329 dependency check functions to work in build_noexcept_spec. */
24331 ++processing_template_decl
;
24333 /* Do deferred instantiation of the noexcept-specifier. */
24334 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
24335 DEFERRED_NOEXCEPT_ARGS (noex
),
24336 tf_warning_or_error
, fn
,
24337 /*function_p=*/false,
24340 current_class_ptr
= save_ccp
;
24341 current_class_ref
= save_ccr
;
24343 /* Build up the noexcept-specification. */
24344 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
24347 --processing_template_decl
;
24349 pop_deferring_access_checks ();
24350 pop_access_scope (fn
);
24351 pop_tinst_level ();
24354 spec
= noexcept_false_spec
;
24359 if (spec
== error_mark_node
)
24361 /* This failed with a hard error, so let's go with false. */
24362 gcc_assert (seen_error ());
24363 spec
= noexcept_false_spec
;
24366 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
24368 TREE_TYPE (orig_fn
) = TREE_TYPE (fn
);
24371 FOR_EACH_CLONE (clone
, fn
)
24373 if (TREE_TYPE (clone
) == fntype
)
24374 TREE_TYPE (clone
) = TREE_TYPE (fn
);
24376 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
24382 /* We're starting to process the function INST, an instantiation of PATTERN;
24383 add their parameters to local_specializations. */
24386 register_parameter_specializations (tree pattern
, tree inst
)
24388 tree tmpl_parm
= DECL_ARGUMENTS (pattern
);
24389 tree spec_parm
= DECL_ARGUMENTS (inst
);
24390 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (inst
))
24392 register_local_specialization (spec_parm
, tmpl_parm
);
24393 spec_parm
= skip_artificial_parms_for (inst
, spec_parm
);
24394 tmpl_parm
= skip_artificial_parms_for (pattern
, tmpl_parm
);
24396 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
24398 if (!DECL_PACK_P (tmpl_parm
))
24400 register_local_specialization (spec_parm
, tmpl_parm
);
24401 spec_parm
= DECL_CHAIN (spec_parm
);
24405 /* Register the (value) argument pack as a specialization of
24406 TMPL_PARM, then move on. */
24407 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
24408 register_local_specialization (argpack
, tmpl_parm
);
24411 gcc_assert (!spec_parm
);
24414 /* Produce the definition of D, a _DECL generated from a template. If
24415 DEFER_OK is true, then we don't have to actually do the
24416 instantiation now; we just have to do it sometime. Normally it is
24417 an error if this is an explicit instantiation but D is undefined.
24418 EXPL_INST_CLASS_MEM_P is true iff D is a member of an explicitly
24419 instantiated class template. */
24422 instantiate_decl (tree d
, bool defer_ok
, bool expl_inst_class_mem_p
)
24424 tree tmpl
= DECL_TI_TEMPLATE (d
);
24431 bool pattern_defined
;
24432 location_t saved_loc
= input_location
;
24433 int saved_unevaluated_operand
= cp_unevaluated_operand
;
24434 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
24438 /* This function should only be used to instantiate templates for
24439 functions and static member variables. */
24440 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
24442 /* A concept is never instantiated. */
24443 gcc_assert (!DECL_DECLARED_CONCEPT_P (d
));
24445 /* Variables are never deferred; if instantiation is required, they
24446 are instantiated right away. That allows for better code in the
24447 case that an expression refers to the value of the variable --
24448 if the variable has a constant value the referring expression can
24449 take advantage of that fact. */
24453 /* Don't instantiate cloned functions. Instead, instantiate the
24454 functions they cloned. */
24455 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
24456 d
= DECL_CLONED_FUNCTION (d
);
24458 if (DECL_TEMPLATE_INSTANTIATED (d
)
24459 || (TREE_CODE (d
) == FUNCTION_DECL
24460 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
24461 || DECL_TEMPLATE_SPECIALIZATION (d
))
24462 /* D has already been instantiated or explicitly specialized, so
24463 there's nothing for us to do here.
24465 It might seem reasonable to check whether or not D is an explicit
24466 instantiation, and, if so, stop here. But when an explicit
24467 instantiation is deferred until the end of the compilation,
24468 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
24469 the instantiation. */
24472 /* Check to see whether we know that this template will be
24473 instantiated in some other file, as with "extern template"
24475 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
24477 /* In general, we do not instantiate such templates. */
24478 if (external_p
&& !always_instantiate_p (d
))
24481 gen_tmpl
= most_general_template (tmpl
);
24482 gen_args
= DECL_TI_ARGS (d
);
24484 if (tmpl
!= gen_tmpl
)
24485 /* We should already have the extra args. */
24486 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
24487 == TMPL_ARGS_DEPTH (gen_args
));
24488 /* And what's in the hash table should match D. */
24489 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
24490 || spec
== NULL_TREE
);
24492 /* This needs to happen before any tsubsting. */
24493 if (! push_tinst_level (d
))
24496 timevar_push (TV_TEMPLATE_INST
);
24498 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
24499 for the instantiation. */
24500 td
= template_for_substitution (d
);
24505 /* Look up an explicit specialization, if any. */
24506 tree tid
= lookup_template_variable (gen_tmpl
, gen_args
);
24507 tree elt
= most_specialized_partial_spec (tid
, tf_warning_or_error
);
24508 if (elt
&& elt
!= error_mark_node
)
24510 td
= TREE_VALUE (elt
);
24511 args
= TREE_PURPOSE (elt
);
24515 code_pattern
= DECL_TEMPLATE_RESULT (td
);
24517 /* We should never be trying to instantiate a member of a class
24518 template or partial specialization. */
24519 gcc_assert (d
!= code_pattern
);
24521 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
24522 || DECL_TEMPLATE_SPECIALIZATION (td
))
24523 /* In the case of a friend template whose definition is provided
24524 outside the class, we may have too many arguments. Drop the
24525 ones we don't need. The same is true for specializations. */
24526 args
= get_innermost_template_args
24527 (args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
24529 if (TREE_CODE (d
) == FUNCTION_DECL
)
24531 deleted_p
= DECL_DELETED_FN (code_pattern
);
24532 pattern_defined
= ((DECL_SAVED_TREE (code_pattern
) != NULL_TREE
24533 && DECL_INITIAL (code_pattern
) != error_mark_node
)
24534 || DECL_DEFAULTED_FN (code_pattern
)
24540 if (DECL_CLASS_SCOPE_P (code_pattern
))
24541 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
24543 pattern_defined
= ! DECL_EXTERNAL (code_pattern
);
24546 /* We may be in the middle of deferred access check. Disable it now. */
24547 push_deferring_access_checks (dk_no_deferred
);
24549 /* Unless an explicit instantiation directive has already determined
24550 the linkage of D, remember that a definition is available for
24552 if (pattern_defined
24553 && !DECL_INTERFACE_KNOWN (d
)
24554 && !DECL_NOT_REALLY_EXTERN (d
))
24555 mark_definable (d
);
24557 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
24558 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
24559 input_location
= DECL_SOURCE_LOCATION (d
);
24561 /* If D is a member of an explicitly instantiated class template,
24562 and no definition is available, treat it like an implicit
24564 if (!pattern_defined
&& expl_inst_class_mem_p
24565 && DECL_EXPLICIT_INSTANTIATION (d
))
24567 /* Leave linkage flags alone on instantiations with anonymous
24569 if (TREE_PUBLIC (d
))
24571 DECL_NOT_REALLY_EXTERN (d
) = 0;
24572 DECL_INTERFACE_KNOWN (d
) = 0;
24574 SET_DECL_IMPLICIT_INSTANTIATION (d
);
24577 /* Defer all other templates, unless we have been explicitly
24578 forbidden from doing so. */
24579 if (/* If there is no definition, we cannot instantiate the
24582 /* If it's OK to postpone instantiation, do so. */
24584 /* If this is a static data member that will be defined
24585 elsewhere, we don't want to instantiate the entire data
24586 member, but we do want to instantiate the initializer so that
24587 we can substitute that elsewhere. */
24588 || (external_p
&& VAR_P (d
))
24589 /* Handle here a deleted function too, avoid generating
24590 its body (c++/61080). */
24593 /* The definition of the static data member is now required so
24594 we must substitute the initializer. */
24596 && !DECL_INITIAL (d
)
24597 && DECL_INITIAL (code_pattern
))
24601 bool const_init
= false;
24602 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
24604 ns
= decl_namespace_context (d
);
24605 push_nested_namespace (ns
);
24607 push_nested_class (DECL_CONTEXT (d
));
24608 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
24610 tf_warning_or_error
, NULL_TREE
,
24611 /*integral_constant_expression_p=*/false);
24612 /* If instantiating the initializer involved instantiating this
24613 again, don't call cp_finish_decl twice. */
24614 if (!DECL_INITIAL (d
))
24616 /* Make sure the initializer is still constant, in case of
24617 circular dependency (template/instantiate6.C). */
24619 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
24620 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
24621 /*asmspec_tree=*/NULL_TREE
,
24622 LOOKUP_ONLYCONVERTING
);
24625 pop_nested_class ();
24626 pop_nested_namespace (ns
);
24629 /* We restore the source position here because it's used by
24630 add_pending_template. */
24631 input_location
= saved_loc
;
24633 if (at_eof
&& !pattern_defined
24634 && DECL_EXPLICIT_INSTANTIATION (d
)
24635 && DECL_NOT_REALLY_EXTERN (d
))
24638 The definition of a non-exported function template, a
24639 non-exported member function template, or a non-exported
24640 member function or static data member of a class template
24641 shall be present in every translation unit in which it is
24642 explicitly instantiated. */
24643 permerror (input_location
, "explicit instantiation of %qD "
24644 "but no definition available", d
);
24646 /* If we're in unevaluated context, we just wanted to get the
24647 constant value; this isn't an odr use, so don't queue
24648 a full instantiation. */
24649 if (cp_unevaluated_operand
!= 0)
24651 /* ??? Historically, we have instantiated inline functions, even
24652 when marked as "extern template". */
24653 if (!(external_p
&& VAR_P (d
)))
24654 add_pending_template (d
);
24657 /* Tell the repository that D is available in this translation unit
24658 -- and see if it is supposed to be instantiated here. */
24659 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
24661 /* In a PCH file, despite the fact that the repository hasn't
24662 requested instantiation in the PCH it is still possible that
24663 an instantiation will be required in a file that includes the
24666 add_pending_template (d
);
24667 /* Instantiate inline functions so that the inliner can do its
24668 job, even though we'll not be emitting a copy of this
24670 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
24674 bool push_to_top
, nested
;
24676 fn_context
= decl_function_context (d
);
24677 if (LAMBDA_FUNCTION_P (d
))
24678 /* tsubst_lambda_expr resolved any references to enclosing functions. */
24679 fn_context
= NULL_TREE
;
24680 nested
= current_function_decl
!= NULL_TREE
;
24681 push_to_top
= !(nested
&& fn_context
== current_function_decl
);
24683 vec
<tree
> omp_privatization_save
;
24685 save_omp_privatization_clauses (omp_privatization_save
);
24688 push_to_top_level ();
24691 gcc_assert (!processing_template_decl
);
24692 push_function_context ();
24693 cp_unevaluated_operand
= 0;
24694 c_inhibit_evaluation_warnings
= 0;
24697 /* Mark D as instantiated so that recursive calls to
24698 instantiate_decl do not try to instantiate it again. */
24699 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
24701 /* Regenerate the declaration in case the template has been modified
24702 by a subsequent redeclaration. */
24703 regenerate_decl_from_template (d
, td
, args
);
24705 /* We already set the file and line above. Reset them now in case
24706 they changed as a result of calling regenerate_decl_from_template. */
24707 input_location
= DECL_SOURCE_LOCATION (d
);
24712 bool const_init
= false;
24714 /* Clear out DECL_RTL; whatever was there before may not be right
24715 since we've reset the type of the declaration. */
24716 SET_DECL_RTL (d
, NULL
);
24717 DECL_IN_AGGR_P (d
) = 0;
24719 /* The initializer is placed in DECL_INITIAL by
24720 regenerate_decl_from_template so we don't need to
24721 push/pop_access_scope again here. Pull it out so that
24722 cp_finish_decl can process it. */
24723 init
= DECL_INITIAL (d
);
24724 DECL_INITIAL (d
) = NULL_TREE
;
24725 DECL_INITIALIZED_P (d
) = 0;
24727 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
24728 initializer. That function will defer actual emission until
24729 we have a chance to determine linkage. */
24730 DECL_EXTERNAL (d
) = 0;
24732 /* Enter the scope of D so that access-checking works correctly. */
24733 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
24735 push_nested_class (DECL_CONTEXT (d
));
24737 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
24738 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
24741 pop_nested_class ();
24743 if (variable_template_p (gen_tmpl
))
24744 note_variable_template_instantiation (d
);
24746 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
24747 synthesize_method (d
);
24748 else if (TREE_CODE (d
) == FUNCTION_DECL
)
24750 /* Set up the list of local specializations. */
24751 local_specialization_stack
lss (push_to_top
? lss_blank
: lss_copy
);
24752 tree block
= NULL_TREE
;
24754 /* Set up context. */
24755 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
24756 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
24757 block
= push_stmt_list ();
24759 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
24761 /* Some typedefs referenced from within the template code need to be
24762 access checked at template instantiation time, i.e now. These
24763 types were added to the template at parsing time. Let's get those
24764 and perform the access checks then. */
24765 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (td
),
24768 /* Create substitution entries for the parameters. */
24769 register_parameter_specializations (code_pattern
, d
);
24771 /* Substitute into the body of the function. */
24772 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
24773 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
24774 tf_warning_or_error
, tmpl
);
24777 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
24778 tf_warning_or_error
, tmpl
,
24779 /*integral_constant_expression_p=*/false);
24781 /* Set the current input_location to the end of the function
24782 so that finish_function knows where we are. */
24784 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
24786 /* Remember if we saw an infinite loop in the template. */
24787 current_function_infinite_loop
24788 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
24791 /* Finish the function. */
24792 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
24793 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
24794 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
24797 d
= finish_function (/*inline_p=*/false);
24798 expand_or_defer_fn (d
);
24801 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
24802 cp_check_omp_declare_reduction (d
);
24805 /* We're not deferring instantiation any more. */
24806 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
24809 pop_from_top_level ();
24811 pop_function_context ();
24814 restore_omp_privatization_clauses (omp_privatization_save
);
24817 pop_deferring_access_checks ();
24818 timevar_pop (TV_TEMPLATE_INST
);
24819 pop_tinst_level ();
24820 input_location
= saved_loc
;
24821 cp_unevaluated_operand
= saved_unevaluated_operand
;
24822 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
24827 /* Run through the list of templates that we wish we could
24828 instantiate, and instantiate any we can. RETRIES is the
24829 number of times we retry pending template instantiation. */
24832 instantiate_pending_templates (int retries
)
24835 location_t saved_loc
= input_location
;
24837 /* Instantiating templates may trigger vtable generation. This in turn
24838 may require further template instantiations. We place a limit here
24839 to avoid infinite loop. */
24840 if (pending_templates
&& retries
>= max_tinst_depth
)
24842 tree decl
= pending_templates
->tinst
->maybe_get_node ();
24844 fatal_error (input_location
,
24845 "template instantiation depth exceeds maximum of %d"
24846 " instantiating %q+D, possibly from virtual table generation"
24847 " (use %<-ftemplate-depth=%> to increase the maximum)",
24848 max_tinst_depth
, decl
);
24849 if (TREE_CODE (decl
) == FUNCTION_DECL
)
24850 /* Pretend that we defined it. */
24851 DECL_INITIAL (decl
) = error_mark_node
;
24857 struct pending_template
**t
= &pending_templates
;
24858 struct pending_template
*last
= NULL
;
24862 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
24863 bool complete
= false;
24865 if (TYPE_P (instantiation
))
24867 if (!COMPLETE_TYPE_P (instantiation
))
24869 instantiate_class_template (instantiation
);
24870 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
24871 for (tree fld
= TYPE_FIELDS (instantiation
);
24872 fld
; fld
= TREE_CHAIN (fld
))
24874 || (TREE_CODE (fld
) == FUNCTION_DECL
24875 && !DECL_ARTIFICIAL (fld
)))
24876 && DECL_TEMPLATE_INSTANTIATION (fld
))
24877 instantiate_decl (fld
,
24878 /*defer_ok=*/false,
24879 /*expl_inst_class_mem_p=*/false);
24881 if (COMPLETE_TYPE_P (instantiation
))
24885 complete
= COMPLETE_TYPE_P (instantiation
);
24889 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
24890 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
24893 = instantiate_decl (instantiation
,
24894 /*defer_ok=*/false,
24895 /*expl_inst_class_mem_p=*/false);
24896 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
24900 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
24901 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
24906 /* If INSTANTIATION has been instantiated, then we don't
24907 need to consider it again in the future. */
24908 struct pending_template
*drop
= *t
;
24910 set_refcount_ptr (drop
->tinst
);
24911 pending_template_freelist ().free (drop
);
24919 set_refcount_ptr (current_tinst_level
);
24921 last_pending_template
= last
;
24923 while (reconsider
);
24925 input_location
= saved_loc
;
24928 /* Substitute ARGVEC into T, which is a list of initializers for
24929 either base class or a non-static data member. The TREE_PURPOSEs
24930 are DECLs, and the TREE_VALUEs are the initializer values. Used by
24931 instantiate_decl. */
24934 tsubst_initializer_list (tree t
, tree argvec
)
24936 tree inits
= NULL_TREE
;
24937 tree target_ctor
= error_mark_node
;
24939 for (; t
; t
= TREE_CHAIN (t
))
24943 tree expanded_bases
= NULL_TREE
;
24944 tree expanded_arguments
= NULL_TREE
;
24947 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
24952 /* Expand the base class expansion type into separate base
24954 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
24955 tf_warning_or_error
,
24957 if (expanded_bases
== error_mark_node
)
24960 /* We'll be building separate TREE_LISTs of arguments for
24962 len
= TREE_VEC_LENGTH (expanded_bases
);
24963 expanded_arguments
= make_tree_vec (len
);
24964 for (i
= 0; i
< len
; i
++)
24965 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
24967 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
24968 expand each argument in the TREE_VALUE of t. */
24969 expr
= make_node (EXPR_PACK_EXPANSION
);
24970 PACK_EXPANSION_LOCAL_P (expr
) = true;
24971 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
24972 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
24974 if (TREE_VALUE (t
) == void_type_node
)
24975 /* VOID_TYPE_NODE is used to indicate
24976 value-initialization. */
24978 for (i
= 0; i
< len
; i
++)
24979 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
24983 /* Substitute parameter packs into each argument in the
24985 in_base_initializer
= 1;
24986 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
24988 tree expanded_exprs
;
24990 /* Expand the argument. */
24991 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
24993 = tsubst_pack_expansion (expr
, argvec
,
24994 tf_warning_or_error
,
24996 if (expanded_exprs
== error_mark_node
)
24999 /* Prepend each of the expanded expressions to the
25000 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
25001 for (i
= 0; i
< len
; i
++)
25003 TREE_VEC_ELT (expanded_arguments
, i
) =
25004 tree_cons (NULL_TREE
,
25005 TREE_VEC_ELT (expanded_exprs
, i
),
25006 TREE_VEC_ELT (expanded_arguments
, i
));
25009 in_base_initializer
= 0;
25011 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
25012 since we built them backwards. */
25013 for (i
= 0; i
< len
; i
++)
25015 TREE_VEC_ELT (expanded_arguments
, i
) =
25016 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
25021 for (i
= 0; i
< len
; ++i
)
25023 if (expanded_bases
)
25025 decl
= TREE_VEC_ELT (expanded_bases
, i
);
25026 decl
= expand_member_init (decl
);
25027 init
= TREE_VEC_ELT (expanded_arguments
, i
);
25032 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
25033 tf_warning_or_error
, NULL_TREE
);
25035 decl
= expand_member_init (decl
);
25036 if (decl
&& !DECL_P (decl
))
25037 in_base_initializer
= 1;
25039 init
= TREE_VALUE (t
);
25041 if (init
!= void_type_node
)
25042 init
= tsubst_expr (init
, argvec
,
25043 tf_warning_or_error
, NULL_TREE
,
25044 /*integral_constant_expression_p=*/false);
25045 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
25046 /* If we had an initializer but it instantiated to nothing,
25047 value-initialize the object. This will only occur when
25048 the initializer was a pack expansion where the parameter
25049 packs used in that expansion were of length zero. */
25050 init
= void_type_node
;
25051 in_base_initializer
= 0;
25054 if (target_ctor
!= error_mark_node
25055 && init
!= error_mark_node
)
25057 error ("mem-initializer for %qD follows constructor delegation",
25061 /* Look for a target constructor. */
25062 if (init
!= error_mark_node
25063 && decl
&& CLASS_TYPE_P (decl
)
25064 && same_type_p (decl
, current_class_type
))
25066 maybe_warn_cpp0x (CPP0X_DELEGATING_CTORS
);
25069 error ("constructor delegation follows mem-initializer for %qD",
25070 TREE_PURPOSE (inits
));
25073 target_ctor
= init
;
25078 init
= build_tree_list (decl
, init
);
25079 TREE_CHAIN (init
) = inits
;
25087 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
25090 set_current_access_from_decl (tree decl
)
25092 if (TREE_PRIVATE (decl
))
25093 current_access_specifier
= access_private_node
;
25094 else if (TREE_PROTECTED (decl
))
25095 current_access_specifier
= access_protected_node
;
25097 current_access_specifier
= access_public_node
;
25100 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
25101 is the instantiation (which should have been created with
25102 start_enum) and ARGS are the template arguments to use. */
25105 tsubst_enum (tree tag
, tree newtag
, tree args
)
25109 if (SCOPED_ENUM_P (newtag
))
25110 begin_scope (sk_scoped_enum
, newtag
);
25112 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
25117 decl
= TREE_VALUE (e
);
25118 /* Note that in a template enum, the TREE_VALUE is the
25119 CONST_DECL, not the corresponding INTEGER_CST. */
25120 value
= tsubst_expr (DECL_INITIAL (decl
),
25121 args
, tf_warning_or_error
, NULL_TREE
,
25122 /*integral_constant_expression_p=*/true);
25124 /* Give this enumeration constant the correct access. */
25125 set_current_access_from_decl (decl
);
25127 /* Actually build the enumerator itself. Here we're assuming that
25128 enumerators can't have dependent attributes. */
25129 build_enumerator (DECL_NAME (decl
), value
, newtag
,
25130 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
25133 if (SCOPED_ENUM_P (newtag
))
25136 finish_enum_value_list (newtag
);
25137 finish_enum (newtag
);
25139 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
25140 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
25143 /* DECL is a FUNCTION_DECL that is a template specialization. Return
25144 its type -- but without substituting the innermost set of template
25145 arguments. So, innermost set of template parameters will appear in
25149 get_mostly_instantiated_function_type (tree decl
)
25151 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
25152 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
25155 /* Return truthvalue if we're processing a template different from
25156 the last one involved in diagnostics. */
25158 problematic_instantiation_changed (void)
25160 return current_tinst_level
!= last_error_tinst_level
;
25163 /* Remember current template involved in diagnostics. */
25165 record_last_problematic_instantiation (void)
25167 set_refcount_ptr (last_error_tinst_level
, current_tinst_level
);
25170 struct tinst_level
*
25171 current_instantiation (void)
25173 return current_tinst_level
;
25176 /* Return TRUE if current_function_decl is being instantiated, false
25180 instantiating_current_function_p (void)
25182 return (current_instantiation ()
25183 && (current_instantiation ()->maybe_get_node ()
25184 == current_function_decl
));
25187 /* [temp.param] Check that template non-type parm TYPE is of an allowable
25188 type. Return false for ok, true for disallowed. Issue error and
25189 inform messages under control of COMPLAIN. */
25192 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
25194 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
25196 else if (TYPE_PTR_P (type
))
25198 else if (TYPE_REF_P (type
)
25199 && !TYPE_REF_IS_RVALUE (type
))
25201 else if (TYPE_PTRMEM_P (type
))
25203 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
25205 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
25207 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
25209 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
25211 /* A bound template template parm could later be instantiated to have a valid
25212 nontype parm type via an alias template. */
25213 else if (cxx_dialect
>= cxx11
25214 && TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
25216 else if (CLASS_TYPE_P (type
))
25218 if (cxx_dialect
< cxx2a
)
25220 error ("non-type template parameters of class type only available "
25221 "with %<-std=c++2a%> or %<-std=gnu++2a%>");
25224 if (!complete_type_or_else (type
, NULL_TREE
))
25226 if (!literal_type_p (type
))
25228 error ("%qT is not a valid type for a template non-type parameter "
25229 "because it is not literal", type
);
25230 explain_non_literal_class (type
);
25233 if (cp_has_mutable_p (type
))
25235 error ("%qT is not a valid type for a template non-type parameter "
25236 "because it has a mutable member", type
);
25239 /* FIXME check op<=> and strong structural equality once spaceship is
25244 if (complain
& tf_error
)
25246 if (type
== error_mark_node
)
25247 inform (input_location
, "invalid template non-type parameter");
25249 error ("%q#T is not a valid type for a template non-type parameter",
25255 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
25256 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
25259 dependent_type_p_r (tree type
)
25265 A type is dependent if it is:
25267 -- a template parameter. Template template parameters are types
25268 for us (since TYPE_P holds true for them) so we handle
25270 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
25271 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
25273 /* -- a qualified-id with a nested-name-specifier which contains a
25274 class-name that names a dependent type or whose unqualified-id
25275 names a dependent type. */
25276 if (TREE_CODE (type
) == TYPENAME_TYPE
)
25279 /* An alias template specialization can be dependent even if the
25280 resulting type is not. */
25281 if (dependent_alias_template_spec_p (type
))
25284 /* -- a cv-qualified type where the cv-unqualified type is
25286 No code is necessary for this bullet; the code below handles
25287 cv-qualified types, and we don't want to strip aliases with
25288 TYPE_MAIN_VARIANT because of DR 1558. */
25289 /* -- a compound type constructed from any dependent type. */
25290 if (TYPE_PTRMEM_P (type
))
25291 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
25292 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
25294 else if (INDIRECT_TYPE_P (type
))
25295 return dependent_type_p (TREE_TYPE (type
));
25296 else if (TREE_CODE (type
) == FUNCTION_TYPE
25297 || TREE_CODE (type
) == METHOD_TYPE
)
25301 if (dependent_type_p (TREE_TYPE (type
)))
25303 for (arg_type
= TYPE_ARG_TYPES (type
);
25305 arg_type
= TREE_CHAIN (arg_type
))
25306 if (dependent_type_p (TREE_VALUE (arg_type
)))
25308 if (cxx_dialect
>= cxx17
)
25309 /* A value-dependent noexcept-specifier makes the type dependent. */
25310 if (tree spec
= TYPE_RAISES_EXCEPTIONS (type
))
25311 if (tree noex
= TREE_PURPOSE (spec
))
25312 /* Treat DEFERRED_NOEXCEPT as non-dependent, since it doesn't
25313 affect overload resolution and treating it as dependent breaks
25315 if (TREE_CODE (noex
) != DEFERRED_NOEXCEPT
25316 && value_dependent_expression_p (noex
))
25320 /* -- an array type constructed from any dependent type or whose
25321 size is specified by a constant expression that is
25324 We checked for type- and value-dependence of the bounds in
25325 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
25326 if (TREE_CODE (type
) == ARRAY_TYPE
)
25328 if (TYPE_DOMAIN (type
)
25329 && dependent_type_p (TYPE_DOMAIN (type
)))
25331 return dependent_type_p (TREE_TYPE (type
));
25334 /* -- a template-id in which either the template name is a template
25336 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
25338 /* ... or any of the template arguments is a dependent type or
25339 an expression that is type-dependent or value-dependent. */
25340 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
25341 && (any_dependent_template_arguments_p
25342 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
25345 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
25346 dependent; if the argument of the `typeof' expression is not
25347 type-dependent, then it should already been have resolved. */
25348 if (TREE_CODE (type
) == TYPEOF_TYPE
25349 || TREE_CODE (type
) == DECLTYPE_TYPE
25350 || TREE_CODE (type
) == UNDERLYING_TYPE
)
25353 /* A template argument pack is dependent if any of its packed
25355 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
25357 tree args
= ARGUMENT_PACK_ARGS (type
);
25358 int i
, len
= TREE_VEC_LENGTH (args
);
25359 for (i
= 0; i
< len
; ++i
)
25360 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
25364 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
25365 be template parameters. */
25366 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
25369 if (any_dependent_type_attributes_p (TYPE_ATTRIBUTES (type
)))
25372 /* The standard does not specifically mention types that are local
25373 to template functions or local classes, but they should be
25374 considered dependent too. For example:
25376 template <int I> void f() {
25381 The size of `E' cannot be known until the value of `I' has been
25382 determined. Therefore, `E' must be considered dependent. */
25383 scope
= TYPE_CONTEXT (type
);
25384 if (scope
&& TYPE_P (scope
))
25385 return dependent_type_p (scope
);
25386 /* Don't use type_dependent_expression_p here, as it can lead
25387 to infinite recursion trying to determine whether a lambda
25388 nested in a lambda is dependent (c++/47687). */
25389 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
25390 && DECL_LANG_SPECIFIC (scope
)
25391 && DECL_TEMPLATE_INFO (scope
)
25392 && (any_dependent_template_arguments_p
25393 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
25396 /* Other types are non-dependent. */
25400 /* Returns TRUE if TYPE is dependent, in the sense of
25401 [temp.dep.type]. Note that a NULL type is considered dependent. */
25404 dependent_type_p (tree type
)
25406 /* If there are no template parameters in scope, then there can't be
25407 any dependent types. */
25408 if (!processing_template_decl
)
25410 /* If we are not processing a template, then nobody should be
25411 providing us with a dependent type. */
25413 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
25417 /* If the type is NULL, we have not computed a type for the entity
25418 in question; in that case, the type is dependent. */
25422 /* Erroneous types can be considered non-dependent. */
25423 if (type
== error_mark_node
)
25426 /* Getting here with global_type_node means we improperly called this
25427 function on the TREE_TYPE of an IDENTIFIER_NODE. */
25428 gcc_checking_assert (type
!= global_type_node
);
25430 /* If we have not already computed the appropriate value for TYPE,
25432 if (!TYPE_DEPENDENT_P_VALID (type
))
25434 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
25435 TYPE_DEPENDENT_P_VALID (type
) = 1;
25438 return TYPE_DEPENDENT_P (type
);
25441 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
25442 lookup. In other words, a dependent type that is not the current
25446 dependent_scope_p (tree scope
)
25448 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
25449 && !currently_open_class (scope
));
25452 /* T is a SCOPE_REF. Return whether it represents a non-static member of
25453 an unknown base of 'this' (and is therefore instantiation-dependent). */
25456 unknown_base_ref_p (tree t
)
25458 if (!current_class_ptr
)
25461 tree mem
= TREE_OPERAND (t
, 1);
25462 if (shared_member_p (mem
))
25465 tree cur
= current_nonlambda_class_type ();
25466 if (!any_dependent_bases_p (cur
))
25469 tree ctx
= TREE_OPERAND (t
, 0);
25470 if (DERIVED_FROM_P (ctx
, cur
))
25476 /* T is a SCOPE_REF; return whether we need to consider it
25477 instantiation-dependent so that we can check access at instantiation
25478 time even though we know which member it resolves to. */
25481 instantiation_dependent_scope_ref_p (tree t
)
25483 if (DECL_P (TREE_OPERAND (t
, 1))
25484 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
25485 && !unknown_base_ref_p (t
)
25486 && accessible_in_template_p (TREE_OPERAND (t
, 0),
25487 TREE_OPERAND (t
, 1)))
25493 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
25494 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
25497 /* Note that this predicate is not appropriate for general expressions;
25498 only constant expressions (that satisfy potential_constant_expression)
25499 can be tested for value dependence. */
25502 value_dependent_expression_p (tree expression
)
25504 if (!processing_template_decl
|| expression
== NULL_TREE
)
25507 /* A type-dependent expression is also value-dependent. */
25508 if (type_dependent_expression_p (expression
))
25511 switch (TREE_CODE (expression
))
25514 /* A dependent member function of the current instantiation. */
25515 return dependent_type_p (BINFO_TYPE (BASELINK_BINFO (expression
)));
25517 case FUNCTION_DECL
:
25518 /* A dependent member function of the current instantiation. */
25519 if (DECL_CLASS_SCOPE_P (expression
)
25520 && dependent_type_p (DECL_CONTEXT (expression
)))
25524 case IDENTIFIER_NODE
:
25525 /* A name that has not been looked up -- must be dependent. */
25528 case TEMPLATE_PARM_INDEX
:
25529 /* A non-type template parm. */
25533 /* A non-type template parm. */
25534 if (DECL_TEMPLATE_PARM_P (expression
))
25536 return value_dependent_expression_p (DECL_INITIAL (expression
));
25539 /* A constant with literal type and is initialized
25540 with an expression that is value-dependent. */
25541 if (DECL_DEPENDENT_INIT_P (expression
)
25542 /* FIXME cp_finish_decl doesn't fold reference initializers. */
25543 || TYPE_REF_P (TREE_TYPE (expression
)))
25545 if (DECL_HAS_VALUE_EXPR_P (expression
))
25547 tree value_expr
= DECL_VALUE_EXPR (expression
);
25548 if (value_dependent_expression_p (value_expr
))
25553 case DYNAMIC_CAST_EXPR
:
25554 case STATIC_CAST_EXPR
:
25555 case CONST_CAST_EXPR
:
25556 case REINTERPRET_CAST_EXPR
:
25558 case IMPLICIT_CONV_EXPR
:
25559 /* These expressions are value-dependent if the type to which
25560 the cast occurs is dependent or the expression being casted
25561 is value-dependent. */
25563 tree type
= TREE_TYPE (expression
);
25565 if (dependent_type_p (type
))
25568 /* A functional cast has a list of operands. */
25569 expression
= TREE_OPERAND (expression
, 0);
25572 /* If there are no operands, it must be an expression such
25573 as "int()". This should not happen for aggregate types
25574 because it would form non-constant expressions. */
25575 gcc_assert (cxx_dialect
>= cxx11
25576 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
25581 if (TREE_CODE (expression
) == TREE_LIST
)
25582 return any_value_dependent_elements_p (expression
);
25584 return value_dependent_expression_p (expression
);
25588 if (SIZEOF_EXPR_TYPE_P (expression
))
25589 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
25593 /* A `sizeof' expression is value-dependent if the operand is
25594 type-dependent or is a pack expansion. */
25595 expression
= TREE_OPERAND (expression
, 0);
25596 if (PACK_EXPANSION_P (expression
))
25598 else if (TYPE_P (expression
))
25599 return dependent_type_p (expression
);
25600 return instantiation_dependent_uneval_expression_p (expression
);
25602 case AT_ENCODE_EXPR
:
25603 /* An 'encode' expression is value-dependent if the operand is
25605 expression
= TREE_OPERAND (expression
, 0);
25606 return dependent_type_p (expression
);
25608 case NOEXCEPT_EXPR
:
25609 expression
= TREE_OPERAND (expression
, 0);
25610 return instantiation_dependent_uneval_expression_p (expression
);
25613 /* All instantiation-dependent expressions should also be considered
25614 value-dependent. */
25615 return instantiation_dependent_scope_ref_p (expression
);
25617 case COMPONENT_REF
:
25618 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
25619 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
25621 case NONTYPE_ARGUMENT_PACK
:
25622 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
25623 is value-dependent. */
25625 tree values
= ARGUMENT_PACK_ARGS (expression
);
25626 int i
, len
= TREE_VEC_LENGTH (values
);
25628 for (i
= 0; i
< len
; ++i
)
25629 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
25637 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
25639 if (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
)))
25645 if (TREE_CODE (type2
) != TREE_LIST
)
25646 return dependent_type_p (type2
);
25648 for (; type2
; type2
= TREE_CHAIN (type2
))
25649 if (dependent_type_p (TREE_VALUE (type2
)))
25656 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
25657 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
25660 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
25661 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
25665 tree op
= TREE_OPERAND (expression
, 0);
25666 return (value_dependent_expression_p (op
)
25667 || has_value_dependent_address (op
));
25670 case REQUIRES_EXPR
:
25671 /* Treat all requires-expressions as value-dependent so
25672 we don't try to fold them. */
25676 return dependent_type_p (TREE_OPERAND (expression
, 0));
25680 if (value_dependent_expression_p (CALL_EXPR_FN (expression
)))
25682 tree fn
= get_callee_fndecl (expression
);
25684 nargs
= call_expr_nargs (expression
);
25685 for (i
= 0; i
< nargs
; ++i
)
25687 tree op
= CALL_EXPR_ARG (expression
, i
);
25688 /* In a call to a constexpr member function, look through the
25689 implicit ADDR_EXPR on the object argument so that it doesn't
25690 cause the call to be considered value-dependent. We also
25691 look through it in potential_constant_expression. */
25692 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
25693 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
25694 && TREE_CODE (op
) == ADDR_EXPR
)
25695 op
= TREE_OPERAND (op
, 0);
25696 if (value_dependent_expression_p (op
))
25702 case TEMPLATE_ID_EXPR
:
25703 return variable_concept_p (TREE_OPERAND (expression
, 0));
25709 if (dependent_type_p (TREE_TYPE (expression
)))
25711 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
25712 if (value_dependent_expression_p (val
))
25718 /* Treat a GNU statement expression as dependent to avoid crashing
25719 under instantiate_non_dependent_expr; it can't be constant. */
25723 /* A constant expression is value-dependent if any subexpression is
25724 value-dependent. */
25725 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
25727 case tcc_reference
:
25729 case tcc_comparison
:
25731 case tcc_expression
:
25734 int i
, len
= cp_tree_operand_length (expression
);
25736 for (i
= 0; i
< len
; i
++)
25738 tree t
= TREE_OPERAND (expression
, i
);
25740 /* In some cases, some of the operands may be missing.
25741 (For example, in the case of PREDECREMENT_EXPR, the
25742 amount to increment by may be missing.) That doesn't
25743 make the expression dependent. */
25744 if (t
&& value_dependent_expression_p (t
))
25755 /* The expression is not value-dependent. */
25759 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
25760 [temp.dep.expr]. Note that an expression with no type is
25761 considered dependent. Other parts of the compiler arrange for an
25762 expression with type-dependent subexpressions to have no type, so
25763 this function doesn't have to be fully recursive. */
25766 type_dependent_expression_p (tree expression
)
25768 if (!processing_template_decl
)
25771 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
25774 STRIP_ANY_LOCATION_WRAPPER (expression
);
25776 /* An unresolved name is always dependent. */
25777 if (identifier_p (expression
)
25778 || TREE_CODE (expression
) == USING_DECL
25779 || TREE_CODE (expression
) == WILDCARD_DECL
)
25782 /* A lambda-expression in template context is dependent. dependent_type_p is
25783 true for a lambda in the scope of a class or function template, but that
25784 doesn't cover all template contexts, like a default template argument. */
25785 if (TREE_CODE (expression
) == LAMBDA_EXPR
)
25788 /* A fold expression is type-dependent. */
25789 if (TREE_CODE (expression
) == UNARY_LEFT_FOLD_EXPR
25790 || TREE_CODE (expression
) == UNARY_RIGHT_FOLD_EXPR
25791 || TREE_CODE (expression
) == BINARY_LEFT_FOLD_EXPR
25792 || TREE_CODE (expression
) == BINARY_RIGHT_FOLD_EXPR
)
25795 /* Some expression forms are never type-dependent. */
25796 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
25797 || TREE_CODE (expression
) == SIZEOF_EXPR
25798 || TREE_CODE (expression
) == ALIGNOF_EXPR
25799 || TREE_CODE (expression
) == AT_ENCODE_EXPR
25800 || TREE_CODE (expression
) == NOEXCEPT_EXPR
25801 || TREE_CODE (expression
) == TRAIT_EXPR
25802 || TREE_CODE (expression
) == TYPEID_EXPR
25803 || TREE_CODE (expression
) == DELETE_EXPR
25804 || TREE_CODE (expression
) == VEC_DELETE_EXPR
25805 || TREE_CODE (expression
) == THROW_EXPR
25806 || TREE_CODE (expression
) == REQUIRES_EXPR
)
25809 /* The types of these expressions depends only on the type to which
25810 the cast occurs. */
25811 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
25812 || TREE_CODE (expression
) == STATIC_CAST_EXPR
25813 || TREE_CODE (expression
) == CONST_CAST_EXPR
25814 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
25815 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
25816 || TREE_CODE (expression
) == CAST_EXPR
)
25817 return dependent_type_p (TREE_TYPE (expression
));
25819 /* The types of these expressions depends only on the type created
25820 by the expression. */
25821 if (TREE_CODE (expression
) == NEW_EXPR
25822 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
25824 /* For NEW_EXPR tree nodes created inside a template, either
25825 the object type itself or a TREE_LIST may appear as the
25827 tree type
= TREE_OPERAND (expression
, 1);
25828 if (TREE_CODE (type
) == TREE_LIST
)
25829 /* This is an array type. We need to check array dimensions
25831 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
25832 || value_dependent_expression_p
25833 (TREE_OPERAND (TREE_VALUE (type
), 1));
25835 return dependent_type_p (type
);
25838 if (TREE_CODE (expression
) == SCOPE_REF
)
25840 tree scope
= TREE_OPERAND (expression
, 0);
25841 tree name
= TREE_OPERAND (expression
, 1);
25843 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
25844 contains an identifier associated by name lookup with one or more
25845 declarations declared with a dependent type, or...a
25846 nested-name-specifier or qualified-id that names a member of an
25847 unknown specialization. */
25848 return (type_dependent_expression_p (name
)
25849 || dependent_scope_p (scope
));
25852 if (TREE_CODE (expression
) == TEMPLATE_DECL
25853 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
25854 return uses_outer_template_parms (expression
);
25856 if (TREE_CODE (expression
) == STMT_EXPR
)
25857 expression
= stmt_expr_value_expr (expression
);
25859 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
25864 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
25866 if (type_dependent_expression_p (elt
))
25872 /* A static data member of the current instantiation with incomplete
25873 array type is type-dependent, as the definition and specializations
25874 can have different bounds. */
25875 if (VAR_P (expression
)
25876 && DECL_CLASS_SCOPE_P (expression
)
25877 && dependent_type_p (DECL_CONTEXT (expression
))
25878 && VAR_HAD_UNKNOWN_BOUND (expression
))
25881 /* An array of unknown bound depending on a variadic parameter, eg:
25883 template<typename... Args>
25884 void foo (Args... args)
25886 int arr[] = { args... };
25889 template<int... vals>
25892 int arr[] = { vals... };
25895 If the array has no length and has an initializer, it must be that
25896 we couldn't determine its length in cp_complete_array_type because
25897 it is dependent. */
25898 if (VAR_P (expression
)
25899 && TREE_TYPE (expression
) != NULL_TREE
25900 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
25901 && !TYPE_DOMAIN (TREE_TYPE (expression
))
25902 && DECL_INITIAL (expression
))
25905 /* A function or variable template-id is type-dependent if it has any
25906 dependent template arguments. */
25907 if (VAR_OR_FUNCTION_DECL_P (expression
)
25908 && DECL_LANG_SPECIFIC (expression
)
25909 && DECL_TEMPLATE_INFO (expression
))
25911 /* Consider the innermost template arguments, since those are the ones
25912 that come from the template-id; the template arguments for the
25913 enclosing class do not make it type-dependent unless they are used in
25914 the type of the decl. */
25915 if (instantiates_primary_template_p (expression
)
25916 && (any_dependent_template_arguments_p
25917 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
25921 /* Otherwise, if the function decl isn't from a dependent scope, it can't be
25922 type-dependent. Checking this is important for functions with auto return
25923 type, which looks like a dependent type. */
25924 if (TREE_CODE (expression
) == FUNCTION_DECL
25925 && !(DECL_CLASS_SCOPE_P (expression
)
25926 && dependent_type_p (DECL_CONTEXT (expression
)))
25927 && !(DECL_LANG_SPECIFIC (expression
)
25928 && DECL_FRIEND_P (expression
)
25929 && (!DECL_FRIEND_CONTEXT (expression
)
25930 || dependent_type_p (DECL_FRIEND_CONTEXT (expression
))))
25931 && !DECL_LOCAL_FUNCTION_P (expression
))
25933 gcc_assert (!dependent_type_p (TREE_TYPE (expression
))
25934 || undeduced_auto_decl (expression
));
25938 /* Always dependent, on the number of arguments if nothing else. */
25939 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
25942 if (TREE_TYPE (expression
) == unknown_type_node
)
25944 if (TREE_CODE (expression
) == ADDR_EXPR
)
25945 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
25946 if (TREE_CODE (expression
) == COMPONENT_REF
25947 || TREE_CODE (expression
) == OFFSET_REF
)
25949 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
25951 expression
= TREE_OPERAND (expression
, 1);
25952 if (identifier_p (expression
))
25955 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
25956 if (TREE_CODE (expression
) == SCOPE_REF
)
25959 if (BASELINK_P (expression
))
25961 if (BASELINK_OPTYPE (expression
)
25962 && dependent_type_p (BASELINK_OPTYPE (expression
)))
25964 expression
= BASELINK_FUNCTIONS (expression
);
25967 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
25969 if (any_dependent_template_arguments_p
25970 (TREE_OPERAND (expression
, 1)))
25972 expression
= TREE_OPERAND (expression
, 0);
25973 if (identifier_p (expression
))
25977 gcc_assert (TREE_CODE (expression
) == OVERLOAD
25978 || TREE_CODE (expression
) == FUNCTION_DECL
);
25980 for (lkp_iterator
iter (expression
); iter
; ++iter
)
25981 if (type_dependent_expression_p (*iter
))
25987 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
25989 /* Dependent type attributes might not have made it from the decl to
25991 if (DECL_P (expression
)
25992 && any_dependent_type_attributes_p (DECL_ATTRIBUTES (expression
)))
25995 return (dependent_type_p (TREE_TYPE (expression
)));
25998 /* [temp.dep.expr]/5: A class member access expression (5.2.5) is
25999 type-dependent if the expression refers to a member of the current
26000 instantiation and the type of the referenced member is dependent, or the
26001 class member access expression refers to a member of an unknown
26004 This function returns true if the OBJECT in such a class member access
26005 expression is of an unknown specialization. */
26008 type_dependent_object_expression_p (tree object
)
26010 /* An IDENTIFIER_NODE can sometimes have a TREE_TYPE, but it's still
26012 if (TREE_CODE (object
) == IDENTIFIER_NODE
)
26014 tree scope
= TREE_TYPE (object
);
26015 return (!scope
|| dependent_scope_p (scope
));
26018 /* walk_tree callback function for instantiation_dependent_expression_p,
26019 below. Returns non-zero if a dependent subexpression is found. */
26022 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
26027 /* We don't have to worry about decltype currently because decltype
26028 of an instantiation-dependent expr is a dependent type. This
26029 might change depending on the resolution of DR 1172. */
26030 *walk_subtrees
= false;
26033 enum tree_code code
= TREE_CODE (*tp
);
26036 /* Don't treat an argument list as dependent just because it has no
26040 case NONTYPE_ARGUMENT_PACK
:
26043 case TEMPLATE_PARM_INDEX
:
26044 if (dependent_type_p (TREE_TYPE (*tp
)))
26046 if (TEMPLATE_PARM_PARAMETER_PACK (*tp
))
26048 /* We'll check value-dependence separately. */
26051 /* Handle expressions with type operands. */
26055 case AT_ENCODE_EXPR
:
26057 tree op
= TREE_OPERAND (*tp
, 0);
26058 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
26059 op
= TREE_TYPE (op
);
26062 if (dependent_type_p (op
))
26066 *walk_subtrees
= false;
26073 case COMPONENT_REF
:
26074 if (identifier_p (TREE_OPERAND (*tp
, 1)))
26075 /* In a template, finish_class_member_access_expr creates a
26076 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
26077 type-dependent, so that we can check access control at
26078 instantiation time (PR 42277). See also Core issue 1273. */
26083 if (instantiation_dependent_scope_ref_p (*tp
))
26088 /* Treat statement-expressions as dependent. */
26092 /* Treat requires-expressions as dependent. */
26093 case REQUIRES_EXPR
:
26097 /* Treat calls to function concepts as dependent. */
26098 if (function_concept_check_p (*tp
))
26102 case TEMPLATE_ID_EXPR
:
26103 /* And variable concepts. */
26104 if (variable_concept_p (TREE_OPERAND (*tp
, 0)))
26109 if (CONSTRUCTOR_IS_DEPENDENT (*tp
))
26117 if (type_dependent_expression_p (*tp
))
26123 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
26124 sense defined by the ABI:
26126 "An expression is instantiation-dependent if it is type-dependent
26127 or value-dependent, or it has a subexpression that is type-dependent
26128 or value-dependent."
26130 Except don't actually check value-dependence for unevaluated expressions,
26131 because in sizeof(i) we don't care about the value of i. Checking
26132 type-dependence will in turn check value-dependence of array bounds/template
26133 arguments as needed. */
26136 instantiation_dependent_uneval_expression_p (tree expression
)
26140 if (!processing_template_decl
)
26143 if (expression
== error_mark_node
)
26146 result
= cp_walk_tree_without_duplicates (&expression
,
26147 instantiation_dependent_r
, NULL
);
26148 return result
!= NULL_TREE
;
26151 /* As above, but also check value-dependence of the expression as a whole. */
26154 instantiation_dependent_expression_p (tree expression
)
26156 return (instantiation_dependent_uneval_expression_p (expression
)
26157 || value_dependent_expression_p (expression
));
26160 /* Like type_dependent_expression_p, but it also works while not processing
26161 a template definition, i.e. during substitution or mangling. */
26164 type_dependent_expression_p_push (tree expr
)
26167 ++processing_template_decl
;
26168 b
= type_dependent_expression_p (expr
);
26169 --processing_template_decl
;
26173 /* Returns TRUE if ARGS contains a type-dependent expression. */
26176 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
26181 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
26183 if (type_dependent_expression_p (arg
))
26189 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
26190 expressions) contains any type-dependent expressions. */
26193 any_type_dependent_elements_p (const_tree list
)
26195 for (; list
; list
= TREE_CHAIN (list
))
26196 if (type_dependent_expression_p (TREE_VALUE (list
)))
26202 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
26203 expressions) contains any value-dependent expressions. */
26206 any_value_dependent_elements_p (const_tree list
)
26208 for (; list
; list
= TREE_CHAIN (list
))
26209 if (value_dependent_expression_p (TREE_VALUE (list
)))
26215 /* Returns TRUE if the ARG (a template argument) is dependent. */
26218 dependent_template_arg_p (tree arg
)
26220 if (!processing_template_decl
)
26223 /* Assume a template argument that was wrongly written by the user
26224 is dependent. This is consistent with what
26225 any_dependent_template_arguments_p [that calls this function]
26227 if (!arg
|| arg
== error_mark_node
)
26230 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
26231 arg
= argument_pack_select_arg (arg
);
26233 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
26235 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
26237 if (DECL_TEMPLATE_PARM_P (arg
))
26239 /* A member template of a dependent class is not necessarily
26240 type-dependent, but it is a dependent template argument because it
26241 will be a member of an unknown specialization to that template. */
26242 tree scope
= CP_DECL_CONTEXT (arg
);
26243 return TYPE_P (scope
) && dependent_type_p (scope
);
26245 else if (ARGUMENT_PACK_P (arg
))
26247 tree args
= ARGUMENT_PACK_ARGS (arg
);
26248 int i
, len
= TREE_VEC_LENGTH (args
);
26249 for (i
= 0; i
< len
; ++i
)
26251 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
26257 else if (TYPE_P (arg
))
26258 return dependent_type_p (arg
);
26260 return (type_dependent_expression_p (arg
)
26261 || value_dependent_expression_p (arg
));
26264 /* Returns true if ARGS (a collection of template arguments) contains
26265 any types that require structural equality testing. */
26268 any_template_arguments_need_structural_equality_p (tree args
)
26275 if (args
== error_mark_node
)
26278 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
26280 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
26281 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
26283 tree arg
= TREE_VEC_ELT (level
, j
);
26284 tree packed_args
= NULL_TREE
;
26287 if (ARGUMENT_PACK_P (arg
))
26289 /* Look inside the argument pack. */
26290 packed_args
= ARGUMENT_PACK_ARGS (arg
);
26291 len
= TREE_VEC_LENGTH (packed_args
);
26294 for (k
= 0; k
< len
; ++k
)
26297 arg
= TREE_VEC_ELT (packed_args
, k
);
26299 if (error_operand_p (arg
))
26301 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
26303 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
26305 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
26306 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
26315 /* Returns true if ARGS (a collection of template arguments) contains
26316 any dependent arguments. */
26319 any_dependent_template_arguments_p (const_tree args
)
26326 if (args
== error_mark_node
)
26329 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
26331 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
26332 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
26333 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
26340 /* Returns true if ARGS contains any errors. */
26343 any_erroneous_template_args_p (const_tree args
)
26348 if (args
== error_mark_node
)
26351 if (args
&& TREE_CODE (args
) != TREE_VEC
)
26353 if (tree ti
= get_template_info (args
))
26354 args
= TI_ARGS (ti
);
26362 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
26364 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
26365 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
26366 if (error_operand_p (TREE_VEC_ELT (level
, j
)))
26373 /* Returns TRUE if the template TMPL is type-dependent. */
26376 dependent_template_p (tree tmpl
)
26378 if (TREE_CODE (tmpl
) == OVERLOAD
)
26380 for (lkp_iterator
iter (tmpl
); iter
; ++iter
)
26381 if (dependent_template_p (*iter
))
26386 /* Template template parameters are dependent. */
26387 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
26388 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
26390 /* So are names that have not been looked up. */
26391 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
26396 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
26399 dependent_template_id_p (tree tmpl
, tree args
)
26401 return (dependent_template_p (tmpl
)
26402 || any_dependent_template_arguments_p (args
));
26405 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
26409 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
26413 if (!processing_template_decl
)
26416 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
26418 tree decl
= TREE_VEC_ELT (declv
, i
);
26419 tree init
= TREE_VEC_ELT (initv
, i
);
26420 tree cond
= TREE_VEC_ELT (condv
, i
);
26421 tree incr
= TREE_VEC_ELT (incrv
, i
);
26423 if (type_dependent_expression_p (decl
)
26424 || TREE_CODE (decl
) == SCOPE_REF
)
26427 if (init
&& type_dependent_expression_p (init
))
26430 if (cond
== global_namespace
)
26433 if (type_dependent_expression_p (cond
))
26436 if (COMPARISON_CLASS_P (cond
)
26437 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
26438 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
26441 if (TREE_CODE (incr
) == MODOP_EXPR
)
26443 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
26444 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
26447 else if (type_dependent_expression_p (incr
))
26449 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
26451 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
26453 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
26455 tree t
= TREE_OPERAND (incr
, 1);
26456 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
26457 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
26460 /* If this loop has a class iterator with != comparison
26461 with increment other than i++/++i/i--/--i, make sure the
26462 increment is constant. */
26463 if (CLASS_TYPE_P (TREE_TYPE (decl
))
26464 && TREE_CODE (cond
) == NE_EXPR
)
26466 if (TREE_OPERAND (t
, 0) == decl
)
26467 t
= TREE_OPERAND (t
, 1);
26469 t
= TREE_OPERAND (t
, 0);
26470 if (TREE_CODE (t
) != INTEGER_CST
)
26480 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
26481 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
26482 no such TYPE can be found. Note that this function peers inside
26483 uninstantiated templates and therefore should be used only in
26484 extremely limited situations. ONLY_CURRENT_P restricts this
26485 peering to the currently open classes hierarchy (which is required
26486 when comparing types). */
26489 resolve_typename_type (tree type
, bool only_current_p
)
26498 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
26500 scope
= TYPE_CONTEXT (type
);
26501 /* We shouldn't have built a TYPENAME_TYPE with a non-dependent scope. */
26502 gcc_checking_assert (uses_template_parms (scope
));
26504 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
26505 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
26506 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
26507 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
26508 identifier of the TYPENAME_TYPE anymore.
26509 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
26510 TYPENAME_TYPE instead, we avoid messing up with a possible
26511 typedef variant case. */
26512 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
26514 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
26515 it first before we can figure out what NAME refers to. */
26516 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
26518 if (TYPENAME_IS_RESOLVING_P (scope
))
26519 /* Given a class template A with a dependent base with nested type C,
26520 typedef typename A::C::C C will land us here, as trying to resolve
26521 the initial A::C leads to the local C typedef, which leads back to
26522 A::C::C. So we break the recursion now. */
26525 scope
= resolve_typename_type (scope
, only_current_p
);
26527 /* If we don't know what SCOPE refers to, then we cannot resolve the
26529 if (!CLASS_TYPE_P (scope
))
26531 /* If this is a typedef, we don't want to look inside (c++/11987). */
26532 if (typedef_variant_p (type
))
26534 /* If SCOPE isn't the template itself, it will not have a valid
26535 TYPE_FIELDS list. */
26536 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
26537 /* scope is either the template itself or a compatible instantiation
26538 like X<T>, so look up the name in the original template. */
26539 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
26540 /* If scope has no fields, it can't be a current instantiation. Check this
26541 before currently_open_class to avoid infinite recursion (71515). */
26542 if (!TYPE_FIELDS (scope
))
26544 /* If the SCOPE is not the current instantiation, there's no reason
26545 to look inside it. */
26546 if (only_current_p
&& !currently_open_class (scope
))
26548 /* Enter the SCOPE so that name lookup will be resolved as if we
26549 were in the class definition. In particular, SCOPE will no
26550 longer be considered a dependent type. */
26551 pushed_scope
= push_scope (scope
);
26552 /* Look up the declaration. */
26553 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
26554 tf_warning_or_error
);
26556 result
= NULL_TREE
;
26558 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
26559 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
26560 tree fullname
= TYPENAME_TYPE_FULLNAME (type
);
26563 else if (identifier_p (fullname
)
26564 && TREE_CODE (decl
) == TYPE_DECL
)
26566 result
= TREE_TYPE (decl
);
26567 if (result
== error_mark_node
)
26568 result
= NULL_TREE
;
26570 else if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
26571 && DECL_CLASS_TEMPLATE_P (decl
))
26573 /* Obtain the template and the arguments. */
26574 tree tmpl
= TREE_OPERAND (fullname
, 0);
26575 if (TREE_CODE (tmpl
) == IDENTIFIER_NODE
)
26577 /* We get here with a plain identifier because a previous tentative
26578 parse of the nested-name-specifier as part of a ptr-operator saw
26579 ::template X<A>. The use of ::template is necessary in a
26580 ptr-operator, but wrong in a declarator-id.
26582 [temp.names]: In a qualified-id of a declarator-id, the keyword
26583 template shall not appear at the top level. */
26584 pedwarn (cp_expr_loc_or_loc (fullname
, input_location
), OPT_Wpedantic
,
26585 "keyword %<template%> not allowed in declarator-id");
26588 tree args
= TREE_OPERAND (fullname
, 1);
26589 /* Instantiate the template. */
26590 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
26591 /*entering_scope=*/true,
26592 tf_error
| tf_user
);
26593 if (result
== error_mark_node
)
26594 result
= NULL_TREE
;
26597 /* Leave the SCOPE. */
26599 pop_scope (pushed_scope
);
26601 /* If we failed to resolve it, return the original typename. */
26605 /* If lookup found a typename type, resolve that too. */
26606 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
26608 /* Ill-formed programs can cause infinite recursion here, so we
26609 must catch that. */
26610 TYPENAME_IS_RESOLVING_P (result
) = 1;
26611 result
= resolve_typename_type (result
, only_current_p
);
26612 TYPENAME_IS_RESOLVING_P (result
) = 0;
26615 /* Qualify the resulting type. */
26616 quals
= cp_type_quals (type
);
26618 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
26623 /* EXPR is an expression which is not type-dependent. Return a proxy
26624 for EXPR that can be used to compute the types of larger
26625 expressions containing EXPR. */
26628 build_non_dependent_expr (tree expr
)
26630 tree orig_expr
= expr
;
26633 /* When checking, try to get a constant value for all non-dependent
26634 expressions in order to expose bugs in *_dependent_expression_p
26635 and constexpr. This can affect code generation, see PR70704, so
26636 only do this for -fchecking=2. */
26637 if (flag_checking
> 1
26638 && cxx_dialect
>= cxx11
26639 /* Don't do this during nsdmi parsing as it can lead to
26640 unexpected recursive instantiations. */
26641 && !parsing_nsdmi ()
26642 /* Don't do this during concept expansion either and for
26643 the same reason. */
26644 && !expanding_concept ())
26645 fold_non_dependent_expr (expr
, tf_none
);
26647 STRIP_ANY_LOCATION_WRAPPER (expr
);
26649 /* Preserve OVERLOADs; the functions must be available to resolve
26652 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
26653 inner_expr
= stmt_expr_value_expr (inner_expr
);
26654 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
26655 inner_expr
= TREE_OPERAND (inner_expr
, 0);
26656 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
26657 inner_expr
= TREE_OPERAND (inner_expr
, 1);
26658 if (is_overloaded_fn (inner_expr
)
26659 || TREE_CODE (inner_expr
) == OFFSET_REF
)
26661 /* There is no need to return a proxy for a variable or enumerator. */
26662 if (VAR_P (expr
) || TREE_CODE (expr
) == CONST_DECL
)
26664 /* Preserve string constants; conversions from string constants to
26665 "char *" are allowed, even though normally a "const char *"
26666 cannot be used to initialize a "char *". */
26667 if (TREE_CODE (expr
) == STRING_CST
)
26669 /* Preserve void and arithmetic constants, as an optimization -- there is no
26670 reason to create a new node. */
26671 if (TREE_CODE (expr
) == VOID_CST
26672 || TREE_CODE (expr
) == INTEGER_CST
26673 || TREE_CODE (expr
) == REAL_CST
)
26675 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
26676 There is at least one place where we want to know that a
26677 particular expression is a throw-expression: when checking a ?:
26678 expression, there are special rules if the second or third
26679 argument is a throw-expression. */
26680 if (TREE_CODE (expr
) == THROW_EXPR
)
26683 /* Don't wrap an initializer list, we need to be able to look inside. */
26684 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
26687 /* Don't wrap a dummy object, we need to be able to test for it. */
26688 if (is_dummy_object (expr
))
26691 if (TREE_CODE (expr
) == COND_EXPR
)
26692 return build3 (COND_EXPR
,
26694 TREE_OPERAND (expr
, 0),
26695 (TREE_OPERAND (expr
, 1)
26696 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
26697 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
26698 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
26699 if (TREE_CODE (expr
) == COMPOUND_EXPR
26700 && !COMPOUND_EXPR_OVERLOADED (expr
))
26701 return build2 (COMPOUND_EXPR
,
26703 TREE_OPERAND (expr
, 0),
26704 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
26706 /* If the type is unknown, it can't really be non-dependent */
26707 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
26709 /* Otherwise, build a NON_DEPENDENT_EXPR. */
26710 return build1_loc (EXPR_LOCATION (orig_expr
), NON_DEPENDENT_EXPR
,
26711 TREE_TYPE (expr
), expr
);
26714 /* ARGS is a vector of expressions as arguments to a function call.
26715 Replace the arguments with equivalent non-dependent expressions.
26716 This modifies ARGS in place. */
26719 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
26724 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
26726 tree newarg
= build_non_dependent_expr (arg
);
26728 (*args
)[ix
] = newarg
;
26732 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
26733 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
26734 parms. If set_canonical is true, we set TYPE_CANONICAL on it. */
26737 make_auto_1 (tree name
, bool set_canonical
)
26739 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
26740 TYPE_NAME (au
) = build_decl (input_location
,
26741 TYPE_DECL
, name
, au
);
26742 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
26743 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
26744 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
26745 TYPE_NAME (au
), NULL_TREE
);
26747 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
26748 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
26749 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
26755 make_decltype_auto (void)
26757 return make_auto_1 (decltype_auto_identifier
, true);
26763 return make_auto_1 (auto_identifier
, true);
26766 /* Return a C++17 deduction placeholder for class template TMPL. */
26769 make_template_placeholder (tree tmpl
)
26771 tree t
= make_auto_1 (auto_identifier
, false);
26772 CLASS_PLACEHOLDER_TEMPLATE (t
) = tmpl
;
26773 /* Our canonical type depends on the placeholder. */
26774 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
26778 /* True iff T is a C++17 class template deduction placeholder. */
26781 template_placeholder_p (tree t
)
26783 return is_auto (t
) && CLASS_PLACEHOLDER_TEMPLATE (t
);
26786 /* Make a "constrained auto" type-specifier. This is an
26787 auto type with constraints that must be associated after
26788 deduction. The constraint is formed from the given
26789 CONC and its optional sequence of arguments, which are
26790 non-null if written as partial-concept-id. */
26793 make_constrained_auto (tree con
, tree args
)
26795 tree type
= make_auto_1 (auto_identifier
, false);
26797 /* Build the constraint. */
26798 tree tmpl
= DECL_TI_TEMPLATE (con
);
26799 tree expr
= VAR_P (con
) ? tmpl
: ovl_make (tmpl
);
26800 expr
= build_concept_check (expr
, type
, args
);
26802 tree constr
= normalize_expression (expr
);
26803 PLACEHOLDER_TYPE_CONSTRAINTS (type
) = constr
;
26805 /* Our canonical type depends on the constraint. */
26806 TYPE_CANONICAL (type
) = canonical_type_parameter (type
);
26808 /* Attach the constraint to the type declaration. */
26809 tree decl
= TYPE_NAME (type
);
26813 /* Given type ARG, return std::initializer_list<ARG>. */
26818 tree std_init_list
= get_namespace_binding (std_node
, init_list_identifier
);
26820 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
26822 gcc_rich_location
richloc (input_location
);
26823 maybe_add_include_fixit (&richloc
, "<initializer_list>", false);
26824 error_at (&richloc
,
26825 "deducing from brace-enclosed initializer list"
26826 " requires %<#include <initializer_list>%>");
26828 return error_mark_node
;
26830 tree argvec
= make_tree_vec (1);
26831 TREE_VEC_ELT (argvec
, 0) = arg
;
26833 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
26834 NULL_TREE
, 0, tf_warning_or_error
);
26837 /* Replace auto in TYPE with std::initializer_list<auto>. */
26840 listify_autos (tree type
, tree auto_node
)
26842 tree init_auto
= listify (auto_node
);
26843 tree argvec
= make_tree_vec (1);
26844 TREE_VEC_ELT (argvec
, 0) = init_auto
;
26845 if (processing_template_decl
)
26846 argvec
= add_to_template_args (current_template_args (), argvec
);
26847 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
26850 /* Hash traits for hashing possibly constrained 'auto'
26851 TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
26853 struct auto_hash
: default_hash_traits
<tree
>
26855 static inline hashval_t
hash (tree
);
26856 static inline bool equal (tree
, tree
);
26859 /* Hash the 'auto' T. */
26862 auto_hash::hash (tree t
)
26864 if (tree c
= NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS (t
)))
26865 /* Matching constrained-type-specifiers denote the same template
26866 parameter, so hash the constraint. */
26867 return hash_placeholder_constraint (c
);
26869 /* But unconstrained autos are all separate, so just hash the pointer. */
26870 return iterative_hash_object (t
, 0);
26873 /* Compare two 'auto's. */
26876 auto_hash::equal (tree t1
, tree t2
)
26881 tree c1
= PLACEHOLDER_TYPE_CONSTRAINTS (t1
);
26882 tree c2
= PLACEHOLDER_TYPE_CONSTRAINTS (t2
);
26884 /* Two unconstrained autos are distinct. */
26888 return equivalent_placeholder_constraints (c1
, c2
);
26891 /* for_each_template_parm callback for extract_autos: if t is a (possibly
26892 constrained) auto, add it to the vector. */
26895 extract_autos_r (tree t
, void *data
)
26897 hash_table
<auto_hash
> &hash
= *(hash_table
<auto_hash
>*)data
;
26900 /* All the autos were built with index 0; fix that up now. */
26901 tree
*p
= hash
.find_slot (t
, INSERT
);
26904 /* If this is a repeated constrained-type-specifier, use the index we
26906 idx
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (*p
));
26909 /* Otherwise this is new, so use the current count. */
26911 idx
= hash
.elements () - 1;
26913 TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (t
)) = idx
;
26916 /* Always keep walking. */
26920 /* Return a TREE_VEC of the 'auto's used in type under the Concepts TS, which
26921 says they can appear anywhere in the type. */
26924 extract_autos (tree type
)
26926 hash_set
<tree
> visited
;
26927 hash_table
<auto_hash
> hash (2);
26929 for_each_template_parm (type
, extract_autos_r
, &hash
, &visited
, true);
26931 tree tree_vec
= make_tree_vec (hash
.elements());
26932 for (hash_table
<auto_hash
>::iterator iter
= hash
.begin();
26933 iter
!= hash
.end(); ++iter
)
26936 unsigned i
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (elt
));
26937 TREE_VEC_ELT (tree_vec
, i
)
26938 = build_tree_list (NULL_TREE
, TYPE_NAME (elt
));
26944 /* The stem for deduction guide names. */
26945 const char *const dguide_base
= "__dguide_";
26947 /* Return the name for a deduction guide for class template TMPL. */
26950 dguide_name (tree tmpl
)
26952 tree type
= (TYPE_P (tmpl
) ? tmpl
: TREE_TYPE (tmpl
));
26953 tree tname
= TYPE_IDENTIFIER (type
);
26954 char *buf
= (char *) alloca (1 + strlen (dguide_base
)
26955 + IDENTIFIER_LENGTH (tname
));
26956 memcpy (buf
, dguide_base
, strlen (dguide_base
));
26957 memcpy (buf
+ strlen (dguide_base
), IDENTIFIER_POINTER (tname
),
26958 IDENTIFIER_LENGTH (tname
) + 1);
26959 tree dname
= get_identifier (buf
);
26960 TREE_TYPE (dname
) = type
;
26964 /* True if NAME is the name of a deduction guide. */
26967 dguide_name_p (tree name
)
26969 return (TREE_CODE (name
) == IDENTIFIER_NODE
26970 && TREE_TYPE (name
)
26971 && !strncmp (IDENTIFIER_POINTER (name
), dguide_base
,
26972 strlen (dguide_base
)));
26975 /* True if FN is a deduction guide. */
26978 deduction_guide_p (const_tree fn
)
26981 if (tree name
= DECL_NAME (fn
))
26982 return dguide_name_p (name
);
26986 /* True if FN is the copy deduction guide, i.e. A(A)->A. */
26989 copy_guide_p (const_tree fn
)
26991 gcc_assert (deduction_guide_p (fn
));
26992 if (!DECL_ARTIFICIAL (fn
))
26994 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (DECL_TI_TEMPLATE (fn
));
26995 return (TREE_CHAIN (parms
) == void_list_node
26996 && same_type_p (TREE_VALUE (parms
), TREE_TYPE (DECL_NAME (fn
))));
26999 /* True if FN is a guide generated from a constructor template. */
27002 template_guide_p (const_tree fn
)
27004 gcc_assert (deduction_guide_p (fn
));
27005 if (!DECL_ARTIFICIAL (fn
))
27007 tree tmpl
= DECL_TI_TEMPLATE (fn
);
27008 if (tree org
= DECL_ABSTRACT_ORIGIN (tmpl
))
27009 return PRIMARY_TEMPLATE_P (org
);
27013 /* OLDDECL is a _DECL for a template parameter. Return a similar parameter at
27014 LEVEL:INDEX, using tsubst_args and complain for substitution into non-type
27015 template parameter types. Note that the handling of template template
27016 parameters relies on current_template_parms being set appropriately for the
27020 rewrite_template_parm (tree olddecl
, unsigned index
, unsigned level
,
27021 tree tsubst_args
, tsubst_flags_t complain
)
27023 if (olddecl
== error_mark_node
)
27024 return error_mark_node
;
27026 tree oldidx
= get_template_parm_index (olddecl
);
27029 if (TREE_CODE (olddecl
) == TYPE_DECL
27030 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
27032 tree oldtype
= TREE_TYPE (olddecl
);
27033 newtype
= cxx_make_type (TREE_CODE (oldtype
));
27034 TYPE_MAIN_VARIANT (newtype
) = newtype
;
27035 if (TREE_CODE (oldtype
) == TEMPLATE_TYPE_PARM
)
27036 TEMPLATE_TYPE_PARM_FOR_CLASS (newtype
)
27037 = TEMPLATE_TYPE_PARM_FOR_CLASS (oldtype
);
27041 newtype
= TREE_TYPE (olddecl
);
27042 if (type_uses_auto (newtype
))
27044 // Substitute once to fix references to other template parameters.
27045 newtype
= tsubst (newtype
, tsubst_args
,
27046 complain
|tf_partial
, NULL_TREE
);
27047 // Now substitute again to reduce the level of the auto.
27048 newtype
= tsubst (newtype
, current_template_args (),
27049 complain
, NULL_TREE
);
27052 newtype
= tsubst (newtype
, tsubst_args
,
27053 complain
, NULL_TREE
);
27057 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TREE_CODE (olddecl
),
27058 DECL_NAME (olddecl
), newtype
);
27059 SET_DECL_TEMPLATE_PARM_P (newdecl
);
27062 if (TREE_CODE (olddecl
) == TYPE_DECL
27063 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
27065 newidx
= TEMPLATE_TYPE_PARM_INDEX (newtype
)
27066 = build_template_parm_index (index
, level
, level
,
27068 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
27069 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
27070 TYPE_STUB_DECL (newtype
) = TYPE_NAME (newtype
) = newdecl
;
27071 TYPE_CANONICAL (newtype
) = canonical_type_parameter (newtype
);
27073 if (TREE_CODE (olddecl
) == TEMPLATE_DECL
)
27075 DECL_TEMPLATE_RESULT (newdecl
)
27076 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TYPE_DECL
,
27077 DECL_NAME (olddecl
), newtype
);
27078 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (newdecl
)) = true;
27079 // First create a copy (ttargs) of tsubst_args with an
27080 // additional level for the template template parameter's own
27081 // template parameters (ttparms).
27082 tree ttparms
= (INNERMOST_TEMPLATE_PARMS
27083 (DECL_TEMPLATE_PARMS (olddecl
)));
27084 const int depth
= TMPL_ARGS_DEPTH (tsubst_args
);
27085 tree ttargs
= make_tree_vec (depth
+ 1);
27086 for (int i
= 0; i
< depth
; ++i
)
27087 TREE_VEC_ELT (ttargs
, i
) = TREE_VEC_ELT (tsubst_args
, i
);
27088 TREE_VEC_ELT (ttargs
, depth
)
27089 = template_parms_level_to_args (ttparms
);
27090 // Substitute ttargs into ttparms to fix references to
27091 // other template parameters.
27092 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
27093 complain
|tf_partial
);
27094 // Now substitute again with args based on tparms, to reduce
27095 // the level of the ttparms.
27096 ttargs
= current_template_args ();
27097 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
27099 // Finally, tack the adjusted parms onto tparms.
27100 ttparms
= tree_cons (size_int (depth
), ttparms
,
27101 current_template_parms
);
27102 DECL_TEMPLATE_PARMS (newdecl
) = ttparms
;
27107 tree oldconst
= TEMPLATE_PARM_DECL (oldidx
);
27109 = build_decl (DECL_SOURCE_LOCATION (oldconst
),
27110 TREE_CODE (oldconst
),
27111 DECL_NAME (oldconst
), newtype
);
27112 TREE_CONSTANT (newconst
) = TREE_CONSTANT (newdecl
)
27113 = TREE_READONLY (newconst
) = TREE_READONLY (newdecl
) = true;
27114 SET_DECL_TEMPLATE_PARM_P (newconst
);
27115 newidx
= build_template_parm_index (index
, level
, level
,
27116 newconst
, newtype
);
27117 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
27118 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
27119 DECL_INITIAL (newdecl
) = DECL_INITIAL (newconst
) = newidx
;
27125 /* Returns a C++17 class deduction guide template based on the constructor
27126 CTOR. As a special case, CTOR can be a RECORD_TYPE for an implicit default
27127 guide, or REFERENCE_TYPE for an implicit copy/move guide. */
27130 build_deduction_guide (tree ctor
, tree outer_args
, tsubst_flags_t complain
)
27132 tree type
, tparms
, targs
, fparms
, fargs
, ci
;
27133 bool memtmpl
= false;
27136 tree fn_tmpl
= NULL_TREE
;
27141 bool copy_p
= TYPE_REF_P (type
);
27144 type
= TREE_TYPE (type
);
27145 fparms
= tree_cons (NULL_TREE
, type
, void_list_node
);
27148 fparms
= void_list_node
;
27150 tree ctmpl
= CLASSTYPE_TI_TEMPLATE (type
);
27151 tparms
= DECL_TEMPLATE_PARMS (ctmpl
);
27152 targs
= CLASSTYPE_TI_ARGS (type
);
27155 loc
= DECL_SOURCE_LOCATION (ctmpl
);
27156 explicit_p
= false;
27160 ++processing_template_decl
;
27164 = (TREE_CODE (ctor
) == TEMPLATE_DECL
? ctor
27165 : DECL_TI_TEMPLATE (ctor
));
27167 fn_tmpl
= tsubst (fn_tmpl
, outer_args
, complain
, ctor
);
27168 ctor
= DECL_TEMPLATE_RESULT (fn_tmpl
);
27170 type
= DECL_CONTEXT (ctor
);
27172 tparms
= DECL_TEMPLATE_PARMS (fn_tmpl
);
27173 /* If type is a member class template, DECL_TI_ARGS (ctor) will have
27174 fully specialized args for the enclosing class. Strip those off, as
27175 the deduction guide won't have those template parameters. */
27176 targs
= get_innermost_template_args (DECL_TI_ARGS (ctor
),
27177 TMPL_PARMS_DEPTH (tparms
));
27178 /* Discard the 'this' parameter. */
27179 fparms
= FUNCTION_ARG_CHAIN (ctor
);
27180 fargs
= TREE_CHAIN (DECL_ARGUMENTS (ctor
));
27181 ci
= get_constraints (ctor
);
27182 loc
= DECL_SOURCE_LOCATION (ctor
);
27183 explicit_p
= DECL_NONCONVERTING_P (ctor
);
27185 if (PRIMARY_TEMPLATE_P (fn_tmpl
))
27189 /* For a member template constructor, we need to flatten the two
27190 template parameter lists into one, and then adjust the function
27191 signature accordingly. This gets...complicated. */
27192 tree save_parms
= current_template_parms
;
27194 /* For a member template we should have two levels of parms/args, one
27195 for the class and one for the constructor. We stripped
27196 specialized args for further enclosing classes above. */
27197 const int depth
= 2;
27198 gcc_assert (TMPL_ARGS_DEPTH (targs
) == depth
);
27200 /* Template args for translating references to the two-level template
27201 parameters into references to the one-level template parameters we
27203 tree tsubst_args
= copy_node (targs
);
27204 TMPL_ARGS_LEVEL (tsubst_args
, depth
)
27205 = copy_node (TMPL_ARGS_LEVEL (tsubst_args
, depth
));
27207 /* Template parms for the constructor template. */
27208 tree ftparms
= TREE_VALUE (tparms
);
27209 unsigned flen
= TREE_VEC_LENGTH (ftparms
);
27210 /* Template parms for the class template. */
27211 tparms
= TREE_CHAIN (tparms
);
27212 tree ctparms
= TREE_VALUE (tparms
);
27213 unsigned clen
= TREE_VEC_LENGTH (ctparms
);
27214 /* Template parms for the deduction guide start as a copy of the
27215 template parms for the class. We set current_template_parms for
27216 lookup_template_class_1. */
27217 current_template_parms
= tparms
= copy_node (tparms
);
27218 tree new_vec
= TREE_VALUE (tparms
) = make_tree_vec (flen
+ clen
);
27219 for (unsigned i
= 0; i
< clen
; ++i
)
27220 TREE_VEC_ELT (new_vec
, i
) = TREE_VEC_ELT (ctparms
, i
);
27222 /* Now we need to rewrite the constructor parms to append them to the
27224 for (unsigned i
= 0; i
< flen
; ++i
)
27226 unsigned index
= i
+ clen
;
27227 unsigned level
= 1;
27228 tree oldelt
= TREE_VEC_ELT (ftparms
, i
);
27229 tree olddecl
= TREE_VALUE (oldelt
);
27230 tree newdecl
= rewrite_template_parm (olddecl
, index
, level
,
27231 tsubst_args
, complain
);
27232 if (newdecl
== error_mark_node
)
27234 tree newdef
= tsubst_template_arg (TREE_PURPOSE (oldelt
),
27235 tsubst_args
, complain
, ctor
);
27236 tree list
= build_tree_list (newdef
, newdecl
);
27237 TEMPLATE_PARM_CONSTRAINTS (list
)
27238 = tsubst_constraint_info (TEMPLATE_PARM_CONSTRAINTS (oldelt
),
27239 tsubst_args
, complain
, ctor
);
27240 TREE_VEC_ELT (new_vec
, index
) = list
;
27241 TMPL_ARG (tsubst_args
, depth
, i
) = template_parm_to_arg (list
);
27244 /* Now we have a final set of template parms to substitute into the
27245 function signature. */
27246 targs
= template_parms_to_args (tparms
);
27247 fparms
= tsubst_arg_types (fparms
, tsubst_args
, NULL_TREE
,
27249 if (fparms
== error_mark_node
)
27251 fargs
= tsubst (fargs
, tsubst_args
, complain
, ctor
);
27253 ci
= tsubst_constraint_info (ci
, tsubst_args
, complain
, ctor
);
27255 current_template_parms
= save_parms
;
27258 --processing_template_decl
;
27260 return error_mark_node
;
27265 /* Copy the parms so we can set DECL_PRIMARY_TEMPLATE. */
27266 tparms
= copy_node (tparms
);
27267 INNERMOST_TEMPLATE_PARMS (tparms
)
27268 = copy_node (INNERMOST_TEMPLATE_PARMS (tparms
));
27271 tree fntype
= build_function_type (type
, fparms
);
27272 tree ded_fn
= build_lang_decl_loc (loc
,
27274 dguide_name (type
), fntype
);
27275 DECL_ARGUMENTS (ded_fn
) = fargs
;
27276 DECL_ARTIFICIAL (ded_fn
) = true;
27277 DECL_NONCONVERTING_P (ded_fn
) = explicit_p
;
27278 tree ded_tmpl
= build_template_decl (ded_fn
, tparms
, /*member*/false);
27279 DECL_ARTIFICIAL (ded_tmpl
) = true;
27280 DECL_TEMPLATE_RESULT (ded_tmpl
) = ded_fn
;
27281 TREE_TYPE (ded_tmpl
) = TREE_TYPE (ded_fn
);
27282 DECL_TEMPLATE_INFO (ded_fn
) = build_template_info (ded_tmpl
, targs
);
27283 DECL_PRIMARY_TEMPLATE (ded_tmpl
) = ded_tmpl
;
27285 DECL_ABSTRACT_ORIGIN (ded_tmpl
) = fn_tmpl
;
27287 set_constraints (ded_tmpl
, ci
);
27292 /* Deduce template arguments for the class template placeholder PTYPE for
27293 template TMPL based on the initializer INIT, and return the resulting
27297 do_class_deduction (tree ptype
, tree tmpl
, tree init
, int flags
,
27298 tsubst_flags_t complain
)
27300 if (!DECL_CLASS_TEMPLATE_P (tmpl
))
27302 /* We should have handled this in the caller. */
27303 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
))
27305 if (complain
& tf_error
)
27306 error ("non-class template %qT used without template arguments", tmpl
);
27307 return error_mark_node
;
27309 if (init
&& TREE_TYPE (init
) == ptype
)
27310 /* Using the template parm as its own argument. */
27313 tree type
= TREE_TYPE (tmpl
);
27315 bool try_list_ctor
= false;
27317 vec
<tree
,va_gc
> *args
;
27318 if (init
== NULL_TREE
27319 || TREE_CODE (init
) == TREE_LIST
)
27320 args
= make_tree_vector_from_list (init
);
27321 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
27323 try_list_ctor
= TYPE_HAS_LIST_CTOR (type
);
27324 if (try_list_ctor
&& CONSTRUCTOR_NELTS (init
) == 1)
27326 /* As an exception, the first phase in 16.3.1.7 (considering the
27327 initializer list as a single argument) is omitted if the
27328 initializer list consists of a single expression of type cv U,
27329 where U is a specialization of C or a class derived from a
27330 specialization of C. */
27331 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
27332 tree etype
= TREE_TYPE (elt
);
27334 tree tparms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
27335 tree targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
27336 int err
= unify (tparms
, targs
, type
, etype
,
27337 UNIFY_ALLOW_DERIVED
, /*explain*/false);
27339 try_list_ctor
= false;
27342 if (try_list_ctor
|| is_std_init_list (type
))
27343 args
= make_tree_vector_single (init
);
27345 args
= make_tree_vector_from_ctor (init
);
27348 args
= make_tree_vector_single (init
);
27350 tree dname
= dguide_name (tmpl
);
27351 tree cands
= lookup_qualified_name (CP_DECL_CONTEXT (tmpl
), dname
,
27352 /*type*/false, /*complain*/false,
27354 bool elided
= false;
27355 if (cands
== error_mark_node
)
27358 /* Prune explicit deduction guides in copy-initialization context. */
27359 if (flags
& LOOKUP_ONLYCONVERTING
)
27361 for (lkp_iterator
iter (cands
); !elided
&& iter
; ++iter
)
27362 if (DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
27367 /* Found a nonconverting guide, prune the candidates. */
27368 tree pruned
= NULL_TREE
;
27369 for (lkp_iterator
iter (cands
); iter
; ++iter
)
27370 if (!DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
27371 pruned
= lookup_add (*iter
, pruned
);
27377 tree outer_args
= NULL_TREE
;
27378 if (DECL_CLASS_SCOPE_P (tmpl
)
27379 && CLASSTYPE_TEMPLATE_INSTANTIATION (DECL_CONTEXT (tmpl
)))
27381 outer_args
= CLASSTYPE_TI_ARGS (DECL_CONTEXT (tmpl
));
27382 type
= TREE_TYPE (most_general_template (tmpl
));
27385 bool saw_ctor
= false;
27386 // FIXME cache artificial deduction guides
27387 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (type
)); iter
; ++iter
)
27389 /* Skip inherited constructors. */
27390 if (iter
.using_p ())
27393 tree guide
= build_deduction_guide (*iter
, outer_args
, complain
);
27394 if (guide
== error_mark_node
)
27395 return error_mark_node
;
27396 if ((flags
& LOOKUP_ONLYCONVERTING
)
27397 && DECL_NONCONVERTING_P (STRIP_TEMPLATE (guide
)))
27400 cands
= lookup_add (guide
, cands
);
27405 tree call
= error_mark_node
;
27407 /* If this is list-initialization and the class has a list constructor, first
27408 try deducing from the list as a single argument, as [over.match.list]. */
27409 tree list_cands
= NULL_TREE
;
27410 if (try_list_ctor
&& cands
)
27411 for (lkp_iterator
iter (cands
); iter
; ++iter
)
27414 if (is_list_ctor (dg
))
27415 list_cands
= lookup_add (dg
, list_cands
);
27419 ++cp_unevaluated_operand
;
27420 call
= build_new_function_call (list_cands
, &args
, tf_decltype
);
27421 --cp_unevaluated_operand
;
27423 if (call
== error_mark_node
)
27425 /* That didn't work, now try treating the list as a sequence of
27427 release_tree_vector (args
);
27428 args
= make_tree_vector_from_ctor (init
);
27432 /* Maybe generate an implicit deduction guide. */
27433 if (call
== error_mark_node
&& args
->length () < 2)
27435 tree gtype
= NULL_TREE
;
27437 if (args
->length () == 1)
27438 /* Generate a copy guide. */
27439 gtype
= build_reference_type (type
);
27440 else if (!saw_ctor
)
27441 /* Generate a default guide. */
27446 tree guide
= build_deduction_guide (gtype
, outer_args
, complain
);
27447 if (guide
== error_mark_node
)
27448 return error_mark_node
;
27449 cands
= lookup_add (guide
, cands
);
27453 if (elided
&& !cands
)
27455 error ("cannot deduce template arguments for copy-initialization"
27456 " of %qT, as it has no non-explicit deduction guides or "
27457 "user-declared constructors", type
);
27458 return error_mark_node
;
27460 else if (!cands
&& call
== error_mark_node
)
27462 error ("cannot deduce template arguments of %qT, as it has no viable "
27463 "deduction guides", type
);
27464 return error_mark_node
;
27467 if (call
== error_mark_node
)
27469 ++cp_unevaluated_operand
;
27470 call
= build_new_function_call (cands
, &args
, tf_decltype
);
27471 --cp_unevaluated_operand
;
27474 if (call
== error_mark_node
&& (complain
& tf_warning_or_error
))
27476 error ("class template argument deduction failed:");
27478 ++cp_unevaluated_operand
;
27479 call
= build_new_function_call (cands
, &args
, complain
| tf_decltype
);
27480 --cp_unevaluated_operand
;
27483 inform (input_location
, "explicit deduction guides not considered "
27484 "for copy-initialization");
27487 release_tree_vector (args
);
27489 return cp_build_qualified_type (TREE_TYPE (call
), cp_type_quals (ptype
));
27492 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
27493 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
27494 The CONTEXT determines the context in which auto deduction is performed
27495 and is used to control error diagnostics. FLAGS are the LOOKUP_* flags.
27496 OUTER_TARGS are used during template argument deduction
27497 (context == adc_unify) to properly substitute the result, and is ignored
27500 For partial-concept-ids, extra args may be appended to the list of deduced
27501 template arguments prior to determining constraint satisfaction. */
27504 do_auto_deduction (tree type
, tree init
, tree auto_node
,
27505 tsubst_flags_t complain
, auto_deduction_context context
,
27506 tree outer_targs
, int flags
)
27510 if (init
== error_mark_node
)
27511 return error_mark_node
;
27513 if (init
&& type_dependent_expression_p (init
)
27514 && context
!= adc_unify
)
27515 /* Defining a subset of type-dependent expressions that we can deduce
27516 from ahead of time isn't worth the trouble. */
27519 /* Similarly, we can't deduce from another undeduced decl. */
27520 if (init
&& undeduced_auto_decl (init
))
27523 /* We may be doing a partial substitution, but we still want to replace
27525 complain
&= ~tf_partial
;
27527 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
27528 /* C++17 class template argument deduction. */
27529 return do_class_deduction (type
, tmpl
, init
, flags
, complain
);
27531 if (init
== NULL_TREE
|| TREE_TYPE (init
) == NULL_TREE
)
27532 /* Nothing we can do with this, even in deduction context. */
27535 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
27536 with either a new invented type template parameter U or, if the
27537 initializer is a braced-init-list (8.5.4), with
27538 std::initializer_list<U>. */
27539 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
27541 if (!DIRECT_LIST_INIT_P (init
))
27542 type
= listify_autos (type
, auto_node
);
27543 else if (CONSTRUCTOR_NELTS (init
) == 1)
27544 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
27547 if (complain
& tf_warning_or_error
)
27549 if (permerror (input_location
, "direct-list-initialization of "
27550 "%<auto%> requires exactly one element"))
27551 inform (input_location
,
27552 "for deduction to %<std::initializer_list%>, use copy-"
27553 "list-initialization (i.e. add %<=%> before the %<{%>)");
27555 type
= listify_autos (type
, auto_node
);
27559 if (type
== error_mark_node
)
27560 return error_mark_node
;
27562 init
= resolve_nondeduced_context (init
, complain
);
27564 if (context
== adc_decomp_type
27565 && auto_node
== type
27566 && init
!= error_mark_node
27567 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
27568 /* [dcl.decomp]/1 - if decomposition declaration has no ref-qualifiers
27569 and initializer has array type, deduce cv-qualified array type. */
27570 return cp_build_qualified_type_real (TREE_TYPE (init
), TYPE_QUALS (type
),
27572 else if (AUTO_IS_DECLTYPE (auto_node
))
27574 tree stripped_init
= tree_strip_any_location_wrapper (init
);
27575 bool id
= (DECL_P (stripped_init
)
27576 || ((TREE_CODE (init
) == COMPONENT_REF
27577 || TREE_CODE (init
) == SCOPE_REF
)
27578 && !REF_PARENTHESIZED_P (init
)));
27579 targs
= make_tree_vec (1);
27580 TREE_VEC_ELT (targs
, 0)
27581 = finish_decltype_type (init
, id
, tf_warning_or_error
);
27582 if (type
!= auto_node
)
27584 if (complain
& tf_error
)
27585 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
27586 return error_mark_node
;
27591 tree parms
= build_tree_list (NULL_TREE
, type
);
27595 tparms
= extract_autos (type
);
27598 tparms
= make_tree_vec (1);
27599 TREE_VEC_ELT (tparms
, 0)
27600 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
27603 targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
27604 int val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
27606 NULL
, /*explain_p=*/false);
27609 if (processing_template_decl
)
27610 /* Try again at instantiation time. */
27612 if (type
&& type
!= error_mark_node
27613 && (complain
& tf_error
))
27614 /* If type is error_mark_node a diagnostic must have been
27615 emitted by now. Also, having a mention to '<type error>'
27616 in the diagnostic is not really useful to the user. */
27618 if (cfun
&& auto_node
== current_function_auto_return_pattern
27619 && LAMBDA_FUNCTION_P (current_function_decl
))
27620 error ("unable to deduce lambda return type from %qE", init
);
27622 error ("unable to deduce %qT from %qE", type
, init
);
27623 type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
27625 NULL
, /*explain_p=*/true);
27627 return error_mark_node
;
27631 /* Check any placeholder constraints against the deduced type. */
27632 if (flag_concepts
&& !processing_template_decl
)
27633 if (tree constr
= NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS (auto_node
)))
27635 /* Use the deduced type to check the associated constraints. If we
27636 have a partial-concept-id, rebuild the argument list so that
27637 we check using the extra arguments. */
27638 gcc_assert (TREE_CODE (constr
) == CHECK_CONSTR
);
27639 tree cargs
= CHECK_CONSTR_ARGS (constr
);
27640 if (TREE_VEC_LENGTH (cargs
) > 1)
27642 cargs
= copy_node (cargs
);
27643 TREE_VEC_ELT (cargs
, 0) = TREE_VEC_ELT (targs
, 0);
27647 if (!constraints_satisfied_p (constr
, cargs
))
27649 if (complain
& tf_warning_or_error
)
27651 auto_diagnostic_group d
;
27654 case adc_unspecified
:
27656 error("placeholder constraints not satisfied");
27658 case adc_variable_type
:
27659 case adc_decomp_type
:
27660 error ("deduced initializer does not satisfy "
27661 "placeholder constraints");
27663 case adc_return_type
:
27664 error ("deduced return type does not satisfy "
27665 "placeholder constraints");
27667 case adc_requirement
:
27668 error ("deduced expression type does not satisfy "
27669 "placeholder constraints");
27672 diagnose_constraints (input_location
, constr
, targs
);
27674 return error_mark_node
;
27678 if (processing_template_decl
&& context
!= adc_unify
)
27679 outer_targs
= current_template_args ();
27680 targs
= add_to_template_args (outer_targs
, targs
);
27681 return tsubst (type
, targs
, complain
, NULL_TREE
);
27684 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
27688 splice_late_return_type (tree type
, tree late_return_type
)
27690 if (is_auto (type
))
27692 if (late_return_type
)
27693 return late_return_type
;
27695 tree idx
= get_template_parm_index (type
);
27696 if (TEMPLATE_PARM_LEVEL (idx
) <= processing_template_decl
)
27697 /* In an abbreviated function template we didn't know we were dealing
27698 with a function template when we saw the auto return type, so update
27699 it to have the correct level. */
27700 return make_auto_1 (TYPE_IDENTIFIER (type
), true);
27705 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
27706 'decltype(auto)' or a deduced class template. */
27709 is_auto (const_tree type
)
27711 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
27712 && (TYPE_IDENTIFIER (type
) == auto_identifier
27713 || TYPE_IDENTIFIER (type
) == decltype_auto_identifier
))
27719 /* for_each_template_parm callback for type_uses_auto. */
27722 is_auto_r (tree tp
, void */
*data*/
)
27724 return is_auto (tp
);
27727 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
27728 a use of `auto'. Returns NULL_TREE otherwise. */
27731 type_uses_auto (tree type
)
27733 if (type
== NULL_TREE
)
27735 else if (flag_concepts
)
27737 /* The Concepts TS allows multiple autos in one type-specifier; just
27738 return the first one we find, do_auto_deduction will collect all of
27740 if (uses_template_parms (type
))
27741 return for_each_template_parm (type
, is_auto_r
, /*data*/NULL
,
27742 /*visited*/NULL
, /*nondeduced*/false);
27747 return find_type_usage (type
, is_auto
);
27750 /* Report ill-formed occurrences of auto types in ARGUMENTS. If
27751 concepts are enabled, auto is acceptable in template arguments, but
27752 only when TEMPL identifies a template class. Return TRUE if any
27753 such errors were reported. */
27756 check_auto_in_tmpl_args (tree tmpl
, tree args
)
27758 /* If there were previous errors, nevermind. */
27759 if (!args
|| TREE_CODE (args
) != TREE_VEC
)
27762 /* If TMPL is an identifier, we're parsing and we can't tell yet
27763 whether TMPL is supposed to be a type, a function or a variable.
27764 We'll only be able to tell during template substitution, so we
27765 expect to be called again then. If concepts are enabled and we
27766 know we have a type, we're ok. */
27768 && (identifier_p (tmpl
)
27770 && (DECL_TYPE_TEMPLATE_P (tmpl
)
27771 || DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)))))
27774 /* Quickly search for any occurrences of auto; usually there won't
27775 be any, and then we'll avoid allocating the vector. */
27776 if (!type_uses_auto (args
))
27779 bool errors
= false;
27781 tree vec
= extract_autos (args
);
27782 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); i
++)
27784 tree xauto
= TREE_VALUE (TREE_VEC_ELT (vec
, i
));
27785 error_at (DECL_SOURCE_LOCATION (xauto
),
27786 "invalid use of %qT in template argument", xauto
);
27793 /* For a given template T, return the vector of typedefs referenced
27794 in T for which access check is needed at T instantiation time.
27795 T is either a FUNCTION_DECL or a RECORD_TYPE.
27796 Those typedefs were added to T by the function
27797 append_type_to_template_for_access_check. */
27799 vec
<qualified_typedef_usage_t
, va_gc
> *
27800 get_types_needing_access_check (tree t
)
27803 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
27805 if (!t
|| t
== error_mark_node
)
27808 if (!(ti
= get_template_info (t
)))
27811 if (CLASS_TYPE_P (t
)
27812 || TREE_CODE (t
) == FUNCTION_DECL
)
27814 if (!TI_TEMPLATE (ti
))
27817 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
27823 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
27824 tied to T. That list of typedefs will be access checked at
27825 T instantiation time.
27826 T is either a FUNCTION_DECL or a RECORD_TYPE.
27827 TYPE_DECL is a TYPE_DECL node representing a typedef.
27828 SCOPE is the scope through which TYPE_DECL is accessed.
27829 LOCATION is the location of the usage point of TYPE_DECL.
27831 This function is a subroutine of
27832 append_type_to_template_for_access_check. */
27835 append_type_to_template_for_access_check_1 (tree t
,
27838 location_t location
)
27840 qualified_typedef_usage_t typedef_usage
;
27843 if (!t
|| t
== error_mark_node
)
27846 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
27847 || CLASS_TYPE_P (t
))
27849 && TREE_CODE (type_decl
) == TYPE_DECL
27852 if (!(ti
= get_template_info (t
)))
27855 gcc_assert (TI_TEMPLATE (ti
));
27857 typedef_usage
.typedef_decl
= type_decl
;
27858 typedef_usage
.context
= scope
;
27859 typedef_usage
.locus
= location
;
27861 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
27864 /* Append TYPE_DECL to the template TEMPL.
27865 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
27866 At TEMPL instanciation time, TYPE_DECL will be checked to see
27867 if it can be accessed through SCOPE.
27868 LOCATION is the location of the usage point of TYPE_DECL.
27870 e.g. consider the following code snippet:
27877 template<class U> struct S
27879 C::myint mi; // <-- usage point of the typedef C::myint
27884 At S<char> instantiation time, we need to check the access of C::myint
27885 In other words, we need to check the access of the myint typedef through
27886 the C scope. For that purpose, this function will add the myint typedef
27887 and the scope C through which its being accessed to a list of typedefs
27888 tied to the template S. That list will be walked at template instantiation
27889 time and access check performed on each typedefs it contains.
27890 Note that this particular code snippet should yield an error because
27891 myint is private to C. */
27894 append_type_to_template_for_access_check (tree templ
,
27897 location_t location
)
27899 qualified_typedef_usage_t
*iter
;
27902 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
27904 /* Make sure we don't append the type to the template twice. */
27905 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
27906 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
27909 append_type_to_template_for_access_check_1 (templ
, type_decl
,
27913 /* Convert the generic type parameters in PARM that match the types given in the
27914 range [START_IDX, END_IDX) from the current_template_parms into generic type
27918 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
27920 tree current
= current_template_parms
;
27921 int depth
= TMPL_PARMS_DEPTH (current
);
27922 current
= INNERMOST_TEMPLATE_PARMS (current
);
27923 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
27925 for (int i
= 0; i
< start_idx
; ++i
)
27926 TREE_VEC_ELT (replacement
, i
)
27927 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
27929 for (int i
= start_idx
; i
< end_idx
; ++i
)
27931 /* Create a distinct parameter pack type from the current parm and add it
27932 to the replacement args to tsubst below into the generic function
27935 tree o
= TREE_TYPE (TREE_VALUE
27936 (TREE_VEC_ELT (current
, i
)));
27937 tree t
= copy_type (o
);
27938 TEMPLATE_TYPE_PARM_INDEX (t
)
27939 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
27941 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
27942 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
27943 TYPE_MAIN_VARIANT (t
) = t
;
27944 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
27945 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
27946 TREE_VEC_ELT (replacement
, i
) = t
;
27947 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
27950 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
27951 TREE_VEC_ELT (replacement
, i
)
27952 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
27954 /* If there are more levels then build up the replacement with the outer
27957 replacement
= add_to_template_args (template_parms_to_args
27958 (TREE_CHAIN (current_template_parms
)),
27961 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
27964 /* Entries in the decl_constraint hash table. */
27965 struct GTY((for_user
)) constr_entry
27971 /* Hashing function and equality for constraint entries. */
27972 struct constr_hasher
: ggc_ptr_hash
<constr_entry
>
27974 static hashval_t
hash (constr_entry
*e
)
27976 return (hashval_t
)DECL_UID (e
->decl
);
27979 static bool equal (constr_entry
*e1
, constr_entry
*e2
)
27981 return e1
->decl
== e2
->decl
;
27985 /* A mapping from declarations to constraint information. Note that
27986 both templates and their underlying declarations are mapped to the
27987 same constraint information.
27989 FIXME: This is defined in pt.c because garbage collection
27990 code is not being generated for constraint.cc. */
27992 static GTY (()) hash_table
<constr_hasher
> *decl_constraints
;
27994 /* Returns the template constraints of declaration T. If T is not
27995 constrained, return NULL_TREE. Note that T must be non-null. */
27998 get_constraints (tree t
)
28000 if (!flag_concepts
)
28003 gcc_assert (DECL_P (t
));
28004 if (TREE_CODE (t
) == TEMPLATE_DECL
)
28005 t
= DECL_TEMPLATE_RESULT (t
);
28006 constr_entry elt
= { t
, NULL_TREE
};
28007 constr_entry
* found
= decl_constraints
->find (&elt
);
28014 /* Associate the given constraint information CI with the declaration
28015 T. If T is a template, then the constraints are associated with
28016 its underlying declaration. Don't build associations if CI is
28020 set_constraints (tree t
, tree ci
)
28024 gcc_assert (t
&& flag_concepts
);
28025 if (TREE_CODE (t
) == TEMPLATE_DECL
)
28026 t
= DECL_TEMPLATE_RESULT (t
);
28027 gcc_assert (!get_constraints (t
));
28028 constr_entry elt
= {t
, ci
};
28029 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, INSERT
);
28030 constr_entry
* entry
= ggc_alloc
<constr_entry
> ();
28035 /* Remove the associated constraints of the declaration T. */
28038 remove_constraints (tree t
)
28040 gcc_assert (DECL_P (t
));
28041 if (TREE_CODE (t
) == TEMPLATE_DECL
)
28042 t
= DECL_TEMPLATE_RESULT (t
);
28044 constr_entry elt
= {t
, NULL_TREE
};
28045 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, NO_INSERT
);
28047 decl_constraints
->clear_slot (slot
);
28050 /* Memoized satisfaction results for declarations. This
28051 maps the pair (constraint_info, arguments) to the result computed
28052 by constraints_satisfied_p. */
28054 struct GTY((for_user
)) constraint_sat_entry
28061 /* Hashing function and equality for constraint entries. */
28063 struct constraint_sat_hasher
: ggc_ptr_hash
<constraint_sat_entry
>
28065 static hashval_t
hash (constraint_sat_entry
*e
)
28067 hashval_t val
= iterative_hash_object(e
->ci
, 0);
28068 return iterative_hash_template_arg (e
->args
, val
);
28071 static bool equal (constraint_sat_entry
*e1
, constraint_sat_entry
*e2
)
28073 return e1
->ci
== e2
->ci
&& comp_template_args (e1
->args
, e2
->args
);
28077 /* Memoized satisfaction results for concept checks. */
28079 struct GTY((for_user
)) concept_spec_entry
28086 /* Hashing function and equality for constraint entries. */
28088 struct concept_spec_hasher
: ggc_ptr_hash
<concept_spec_entry
>
28090 static hashval_t
hash (concept_spec_entry
*e
)
28092 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
28095 static bool equal (concept_spec_entry
*e1
, concept_spec_entry
*e2
)
28097 ++comparing_specializations
;
28098 bool eq
= e1
->tmpl
== e2
->tmpl
&& comp_template_args (e1
->args
, e2
->args
);
28099 --comparing_specializations
;
28104 static GTY (()) hash_table
<constraint_sat_hasher
> *constraint_memos
;
28105 static GTY (()) hash_table
<concept_spec_hasher
> *concept_memos
;
28107 /* Search for a memoized satisfaction result. Returns one of the
28108 truth value nodes if previously memoized, or NULL_TREE otherwise. */
28111 lookup_constraint_satisfaction (tree ci
, tree args
)
28113 constraint_sat_entry elt
= { ci
, args
, NULL_TREE
};
28114 constraint_sat_entry
* found
= constraint_memos
->find (&elt
);
28116 return found
->result
;
28121 /* Memoize the result of a satisfication test. Returns the saved result. */
28124 memoize_constraint_satisfaction (tree ci
, tree args
, tree result
)
28126 constraint_sat_entry elt
= {ci
, args
, result
};
28127 constraint_sat_entry
** slot
= constraint_memos
->find_slot (&elt
, INSERT
);
28128 constraint_sat_entry
* entry
= ggc_alloc
<constraint_sat_entry
> ();
28134 /* Search for a memoized satisfaction result for a concept. */
28137 lookup_concept_satisfaction (tree tmpl
, tree args
)
28139 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
28140 concept_spec_entry
* found
= concept_memos
->find (&elt
);
28142 return found
->result
;
28147 /* Memoize the result of a concept check. Returns the saved result. */
28150 memoize_concept_satisfaction (tree tmpl
, tree args
, tree result
)
28152 concept_spec_entry elt
= {tmpl
, args
, result
};
28153 concept_spec_entry
** slot
= concept_memos
->find_slot (&elt
, INSERT
);
28154 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
28160 static GTY (()) hash_table
<concept_spec_hasher
> *concept_expansions
;
28162 /* Returns a prior concept specialization. This returns the substituted
28163 and normalized constraints defined by the concept. */
28166 get_concept_expansion (tree tmpl
, tree args
)
28168 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
28169 concept_spec_entry
* found
= concept_expansions
->find (&elt
);
28171 return found
->result
;
28176 /* Save a concept expansion for later. */
28179 save_concept_expansion (tree tmpl
, tree args
, tree def
)
28181 concept_spec_entry elt
= {tmpl
, args
, def
};
28182 concept_spec_entry
** slot
= concept_expansions
->find_slot (&elt
, INSERT
);
28183 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
28190 hash_subsumption_args (tree t1
, tree t2
)
28192 gcc_assert (TREE_CODE (t1
) == CHECK_CONSTR
);
28193 gcc_assert (TREE_CODE (t2
) == CHECK_CONSTR
);
28195 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t1
), val
);
28196 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t1
), val
);
28197 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t2
), val
);
28198 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t2
), val
);
28202 /* Compare the constraints of two subsumption entries. The LEFT1 and
28203 LEFT2 arguments comprise the first subsumption pair and the RIGHT1
28204 and RIGHT2 arguments comprise the second. These are all CHECK_CONSTRs. */
28207 comp_subsumption_args (tree left1
, tree left2
, tree right1
, tree right2
)
28209 if (CHECK_CONSTR_CONCEPT (left1
) == CHECK_CONSTR_CONCEPT (right1
))
28210 if (CHECK_CONSTR_CONCEPT (left2
) == CHECK_CONSTR_CONCEPT (right2
))
28211 if (comp_template_args (CHECK_CONSTR_ARGS (left1
),
28212 CHECK_CONSTR_ARGS (right1
)))
28213 return comp_template_args (CHECK_CONSTR_ARGS (left2
),
28214 CHECK_CONSTR_ARGS (right2
));
28218 /* Key/value pair for learning and memoizing subsumption results. This
28219 associates a pair of check constraints (including arguments) with
28220 a boolean value indicating the result. */
28222 struct GTY((for_user
)) subsumption_entry
28229 /* Hashing function and equality for constraint entries. */
28231 struct subsumption_hasher
: ggc_ptr_hash
<subsumption_entry
>
28233 static hashval_t
hash (subsumption_entry
*e
)
28235 return hash_subsumption_args (e
->t1
, e
->t2
);
28238 static bool equal (subsumption_entry
*e1
, subsumption_entry
*e2
)
28240 ++comparing_specializations
;
28241 bool eq
= comp_subsumption_args(e1
->t1
, e1
->t2
, e2
->t1
, e2
->t2
);
28242 --comparing_specializations
;
28247 static GTY (()) hash_table
<subsumption_hasher
> *subsumption_table
;
28249 /* Search for a previously cached subsumption result. */
28252 lookup_subsumption_result (tree t1
, tree t2
)
28254 subsumption_entry elt
= { t1
, t2
, false };
28255 subsumption_entry
* found
= subsumption_table
->find (&elt
);
28257 return &found
->result
;
28262 /* Save a subsumption result. */
28265 save_subsumption_result (tree t1
, tree t2
, bool result
)
28267 subsumption_entry elt
= {t1
, t2
, result
};
28268 subsumption_entry
** slot
= subsumption_table
->find_slot (&elt
, INSERT
);
28269 subsumption_entry
* entry
= ggc_alloc
<subsumption_entry
> ();
28275 /* Set up the hash table for constraint association. */
28278 init_constraint_processing (void)
28280 if (!flag_concepts
)
28283 decl_constraints
= hash_table
<constr_hasher
>::create_ggc(37);
28284 constraint_memos
= hash_table
<constraint_sat_hasher
>::create_ggc(37);
28285 concept_memos
= hash_table
<concept_spec_hasher
>::create_ggc(37);
28286 concept_expansions
= hash_table
<concept_spec_hasher
>::create_ggc(37);
28287 subsumption_table
= hash_table
<subsumption_hasher
>::create_ggc(37);
28290 /* __integer_pack(N) in a pack expansion expands to a sequence of numbers from
28294 declare_integer_pack (void)
28296 tree ipfn
= push_library_fn (get_identifier ("__integer_pack"),
28297 build_function_type_list (integer_type_node
,
28300 NULL_TREE
, ECF_CONST
);
28301 DECL_DECLARED_CONSTEXPR_P (ipfn
) = true;
28302 DECL_BUILT_IN_CLASS (ipfn
) = BUILT_IN_FRONTEND
;
28303 DECL_FUNCTION_CODE (ipfn
)
28304 = (enum built_in_function
) (int) CP_BUILT_IN_INTEGER_PACK
;
28307 /* Set up the hash tables for template instantiations. */
28310 init_template_processing (void)
28312 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
28313 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
28315 if (cxx_dialect
>= cxx11
)
28316 declare_integer_pack ();
28319 /* Print stats about the template hash tables for -fstats. */
28322 print_template_statistics (void)
28324 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
28325 "%f collisions\n", (long) decl_specializations
->size (),
28326 (long) decl_specializations
->elements (),
28327 decl_specializations
->collisions ());
28328 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
28329 "%f collisions\n", (long) type_specializations
->size (),
28330 (long) type_specializations
->elements (),
28331 type_specializations
->collisions ());
28336 namespace selftest
{
28338 /* Verify that build_non_dependent_expr () works, for various expressions,
28339 and that location wrappers don't affect the results. */
28342 test_build_non_dependent_expr ()
28344 location_t loc
= BUILTINS_LOCATION
;
28346 /* Verify constants, without and with location wrappers. */
28347 tree int_cst
= build_int_cst (integer_type_node
, 42);
28348 ASSERT_EQ (int_cst
, build_non_dependent_expr (int_cst
));
28350 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
28351 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
28352 ASSERT_EQ (wrapped_int_cst
, build_non_dependent_expr (wrapped_int_cst
));
28354 tree string_lit
= build_string (4, "foo");
28355 TREE_TYPE (string_lit
) = char_array_type_node
;
28356 string_lit
= fix_string_type (string_lit
);
28357 ASSERT_EQ (string_lit
, build_non_dependent_expr (string_lit
));
28359 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
28360 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
28361 ASSERT_EQ (wrapped_string_lit
,
28362 build_non_dependent_expr (wrapped_string_lit
));
28365 /* Verify that type_dependent_expression_p () works correctly, even
28366 in the presence of location wrapper nodes. */
28369 test_type_dependent_expression_p ()
28371 location_t loc
= BUILTINS_LOCATION
;
28373 tree name
= get_identifier ("foo");
28375 /* If no templates are involved, nothing is type-dependent. */
28376 gcc_assert (!processing_template_decl
);
28377 ASSERT_FALSE (type_dependent_expression_p (name
));
28379 ++processing_template_decl
;
28381 /* Within a template, an unresolved name is always type-dependent. */
28382 ASSERT_TRUE (type_dependent_expression_p (name
));
28384 /* Ensure it copes with NULL_TREE and errors. */
28385 ASSERT_FALSE (type_dependent_expression_p (NULL_TREE
));
28386 ASSERT_FALSE (type_dependent_expression_p (error_mark_node
));
28388 /* A USING_DECL in a template should be type-dependent, even if wrapped
28389 with a location wrapper (PR c++/83799). */
28390 tree using_decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
28391 TREE_TYPE (using_decl
) = integer_type_node
;
28392 ASSERT_TRUE (type_dependent_expression_p (using_decl
));
28393 tree wrapped_using_decl
= maybe_wrap_with_location (using_decl
, loc
);
28394 ASSERT_TRUE (location_wrapper_p (wrapped_using_decl
));
28395 ASSERT_TRUE (type_dependent_expression_p (wrapped_using_decl
));
28397 --processing_template_decl
;
28400 /* Run all of the selftests within this file. */
28405 test_build_non_dependent_expr ();
28406 test_type_dependent_expression_p ();
28409 } // namespace selftest
28411 #endif /* #if CHECKING_P */
28413 #include "gt-cp-pt.h"