1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2019 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Known bugs or deficiencies include:
24 all methods must be provided in header files; can't use a source
25 file that contains only the method templates and "just win". */
29 #include "coretypes.h"
32 #include "stringpool.h"
35 #include "stor-layout.h"
37 #include "c-family/c-objc.h"
38 #include "cp-objcp-common.h"
40 #include "tree-iterator.h"
41 #include "type-utils.h"
43 #include "gcc-rich-location.h"
46 /* The type of functions taking a tree, and some additional data, and
48 typedef int (*tree_fn_t
) (tree
, void*);
50 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
51 instantiations have been deferred, either because their definitions
52 were not yet available, or because we were putting off doing the work. */
53 struct GTY ((chain_next ("%h.next"))) pending_template
55 struct pending_template
*next
;
56 struct tinst_level
*tinst
;
59 static GTY(()) struct pending_template
*pending_templates
;
60 static GTY(()) struct pending_template
*last_pending_template
;
62 int processing_template_parmlist
;
63 static int template_header_count
;
65 static GTY(()) tree saved_trees
;
66 static vec
<int> inline_parm_levels
;
68 static GTY(()) struct tinst_level
*current_tinst_level
;
70 static GTY(()) tree saved_access_scope
;
72 /* Live only within one (recursive) call to tsubst_expr. We use
73 this to pass the statement expression node from the STMT_EXPR
74 to the EXPR_STMT that is its result. */
75 static tree cur_stmt_expr
;
77 // -------------------------------------------------------------------------- //
78 // Local Specialization Stack
80 // Implementation of the RAII helper for creating new local
82 local_specialization_stack::local_specialization_stack (lss_policy policy
)
83 : saved (local_specializations
)
85 if (policy
== lss_blank
|| !saved
)
86 local_specializations
= new hash_map
<tree
, tree
>;
88 local_specializations
= new hash_map
<tree
, tree
>(*saved
);
91 local_specialization_stack::~local_specialization_stack ()
93 delete local_specializations
;
94 local_specializations
= saved
;
97 /* True if we've recursed into fn_type_unification too many times. */
98 static bool excessive_deduction_depth
;
100 struct GTY((for_user
)) spec_entry
107 struct spec_hasher
: ggc_ptr_hash
<spec_entry
>
109 static hashval_t
hash (spec_entry
*);
110 static bool equal (spec_entry
*, spec_entry
*);
113 static GTY (()) hash_table
<spec_hasher
> *decl_specializations
;
115 static GTY (()) hash_table
<spec_hasher
> *type_specializations
;
117 /* Contains canonical template parameter types. The vector is indexed by
118 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
119 TREE_LIST, whose TREE_VALUEs contain the canonical template
120 parameters of various types and levels. */
121 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
123 #define UNIFY_ALLOW_NONE 0
124 #define UNIFY_ALLOW_MORE_CV_QUAL 1
125 #define UNIFY_ALLOW_LESS_CV_QUAL 2
126 #define UNIFY_ALLOW_DERIVED 4
127 #define UNIFY_ALLOW_INTEGER 8
128 #define UNIFY_ALLOW_OUTER_LEVEL 16
129 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
130 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
132 enum template_base_result
{
134 tbr_ambiguous_baseclass
,
138 static void push_access_scope (tree
);
139 static void pop_access_scope (tree
);
140 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
141 unification_kind_t
, int,
143 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
144 unification_kind_t
, int, bool, bool);
145 static int unify (tree
, tree
, tree
, tree
, int, bool);
146 static void add_pending_template (tree
);
147 static tree
reopen_tinst_level (struct tinst_level
*);
148 static tree
tsubst_initializer_list (tree
, tree
);
149 static tree
get_partial_spec_bindings (tree
, tree
, tree
);
150 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
152 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
154 static void tsubst_enum (tree
, tree
, tree
);
155 static tree
add_to_template_args (tree
, tree
);
156 static tree
add_outermost_template_args (tree
, tree
);
157 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
158 static int check_non_deducible_conversion (tree
, tree
, int, int,
159 struct conversion
**, bool);
160 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
162 static int type_unification_real (tree
, tree
, tree
, const tree
*,
163 unsigned int, int, unification_kind_t
,
164 vec
<deferred_access_check
, va_gc
> **,
166 static void note_template_header (int);
167 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
168 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
169 static tree
convert_template_argument (tree
, tree
, tree
,
170 tsubst_flags_t
, int, tree
);
171 static tree
for_each_template_parm (tree
, tree_fn_t
, void*,
172 hash_set
<tree
> *, bool, tree_fn_t
= NULL
);
173 static tree
expand_template_argument_pack (tree
);
174 static tree
build_template_parm_index (int, int, int, tree
, tree
);
175 static bool inline_needs_template_parms (tree
, bool);
176 static void push_inline_template_parms_recursive (tree
, int);
177 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
178 static int mark_template_parm (tree
, void *);
179 static int template_parm_this_level_p (tree
, void *);
180 static tree
tsubst_friend_function (tree
, tree
);
181 static tree
tsubst_friend_class (tree
, tree
);
182 static int can_complete_type_without_circularity (tree
);
183 static tree
get_bindings (tree
, tree
, tree
, bool);
184 static int template_decl_level (tree
);
185 static int check_cv_quals_for_unify (int, tree
, tree
);
186 static void template_parm_level_and_index (tree
, int*, int*);
187 static int unify_pack_expansion (tree
, tree
, tree
,
188 tree
, unification_kind_t
, bool, bool);
189 static tree
copy_template_args (tree
);
190 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
191 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
192 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
193 static tree
most_specialized_partial_spec (tree
, tsubst_flags_t
);
194 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
195 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
196 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
197 static bool check_specialization_scope (void);
198 static tree
process_partial_specialization (tree
);
199 static void set_current_access_from_decl (tree
);
200 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
202 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
203 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
205 static bool template_template_parm_bindings_ok_p (tree
, tree
);
206 static void tsubst_default_arguments (tree
, tsubst_flags_t
);
207 static tree
for_each_template_parm_r (tree
*, int *, void *);
208 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
209 static void copy_default_args_to_explicit_spec (tree
);
210 static bool invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
211 static bool dependent_template_arg_p (tree
);
212 static bool any_template_arguments_need_structural_equality_p (tree
);
213 static bool dependent_type_p_r (tree
);
214 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
215 static tree
tsubst_decl (tree
, tree
, tsubst_flags_t
);
216 static void perform_typedefs_access_check (tree tmpl
, tree targs
);
217 static void append_type_to_template_for_access_check_1 (tree
, tree
, tree
,
219 static tree
listify (tree
);
220 static tree
listify_autos (tree
, tree
);
221 static tree
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
222 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
223 static bool complex_alias_template_p (const_tree tmpl
);
224 static tree
tsubst_attributes (tree
, tree
, tsubst_flags_t
, tree
);
225 static tree
canonicalize_expr_argument (tree
, tsubst_flags_t
);
226 static tree
make_argument_pack (tree
);
227 static void register_parameter_specializations (tree
, tree
);
228 static tree
enclosing_instantiation_of (tree tctx
);
230 /* Make the current scope suitable for access checking when we are
231 processing T. T can be FUNCTION_DECL for instantiated function
232 template, VAR_DECL for static member variable, or TYPE_DECL for
233 alias template (needed by instantiate_decl). */
236 push_access_scope (tree t
)
238 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
239 || TREE_CODE (t
) == TYPE_DECL
);
241 if (DECL_FRIEND_CONTEXT (t
))
242 push_nested_class (DECL_FRIEND_CONTEXT (t
));
243 else if (DECL_CLASS_SCOPE_P (t
))
244 push_nested_class (DECL_CONTEXT (t
));
246 push_to_top_level ();
248 if (TREE_CODE (t
) == FUNCTION_DECL
)
250 saved_access_scope
= tree_cons
251 (NULL_TREE
, current_function_decl
, saved_access_scope
);
252 current_function_decl
= t
;
256 /* Restore the scope set up by push_access_scope. T is the node we
260 pop_access_scope (tree t
)
262 if (TREE_CODE (t
) == FUNCTION_DECL
)
264 current_function_decl
= TREE_VALUE (saved_access_scope
);
265 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
268 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
271 pop_from_top_level ();
274 /* Do any processing required when DECL (a member template
275 declaration) is finished. Returns the TEMPLATE_DECL corresponding
276 to DECL, unless it is a specialization, in which case the DECL
277 itself is returned. */
280 finish_member_template_decl (tree decl
)
282 if (decl
== error_mark_node
)
283 return error_mark_node
;
285 gcc_assert (DECL_P (decl
));
287 if (TREE_CODE (decl
) == TYPE_DECL
)
291 type
= TREE_TYPE (decl
);
292 if (type
== error_mark_node
)
293 return error_mark_node
;
294 if (MAYBE_CLASS_TYPE_P (type
)
295 && CLASSTYPE_TEMPLATE_INFO (type
)
296 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
298 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
299 check_member_template (tmpl
);
304 else if (TREE_CODE (decl
) == FIELD_DECL
)
305 error ("data member %qD cannot be a member template", decl
);
306 else if (DECL_TEMPLATE_INFO (decl
))
308 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
310 check_member_template (DECL_TI_TEMPLATE (decl
));
311 return DECL_TI_TEMPLATE (decl
);
317 error ("invalid member template declaration %qD", decl
);
319 return error_mark_node
;
322 /* Create a template info node. */
325 build_template_info (tree template_decl
, tree template_args
)
327 tree result
= make_node (TEMPLATE_INFO
);
328 TI_TEMPLATE (result
) = template_decl
;
329 TI_ARGS (result
) = template_args
;
333 /* Return the template info node corresponding to T, whatever T is. */
336 get_template_info (const_tree t
)
338 tree tinfo
= NULL_TREE
;
340 if (!t
|| t
== error_mark_node
)
343 if (TREE_CODE (t
) == NAMESPACE_DECL
344 || TREE_CODE (t
) == PARM_DECL
)
347 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
348 tinfo
= DECL_TEMPLATE_INFO (t
);
350 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
353 if (OVERLOAD_TYPE_P (t
))
354 tinfo
= TYPE_TEMPLATE_INFO (t
);
355 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
356 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
361 /* Returns the template nesting level of the indicated class TYPE.
371 A<T>::B<U> has depth two, while A<T> has depth one.
372 Both A<T>::B<int> and A<int>::B<U> have depth one, if
373 they are instantiations, not specializations.
375 This function is guaranteed to return 0 if passed NULL_TREE so
376 that, for example, `template_class_depth (current_class_type)' is
380 template_class_depth (tree type
)
384 for (depth
= 0; type
&& TREE_CODE (type
) != NAMESPACE_DECL
; )
386 tree tinfo
= get_template_info (type
);
388 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
389 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
393 type
= CP_DECL_CONTEXT (type
);
394 else if (LAMBDA_TYPE_P (type
))
395 type
= LAMBDA_TYPE_EXTRA_SCOPE (type
);
397 type
= CP_TYPE_CONTEXT (type
);
403 /* Return TRUE if NODE instantiates a template that has arguments of
404 its own, be it directly a primary template or indirectly through a
405 partial specializations. */
407 instantiates_primary_template_p (tree node
)
409 tree tinfo
= get_template_info (node
);
413 tree tmpl
= TI_TEMPLATE (tinfo
);
414 if (PRIMARY_TEMPLATE_P (tmpl
))
417 if (!DECL_TEMPLATE_SPECIALIZATION (tmpl
))
420 /* So now we know we have a specialization, but it could be a full
421 or a partial specialization. To tell which, compare the depth of
422 its template arguments with those of its context. */
424 tree ctxt
= DECL_CONTEXT (tmpl
);
425 tree ctinfo
= get_template_info (ctxt
);
429 return (TMPL_ARGS_DEPTH (TI_ARGS (tinfo
))
430 > TMPL_ARGS_DEPTH (TI_ARGS (ctinfo
)));
433 /* Subroutine of maybe_begin_member_template_processing.
434 Returns true if processing DECL needs us to push template parms. */
437 inline_needs_template_parms (tree decl
, bool nsdmi
)
439 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
442 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
443 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
446 /* Subroutine of maybe_begin_member_template_processing.
447 Push the template parms in PARMS, starting from LEVELS steps into the
448 chain, and ending at the beginning, since template parms are listed
452 push_inline_template_parms_recursive (tree parmlist
, int levels
)
454 tree parms
= TREE_VALUE (parmlist
);
458 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
460 ++processing_template_decl
;
461 current_template_parms
462 = tree_cons (size_int (processing_template_decl
),
463 parms
, current_template_parms
);
464 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
466 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
468 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
470 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
472 if (error_operand_p (parm
))
475 gcc_assert (DECL_P (parm
));
477 switch (TREE_CODE (parm
))
485 /* Push the CONST_DECL. */
486 pushdecl (TEMPLATE_PARM_DECL (DECL_INITIAL (parm
)));
495 /* Restore the template parameter context for a member template, a
496 friend template defined in a class definition, or a non-template
497 member of template class. */
500 maybe_begin_member_template_processing (tree decl
)
504 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
508 tree ctx
= DECL_CONTEXT (decl
);
509 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
510 /* Disregard full specializations (c++/60999). */
511 && uses_template_parms (ctx
)
512 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
515 if (inline_needs_template_parms (decl
, nsdmi
))
517 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
518 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
520 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
523 parms
= TREE_CHAIN (parms
);
526 push_inline_template_parms_recursive (parms
, levels
);
529 /* Remember how many levels of template parameters we pushed so that
530 we can pop them later. */
531 inline_parm_levels
.safe_push (levels
);
534 /* Undo the effects of maybe_begin_member_template_processing. */
537 maybe_end_member_template_processing (void)
542 if (inline_parm_levels
.length () == 0)
545 last
= inline_parm_levels
.pop ();
546 for (i
= 0; i
< last
; ++i
)
548 --processing_template_decl
;
549 current_template_parms
= TREE_CHAIN (current_template_parms
);
554 /* Return a new template argument vector which contains all of ARGS,
555 but has as its innermost set of arguments the EXTRA_ARGS. */
558 add_to_template_args (tree args
, tree extra_args
)
565 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
568 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
569 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
571 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
572 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
574 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
575 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
580 /* Like add_to_template_args, but only the outermost ARGS are added to
581 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
582 (EXTRA_ARGS) levels are added. This function is used to combine
583 the template arguments from a partial instantiation with the
584 template arguments used to attain the full instantiation from the
585 partial instantiation. */
588 add_outermost_template_args (tree args
, tree extra_args
)
592 /* If there are more levels of EXTRA_ARGS than there are ARGS,
593 something very fishy is going on. */
594 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
596 /* If *all* the new arguments will be the EXTRA_ARGS, just return
598 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
601 /* For the moment, we make ARGS look like it contains fewer levels. */
602 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
604 new_args
= add_to_template_args (args
, extra_args
);
606 /* Now, we restore ARGS to its full dimensions. */
607 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
612 /* Return the N levels of innermost template arguments from the ARGS. */
615 get_innermost_template_args (tree args
, int n
)
623 /* If N is 1, just return the innermost set of template arguments. */
625 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
627 /* If we're not removing anything, just return the arguments we were
629 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
630 gcc_assert (extra_levels
>= 0);
631 if (extra_levels
== 0)
634 /* Make a new set of arguments, not containing the outer arguments. */
635 new_args
= make_tree_vec (n
);
636 for (i
= 1; i
<= n
; ++i
)
637 SET_TMPL_ARGS_LEVEL (new_args
, i
,
638 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
643 /* The inverse of get_innermost_template_args: Return all but the innermost
644 EXTRA_LEVELS levels of template arguments from the ARGS. */
647 strip_innermost_template_args (tree args
, int extra_levels
)
650 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
655 /* If N is 1, just return the outermost set of template arguments. */
657 return TMPL_ARGS_LEVEL (args
, 1);
659 /* If we're not removing anything, just return the arguments we were
661 gcc_assert (extra_levels
>= 0);
662 if (extra_levels
== 0)
665 /* Make a new set of arguments, not containing the inner arguments. */
666 new_args
= make_tree_vec (n
);
667 for (i
= 1; i
<= n
; ++i
)
668 SET_TMPL_ARGS_LEVEL (new_args
, i
,
669 TMPL_ARGS_LEVEL (args
, i
));
674 /* We've got a template header coming up; push to a new level for storing
678 begin_template_parm_list (void)
680 /* We use a non-tag-transparent scope here, which causes pushtag to
681 put tags in this scope, rather than in the enclosing class or
682 namespace scope. This is the right thing, since we want
683 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
684 global template class, push_template_decl handles putting the
685 TEMPLATE_DECL into top-level scope. For a nested template class,
688 template <class T> struct S1 {
689 template <class T> struct S2 {};
692 pushtag contains special code to insert the TEMPLATE_DECL for S2
693 at the right scope. */
694 begin_scope (sk_template_parms
, NULL
);
695 ++processing_template_decl
;
696 ++processing_template_parmlist
;
697 note_template_header (0);
699 /* Add a dummy parameter level while we process the parameter list. */
700 current_template_parms
701 = tree_cons (size_int (processing_template_decl
),
703 current_template_parms
);
706 /* This routine is called when a specialization is declared. If it is
707 invalid to declare a specialization here, an error is reported and
708 false is returned, otherwise this routine will return true. */
711 check_specialization_scope (void)
713 tree scope
= current_scope ();
717 An explicit specialization shall be declared in the namespace of
718 which the template is a member, or, for member templates, in the
719 namespace of which the enclosing class or enclosing class
720 template is a member. An explicit specialization of a member
721 function, member class or static data member of a class template
722 shall be declared in the namespace of which the class template
724 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
726 error ("explicit specialization in non-namespace scope %qD", scope
);
732 In an explicit specialization declaration for a member of a class
733 template or a member template that appears in namespace scope,
734 the member template and some of its enclosing class templates may
735 remain unspecialized, except that the declaration shall not
736 explicitly specialize a class member template if its enclosing
737 class templates are not explicitly specialized as well. */
738 if (current_template_parms
)
740 error ("enclosing class templates are not explicitly specialized");
747 /* We've just seen template <>. */
750 begin_specialization (void)
752 begin_scope (sk_template_spec
, NULL
);
753 note_template_header (1);
754 return check_specialization_scope ();
757 /* Called at then end of processing a declaration preceded by
761 end_specialization (void)
764 reset_specialization ();
767 /* Any template <>'s that we have seen thus far are not referring to a
768 function specialization. */
771 reset_specialization (void)
773 processing_specialization
= 0;
774 template_header_count
= 0;
777 /* We've just seen a template header. If SPECIALIZATION is nonzero,
778 it was of the form template <>. */
781 note_template_header (int specialization
)
783 processing_specialization
= specialization
;
784 template_header_count
++;
787 /* We're beginning an explicit instantiation. */
790 begin_explicit_instantiation (void)
792 gcc_assert (!processing_explicit_instantiation
);
793 processing_explicit_instantiation
= true;
798 end_explicit_instantiation (void)
800 gcc_assert (processing_explicit_instantiation
);
801 processing_explicit_instantiation
= false;
804 /* An explicit specialization or partial specialization of TMPL is being
805 declared. Check that the namespace in which the specialization is
806 occurring is permissible. Returns false iff it is invalid to
807 specialize TMPL in the current namespace. */
810 check_specialization_namespace (tree tmpl
)
812 tree tpl_ns
= decl_namespace_context (tmpl
);
816 An explicit specialization shall be declared in a namespace enclosing the
817 specialized template. An explicit specialization whose declarator-id is
818 not qualified shall be declared in the nearest enclosing namespace of the
819 template, or, if the namespace is inline (7.3.1), any namespace from its
820 enclosing namespace set. */
821 if (current_scope() != DECL_CONTEXT (tmpl
)
822 && !at_namespace_scope_p ())
824 error ("specialization of %qD must appear at namespace scope", tmpl
);
828 if (is_nested_namespace (current_namespace
, tpl_ns
, cxx_dialect
< cxx11
))
829 /* Same or enclosing namespace. */
833 auto_diagnostic_group d
;
834 if (permerror (input_location
,
835 "specialization of %qD in different namespace", tmpl
))
836 inform (DECL_SOURCE_LOCATION (tmpl
),
837 " from definition of %q#D", tmpl
);
842 /* SPEC is an explicit instantiation. Check that it is valid to
843 perform this explicit instantiation in the current namespace. */
846 check_explicit_instantiation_namespace (tree spec
)
850 /* DR 275: An explicit instantiation shall appear in an enclosing
851 namespace of its template. */
852 ns
= decl_namespace_context (spec
);
853 if (!is_nested_namespace (current_namespace
, ns
))
854 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
855 "(which does not enclose namespace %qD)",
856 spec
, current_namespace
, ns
);
859 // Returns the type of a template specialization only if that
860 // specialization needs to be defined. Otherwise (e.g., if the type has
861 // already been defined), the function returns NULL_TREE.
863 maybe_new_partial_specialization (tree type
)
865 // An implicit instantiation of an incomplete type implies
866 // the definition of a new class template.
868 // template<typename T>
871 // template<typename T>
874 // Here, S<T*> is an implicit instantiation of S whose type
876 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
) && !COMPLETE_TYPE_P (type
))
879 // It can also be the case that TYPE is a completed specialization.
880 // Continuing the previous example, suppose we also declare:
882 // template<typename T>
883 // requires Integral<T>
886 // Here, S<T*> refers to the specialization S<T*> defined
887 // above. However, we need to differentiate definitions because
888 // we intend to define a new partial specialization. In this case,
889 // we rely on the fact that the constraints are different for
890 // this declaration than that above.
892 // Note that we also get here for injected class names and
893 // late-parsed template definitions. We must ensure that we
894 // do not create new type declarations for those cases.
895 if (flag_concepts
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
897 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
898 tree args
= CLASSTYPE_TI_ARGS (type
);
900 // If there are no template parameters, this cannot be a new
901 // partial template specializtion?
902 if (!current_template_parms
)
905 // The injected-class-name is not a new partial specialization.
906 if (DECL_SELF_REFERENCE_P (TYPE_NAME (type
)))
909 // If the constraints are not the same as those of the primary
910 // then, we can probably create a new specialization.
911 tree type_constr
= current_template_constraints ();
913 if (type
== TREE_TYPE (tmpl
))
915 tree main_constr
= get_constraints (tmpl
);
916 if (equivalent_constraints (type_constr
, main_constr
))
920 // Also, if there's a pre-existing specialization with matching
921 // constraints, then this also isn't new.
922 tree specs
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
925 tree spec_tmpl
= TREE_VALUE (specs
);
926 tree spec_args
= TREE_PURPOSE (specs
);
927 tree spec_constr
= get_constraints (spec_tmpl
);
928 if (comp_template_args (args
, spec_args
)
929 && equivalent_constraints (type_constr
, spec_constr
))
931 specs
= TREE_CHAIN (specs
);
934 // Create a new type node (and corresponding type decl)
935 // for the newly declared specialization.
936 tree t
= make_class_type (TREE_CODE (type
));
937 CLASSTYPE_DECLARED_CLASS (t
) = CLASSTYPE_DECLARED_CLASS (type
);
938 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (tmpl
, args
));
940 /* We only need a separate type node for storing the definition of this
941 partial specialization; uses of S<T*> are unconstrained, so all are
942 equivalent. So keep TYPE_CANONICAL the same. */
943 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
945 // Build the corresponding type decl.
946 tree d
= create_implicit_typedef (DECL_NAME (tmpl
), t
);
947 DECL_CONTEXT (d
) = TYPE_CONTEXT (t
);
948 DECL_SOURCE_LOCATION (d
) = input_location
;
956 /* The TYPE is being declared. If it is a template type, that means it
957 is a partial specialization. Do appropriate error-checking. */
960 maybe_process_partial_specialization (tree type
)
964 if (type
== error_mark_node
)
965 return error_mark_node
;
967 /* A lambda that appears in specialization context is not itself a
969 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
972 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
974 error ("name of class shadows template template parameter %qD",
976 return error_mark_node
;
979 context
= TYPE_CONTEXT (type
);
981 if (TYPE_ALIAS_P (type
))
983 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (type
);
985 if (tinfo
&& DECL_ALIAS_TEMPLATE_P (TI_TEMPLATE (tinfo
)))
986 error ("specialization of alias template %qD",
987 TI_TEMPLATE (tinfo
));
989 error ("explicit specialization of non-template %qT", type
);
990 return error_mark_node
;
992 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
994 /* This is for ordinary explicit specialization and partial
995 specialization of a template class such as:
997 template <> class C<int>;
1001 template <class T> class C<T*>;
1003 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
1005 if (tree t
= maybe_new_partial_specialization (type
))
1007 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (t
))
1008 && !at_namespace_scope_p ())
1009 return error_mark_node
;
1010 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t
);
1011 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (t
)) = input_location
;
1012 if (processing_template_decl
)
1014 tree decl
= push_template_decl (TYPE_MAIN_DECL (t
));
1015 if (decl
== error_mark_node
)
1016 return error_mark_node
;
1017 return TREE_TYPE (decl
);
1020 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
1021 error ("specialization of %qT after instantiation", type
);
1022 else if (errorcount
&& !processing_specialization
1023 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
1024 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
1025 /* Trying to define a specialization either without a template<> header
1026 or in an inappropriate place. We've already given an error, so just
1027 bail now so we don't actually define the specialization. */
1028 return error_mark_node
;
1030 else if (CLASS_TYPE_P (type
)
1031 && !CLASSTYPE_USE_TEMPLATE (type
)
1032 && CLASSTYPE_TEMPLATE_INFO (type
)
1033 && context
&& CLASS_TYPE_P (context
)
1034 && CLASSTYPE_TEMPLATE_INFO (context
))
1036 /* This is for an explicit specialization of member class
1037 template according to [temp.expl.spec/18]:
1039 template <> template <class U> class C<int>::D;
1041 The context `C<int>' must be an implicit instantiation.
1042 Otherwise this is just a member class template declared
1045 template <> class C<int> { template <class U> class D; };
1046 template <> template <class U> class C<int>::D;
1048 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1049 while in the second case, `C<int>::D' is a primary template
1050 and `C<T>::D' may not exist. */
1052 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
1053 && !COMPLETE_TYPE_P (type
))
1056 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1058 if (current_namespace
1059 != decl_namespace_context (tmpl
))
1061 if (permerror (input_location
,
1062 "specialization of %qD in different namespace",
1064 inform (DECL_SOURCE_LOCATION (tmpl
),
1065 "from definition of %q#D", tmpl
);
1068 /* Check for invalid specialization after instantiation:
1070 template <> template <> class C<int>::D<int>;
1071 template <> template <class U> class C<int>::D; */
1073 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
1074 t
; t
= TREE_CHAIN (t
))
1076 tree inst
= TREE_VALUE (t
);
1077 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
1078 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
1080 /* We already have a full specialization of this partial
1081 instantiation, or a full specialization has been
1082 looked up but not instantiated. Reassign it to the
1083 new member specialization template. */
1087 elt
.tmpl
= most_general_template (tmpl
);
1088 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
1091 type_specializations
->remove_elt (&elt
);
1094 CLASSTYPE_TI_ARGS (inst
)
1095 = elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
1098 = type_specializations
->find_slot (&elt
, INSERT
);
1099 entry
= ggc_alloc
<spec_entry
> ();
1104 /* But if we've had an implicit instantiation, that's a
1105 problem ([temp.expl.spec]/6). */
1106 error ("specialization %qT after instantiation %qT",
1110 /* Mark TYPE as a specialization. And as a result, we only
1111 have one level of template argument for the innermost
1113 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
1114 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
1115 CLASSTYPE_TI_ARGS (type
)
1116 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
1119 else if (processing_specialization
)
1121 /* Someday C++0x may allow for enum template specialization. */
1122 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
1123 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
1124 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
1125 "of %qD not allowed by ISO C++", type
);
1128 error ("explicit specialization of non-template %qT", type
);
1129 return error_mark_node
;
1136 /* Returns nonzero if we can optimize the retrieval of specializations
1137 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1138 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1141 optimize_specialization_lookup_p (tree tmpl
)
1143 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
1144 && DECL_CLASS_SCOPE_P (tmpl
)
1145 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1147 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
1148 /* The optimized lookup depends on the fact that the
1149 template arguments for the member function template apply
1150 purely to the containing class, which is not true if the
1151 containing class is an explicit or partial
1153 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1154 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1155 && !DECL_CONV_FN_P (tmpl
)
1156 /* It is possible to have a template that is not a member
1157 template and is not a member of a template class:
1159 template <typename T>
1160 struct S { friend A::f(); };
1162 Here, the friend function is a template, but the context does
1163 not have template information. The optimized lookup relies
1164 on having ARGS be the template arguments for both the class
1165 and the function template. */
1166 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1169 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1170 gone through coerce_template_parms by now. */
1173 verify_unstripped_args_1 (tree inner
)
1175 for (int i
= 0; i
< TREE_VEC_LENGTH (inner
); ++i
)
1177 tree arg
= TREE_VEC_ELT (inner
, i
);
1178 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1180 else if (TYPE_P (arg
))
1181 gcc_assert (strip_typedefs (arg
, NULL
) == arg
);
1182 else if (ARGUMENT_PACK_P (arg
))
1183 verify_unstripped_args_1 (ARGUMENT_PACK_ARGS (arg
));
1184 else if (strip_typedefs (TREE_TYPE (arg
), NULL
) != TREE_TYPE (arg
))
1185 /* Allow typedefs on the type of a non-type argument, since a
1186 parameter can have them. */;
1188 gcc_assert (strip_typedefs_expr (arg
, NULL
) == arg
);
1193 verify_unstripped_args (tree args
)
1195 ++processing_template_decl
;
1196 if (!any_dependent_template_arguments_p (args
))
1197 verify_unstripped_args_1 (INNERMOST_TEMPLATE_ARGS (args
));
1198 --processing_template_decl
;
1201 /* Retrieve the specialization (in the sense of [temp.spec] - a
1202 specialization is either an instantiation or an explicit
1203 specialization) of TMPL for the given template ARGS. If there is
1204 no such specialization, return NULL_TREE. The ARGS are a vector of
1205 arguments, or a vector of vectors of arguments, in the case of
1206 templates with more than one level of parameters.
1208 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1209 then we search for a partial specialization matching ARGS. This
1210 parameter is ignored if TMPL is not a class template.
1212 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1213 result is a NONTYPE_ARGUMENT_PACK. */
1216 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1218 if (tmpl
== NULL_TREE
)
1221 if (args
== error_mark_node
)
1224 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1225 || TREE_CODE (tmpl
) == FIELD_DECL
);
1227 /* There should be as many levels of arguments as there are
1228 levels of parameters. */
1229 gcc_assert (TMPL_ARGS_DEPTH (args
)
1230 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1231 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1232 : template_class_depth (DECL_CONTEXT (tmpl
))));
1235 verify_unstripped_args (args
);
1237 /* Lambda functions in templates aren't instantiated normally, but through
1238 tsubst_lambda_expr. */
1239 if (lambda_fn_in_template_p (tmpl
))
1242 if (optimize_specialization_lookup_p (tmpl
))
1244 /* The template arguments actually apply to the containing
1245 class. Find the class specialization with those
1247 tree class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1248 tree class_specialization
1249 = retrieve_specialization (class_template
, args
, 0);
1250 if (!class_specialization
)
1253 /* Find the instance of TMPL. */
1254 tree fns
= get_class_binding (class_specialization
, DECL_NAME (tmpl
));
1255 for (ovl_iterator
iter (fns
); iter
; ++iter
)
1258 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1259 /* using-declarations can add base methods to the method vec,
1260 and we don't want those here. */
1261 && DECL_CONTEXT (fn
) == class_specialization
)
1270 hash_table
<spec_hasher
> *specializations
;
1274 elt
.spec
= NULL_TREE
;
1276 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1277 specializations
= type_specializations
;
1279 specializations
= decl_specializations
;
1282 hash
= spec_hasher::hash (&elt
);
1283 found
= specializations
->find_with_hash (&elt
, hash
);
1291 /* Like retrieve_specialization, but for local declarations. */
1294 retrieve_local_specialization (tree tmpl
)
1296 if (local_specializations
== NULL
)
1299 tree
*slot
= local_specializations
->get (tmpl
);
1300 return slot
? *slot
: NULL_TREE
;
1303 /* Returns nonzero iff DECL is a specialization of TMPL. */
1306 is_specialization_of (tree decl
, tree tmpl
)
1310 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1314 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1320 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1322 for (t
= TREE_TYPE (decl
);
1324 t
= CLASSTYPE_USE_TEMPLATE (t
)
1325 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1326 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1333 /* Returns nonzero iff DECL is a specialization of friend declaration
1334 FRIEND_DECL according to [temp.friend]. */
1337 is_specialization_of_friend (tree decl
, tree friend_decl
)
1339 bool need_template
= true;
1342 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1343 || TREE_CODE (decl
) == TYPE_DECL
);
1345 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1346 of a template class, we want to check if DECL is a specialization
1348 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1349 && DECL_TEMPLATE_INFO (friend_decl
)
1350 && !DECL_USE_TEMPLATE (friend_decl
))
1352 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1353 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1354 need_template
= false;
1356 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1357 && !PRIMARY_TEMPLATE_P (friend_decl
))
1358 need_template
= false;
1360 /* There is nothing to do if this is not a template friend. */
1361 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1364 if (is_specialization_of (decl
, friend_decl
))
1368 A member of a class template may be declared to be a friend of a
1369 non-template class. In this case, the corresponding member of
1370 every specialization of the class template is a friend of the
1371 class granting friendship.
1373 For example, given a template friend declaration
1375 template <class T> friend void A<T>::f();
1377 the member function below is considered a friend
1379 template <> struct A<int> {
1383 For this type of template friend, TEMPLATE_DEPTH below will be
1384 nonzero. To determine if DECL is a friend of FRIEND, we first
1385 check if the enclosing class is a specialization of another. */
1387 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1389 && DECL_CLASS_SCOPE_P (decl
)
1390 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1391 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1393 /* Next, we check the members themselves. In order to handle
1394 a few tricky cases, such as when FRIEND_DECL's are
1396 template <class T> friend void A<T>::g(T t);
1397 template <class T> template <T t> friend void A<T>::h();
1401 void A<int>::g(int);
1402 template <int> void A<int>::h();
1404 we need to figure out ARGS, the template arguments from
1405 the context of DECL. This is required for template substitution
1406 of `T' in the function parameter of `g' and template parameter
1407 of `h' in the above examples. Here ARGS corresponds to `int'. */
1409 tree context
= DECL_CONTEXT (decl
);
1410 tree args
= NULL_TREE
;
1411 int current_depth
= 0;
1413 while (current_depth
< template_depth
)
1415 if (CLASSTYPE_TEMPLATE_INFO (context
))
1417 if (current_depth
== 0)
1418 args
= TYPE_TI_ARGS (context
);
1420 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1423 context
= TYPE_CONTEXT (context
);
1426 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1431 tree friend_args_type
;
1432 tree decl_args_type
;
1434 /* Make sure that both DECL and FRIEND_DECL are templates or
1436 is_template
= DECL_TEMPLATE_INFO (decl
)
1437 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1438 if (need_template
^ is_template
)
1440 else if (is_template
)
1442 /* If both are templates, check template parameter list. */
1444 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1446 if (!comp_template_parms
1447 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1451 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1454 decl_type
= TREE_TYPE (decl
);
1456 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1457 tf_none
, NULL_TREE
);
1458 if (friend_type
== error_mark_node
)
1461 /* Check if return types match. */
1462 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1465 /* Check if function parameter types match, ignoring the
1466 `this' parameter. */
1467 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1468 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1469 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1470 friend_args_type
= TREE_CHAIN (friend_args_type
);
1471 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1472 decl_args_type
= TREE_CHAIN (decl_args_type
);
1474 return compparms (decl_args_type
, friend_args_type
);
1478 /* DECL is a TYPE_DECL */
1480 tree decl_type
= TREE_TYPE (decl
);
1482 /* Make sure that both DECL and FRIEND_DECL are templates or
1485 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1486 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1488 if (need_template
^ is_template
)
1490 else if (is_template
)
1493 /* If both are templates, check the name of the two
1494 TEMPLATE_DECL's first because is_friend didn't. */
1495 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1496 != DECL_NAME (friend_decl
))
1499 /* Now check template parameter list. */
1501 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1503 return comp_template_parms
1504 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1508 return (DECL_NAME (decl
)
1509 == DECL_NAME (friend_decl
));
1515 /* Register the specialization SPEC as a specialization of TMPL with
1516 the indicated ARGS. IS_FRIEND indicates whether the specialization
1517 is actually just a friend declaration. ATTRLIST is the list of
1518 attributes that the specialization is declared with or NULL when
1519 it isn't. Returns SPEC, or an equivalent prior declaration, if
1522 We also store instantiations of field packs in the hash table, even
1523 though they are not themselves templates, to make lookup easier. */
1526 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1530 spec_entry
**slot
= NULL
;
1533 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1534 || (TREE_CODE (tmpl
) == FIELD_DECL
1535 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1537 if (TREE_CODE (spec
) == FUNCTION_DECL
1538 && uses_template_parms (DECL_TI_ARGS (spec
)))
1539 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1540 register it; we want the corresponding TEMPLATE_DECL instead.
1541 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1542 the more obvious `uses_template_parms (spec)' to avoid problems
1543 with default function arguments. In particular, given
1544 something like this:
1546 template <class T> void f(T t1, T t = T())
1548 the default argument expression is not substituted for in an
1549 instantiation unless and until it is actually needed. */
1552 if (optimize_specialization_lookup_p (tmpl
))
1553 /* We don't put these specializations in the hash table, but we might
1554 want to give an error about a mismatch. */
1555 fn
= retrieve_specialization (tmpl
, args
, 0);
1563 hash
= spec_hasher::hash (&elt
);
1566 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1568 fn
= ((spec_entry
*) *slot
)->spec
;
1573 /* We can sometimes try to re-register a specialization that we've
1574 already got. In particular, regenerate_decl_from_template calls
1575 duplicate_decls which will update the specialization list. But,
1576 we'll still get called again here anyhow. It's more convenient
1577 to simply allow this than to try to prevent it. */
1580 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1582 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1584 if (DECL_ODR_USED (fn
)
1585 || DECL_EXPLICIT_INSTANTIATION (fn
))
1587 error ("specialization of %qD after instantiation",
1589 return error_mark_node
;
1594 /* This situation should occur only if the first
1595 specialization is an implicit instantiation, the
1596 second is an explicit specialization, and the
1597 implicit instantiation has not yet been used. That
1598 situation can occur if we have implicitly
1599 instantiated a member function and then specialized
1602 We can also wind up here if a friend declaration that
1603 looked like an instantiation turns out to be a
1606 template <class T> void foo(T);
1607 class S { friend void foo<>(int) };
1608 template <> void foo(int);
1610 We transform the existing DECL in place so that any
1611 pointers to it become pointers to the updated
1614 If there was a definition for the template, but not
1615 for the specialization, we want this to look as if
1616 there were no definition, and vice versa. */
1617 DECL_INITIAL (fn
) = NULL_TREE
;
1618 duplicate_decls (spec
, fn
, is_friend
);
1619 /* The call to duplicate_decls will have applied
1622 An explicit specialization of a function template
1623 is inline only if it is explicitly declared to be,
1624 and independently of whether its function template
1627 to the primary function; now copy the inline bits to
1628 the various clones. */
1629 FOR_EACH_CLONE (clone
, fn
)
1631 DECL_DECLARED_INLINE_P (clone
)
1632 = DECL_DECLARED_INLINE_P (fn
);
1633 DECL_SOURCE_LOCATION (clone
)
1634 = DECL_SOURCE_LOCATION (fn
);
1635 DECL_DELETED_FN (clone
)
1636 = DECL_DELETED_FN (fn
);
1638 check_specialization_namespace (tmpl
);
1643 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1645 tree dd
= duplicate_decls (spec
, fn
, is_friend
);
1646 if (dd
== error_mark_node
)
1647 /* We've already complained in duplicate_decls. */
1648 return error_mark_node
;
1650 if (dd
== NULL_TREE
&& DECL_INITIAL (spec
))
1651 /* Dup decl failed, but this is a new definition. Set the
1652 line number so any errors match this new
1654 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1660 return duplicate_decls (spec
, fn
, is_friend
);
1662 /* A specialization must be declared in the same namespace as the
1663 template it is specializing. */
1664 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1665 && !check_specialization_namespace (tmpl
))
1666 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1668 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1670 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1671 gcc_assert (tmpl
&& args
&& spec
);
1674 if ((TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1675 && PRIMARY_TEMPLATE_P (tmpl
)
1676 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1677 || variable_template_p (tmpl
))
1678 /* If TMPL is a forward declaration of a template function, keep a list
1679 of all specializations in case we need to reassign them to a friend
1680 template later in tsubst_friend_function.
1682 Also keep a list of all variable template instantiations so that
1683 process_partial_specialization can check whether a later partial
1684 specialization would have used it. */
1685 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1686 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1692 /* Returns true iff two spec_entry nodes are equivalent. */
1694 int comparing_specializations
;
1697 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1701 ++comparing_specializations
;
1702 equal
= (e1
->tmpl
== e2
->tmpl
1703 && comp_template_args (e1
->args
, e2
->args
));
1704 if (equal
&& flag_concepts
1705 /* tmpl could be a FIELD_DECL for a capture pack. */
1706 && TREE_CODE (e1
->tmpl
) == TEMPLATE_DECL
1707 && VAR_P (DECL_TEMPLATE_RESULT (e1
->tmpl
))
1708 && uses_template_parms (e1
->args
))
1710 /* Partial specializations of a variable template can be distinguished by
1712 tree c1
= e1
->spec
? get_constraints (e1
->spec
) : NULL_TREE
;
1713 tree c2
= e2
->spec
? get_constraints (e2
->spec
) : NULL_TREE
;
1714 equal
= equivalent_constraints (c1
, c2
);
1716 --comparing_specializations
;
1721 /* Returns a hash for a template TMPL and template arguments ARGS. */
1724 hash_tmpl_and_args (tree tmpl
, tree args
)
1726 hashval_t val
= iterative_hash_object (DECL_UID (tmpl
), 0);
1727 return iterative_hash_template_arg (args
, val
);
1730 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1734 spec_hasher::hash (spec_entry
*e
)
1736 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1739 /* Recursively calculate a hash value for a template argument ARG, for use
1740 in the hash tables of template specializations. */
1743 iterative_hash_template_arg (tree arg
, hashval_t val
)
1745 unsigned HOST_WIDE_INT i
;
1746 enum tree_code code
;
1749 if (arg
== NULL_TREE
)
1750 return iterative_hash_object (arg
, val
);
1755 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1758 code
= TREE_CODE (arg
);
1759 tclass
= TREE_CODE_CLASS (code
);
1761 val
= iterative_hash_object (code
, val
);
1768 case IDENTIFIER_NODE
:
1769 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1773 int i
, len
= TREE_VEC_LENGTH (arg
);
1774 for (i
= 0; i
< len
; ++i
)
1775 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1779 case TYPE_PACK_EXPANSION
:
1780 case EXPR_PACK_EXPANSION
:
1781 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1782 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1784 case TYPE_ARGUMENT_PACK
:
1785 case NONTYPE_ARGUMENT_PACK
:
1786 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1789 for (; arg
; arg
= TREE_CHAIN (arg
))
1790 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1794 for (lkp_iterator
iter (arg
); iter
; ++iter
)
1795 val
= iterative_hash_template_arg (*iter
, val
);
1801 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1802 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1804 val
= iterative_hash_template_arg (field
, val
);
1805 val
= iterative_hash_template_arg (value
, val
);
1811 if (!DECL_ARTIFICIAL (arg
))
1813 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1814 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1816 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1819 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1822 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1823 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1825 case TEMPLATE_PARM_INDEX
:
1826 val
= iterative_hash_template_arg
1827 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1828 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1829 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1832 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1833 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1834 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1837 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1839 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1843 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1844 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1845 val
= iterative_hash_object (code
, val
);
1846 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1849 /* [temp.over.link] Two lambda-expressions are never considered
1852 So just hash the closure type. */
1853 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1856 case IMPLICIT_CONV_EXPR
:
1857 case STATIC_CAST_EXPR
:
1858 case REINTERPRET_CAST_EXPR
:
1859 case CONST_CAST_EXPR
:
1860 case DYNAMIC_CAST_EXPR
:
1862 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1863 /* Now hash operands as usual. */
1868 tree fn
= CALL_EXPR_FN (arg
);
1869 if (tree name
= dependent_name (fn
))
1871 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
1872 val
= iterative_hash_template_arg (TREE_OPERAND (fn
, 1), val
);
1875 val
= iterative_hash_template_arg (fn
, val
);
1876 call_expr_arg_iterator ai
;
1877 for (tree x
= first_call_expr_arg (arg
, &ai
); x
;
1878 x
= next_call_expr_arg (&ai
))
1879 val
= iterative_hash_template_arg (x
, val
);
1890 if (alias_template_specialization_p (arg
))
1892 // We want an alias specialization that survived strip_typedefs
1893 // to hash differently from its TYPE_CANONICAL, to avoid hash
1894 // collisions that compare as different in template_args_equal.
1895 // These could be dependent specializations that strip_typedefs
1896 // left alone, or untouched specializations because
1897 // coerce_template_parms returns the unconverted template
1898 // arguments if it sees incomplete argument packs.
1899 tree ti
= TYPE_ALIAS_TEMPLATE_INFO (arg
);
1900 return hash_tmpl_and_args (TI_TEMPLATE (ti
), TI_ARGS (ti
));
1902 if (TYPE_CANONICAL (arg
))
1903 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1905 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1906 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1907 /* Otherwise just compare the types during lookup. */
1910 case tcc_declaration
:
1912 return iterative_hash_expr (arg
, val
);
1915 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1917 unsigned n
= cp_tree_operand_length (arg
);
1918 for (i
= 0; i
< n
; ++i
)
1919 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1927 /* Unregister the specialization SPEC as a specialization of TMPL.
1928 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1929 if the SPEC was listed as a specialization of TMPL.
1931 Note that SPEC has been ggc_freed, so we can't look inside it. */
1934 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1939 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1940 elt
.args
= TI_ARGS (tinfo
);
1941 elt
.spec
= NULL_TREE
;
1943 entry
= decl_specializations
->find (&elt
);
1946 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1947 gcc_assert (new_spec
!= NULL_TREE
);
1948 entry
->spec
= new_spec
;
1955 /* Like register_specialization, but for local declarations. We are
1956 registering SPEC, an instantiation of TMPL. */
1959 register_local_specialization (tree spec
, tree tmpl
)
1961 gcc_assert (tmpl
!= spec
);
1962 local_specializations
->put (tmpl
, spec
);
1965 /* TYPE is a class type. Returns true if TYPE is an explicitly
1966 specialized class. */
1969 explicit_class_specialization_p (tree type
)
1971 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1973 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1976 /* Print the list of functions at FNS, going through all the overloads
1977 for each element of the list. Alternatively, FNS cannot be a
1978 TREE_LIST, in which case it will be printed together with all the
1981 MORE and *STR should respectively be FALSE and NULL when the function
1982 is called from the outside. They are used internally on recursive
1983 calls. print_candidates manages the two parameters and leaves NULL
1984 in *STR when it ends. */
1987 print_candidates_1 (tree fns
, char **str
, bool more
= false)
1989 if (TREE_CODE (fns
) == TREE_LIST
)
1990 for (; fns
; fns
= TREE_CHAIN (fns
))
1991 print_candidates_1 (TREE_VALUE (fns
), str
, more
|| TREE_CHAIN (fns
));
1993 for (lkp_iterator
iter (fns
); iter
;)
1998 const char *pfx
= *str
;
2002 pfx
= _("candidates are:");
2004 pfx
= _("candidate is:");
2005 *str
= get_spaces (pfx
);
2007 inform (DECL_SOURCE_LOCATION (cand
), "%s %#qD", pfx
, cand
);
2011 /* Print the list of candidate FNS in an error message. FNS can also
2012 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
2015 print_candidates (tree fns
)
2018 print_candidates_1 (fns
, &str
);
2022 /* Get a (possibly) constrained template declaration for the
2023 purpose of ordering candidates. */
2025 get_template_for_ordering (tree list
)
2027 gcc_assert (TREE_CODE (list
) == TREE_LIST
);
2028 tree f
= TREE_VALUE (list
);
2029 if (tree ti
= DECL_TEMPLATE_INFO (f
))
2030 return TI_TEMPLATE (ti
);
2034 /* Among candidates having the same signature, return the
2035 most constrained or NULL_TREE if there is no best candidate.
2036 If the signatures of candidates vary (e.g., template
2037 specialization vs. member function), then there can be no
2040 Note that we don't compare constraints on the functions
2041 themselves, but rather those of their templates. */
2043 most_constrained_function (tree candidates
)
2045 // Try to find the best candidate in a first pass.
2046 tree champ
= candidates
;
2047 for (tree c
= TREE_CHAIN (champ
); c
; c
= TREE_CHAIN (c
))
2049 int winner
= more_constrained (get_template_for_ordering (champ
),
2050 get_template_for_ordering (c
));
2052 champ
= c
; // The candidate is more constrained
2053 else if (winner
== 0)
2054 return NULL_TREE
; // Neither is more constrained
2057 // Verify that the champ is better than previous candidates.
2058 for (tree c
= candidates
; c
!= champ
; c
= TREE_CHAIN (c
)) {
2059 if (!more_constrained (get_template_for_ordering (champ
),
2060 get_template_for_ordering (c
)))
2068 /* Returns the template (one of the functions given by TEMPLATE_ID)
2069 which can be specialized to match the indicated DECL with the
2070 explicit template args given in TEMPLATE_ID. The DECL may be
2071 NULL_TREE if none is available. In that case, the functions in
2072 TEMPLATE_ID are non-members.
2074 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2075 specialization of a member template.
2077 The TEMPLATE_COUNT is the number of references to qualifying
2078 template classes that appeared in the name of the function. See
2079 check_explicit_specialization for a more accurate description.
2081 TSK indicates what kind of template declaration (if any) is being
2082 declared. TSK_TEMPLATE indicates that the declaration given by
2083 DECL, though a FUNCTION_DECL, has template parameters, and is
2084 therefore a template function.
2086 The template args (those explicitly specified and those deduced)
2087 are output in a newly created vector *TARGS_OUT.
2089 If it is impossible to determine the result, an error message is
2090 issued. The error_mark_node is returned to indicate failure. */
2093 determine_specialization (tree template_id
,
2096 int need_member_template
,
2102 tree explicit_targs
;
2103 tree candidates
= NULL_TREE
;
2105 /* A TREE_LIST of templates of which DECL may be a specialization.
2106 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2107 corresponding TREE_PURPOSE is the set of template arguments that,
2108 when used to instantiate the template, would produce a function
2109 with the signature of DECL. */
2110 tree templates
= NULL_TREE
;
2112 cp_binding_level
*b
;
2114 *targs_out
= NULL_TREE
;
2116 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
2117 return error_mark_node
;
2119 /* We shouldn't be specializing a member template of an
2120 unspecialized class template; we already gave an error in
2121 check_specialization_scope, now avoid crashing. */
2123 && template_count
&& DECL_CLASS_SCOPE_P (decl
)
2124 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
2126 gcc_assert (errorcount
);
2127 return error_mark_node
;
2130 fns
= TREE_OPERAND (template_id
, 0);
2131 explicit_targs
= TREE_OPERAND (template_id
, 1);
2133 if (fns
== error_mark_node
)
2134 return error_mark_node
;
2136 /* Check for baselinks. */
2137 if (BASELINK_P (fns
))
2138 fns
= BASELINK_FUNCTIONS (fns
);
2140 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
2142 error ("%qD is not a function template", fns
);
2143 return error_mark_node
;
2145 else if (VAR_P (decl
) && !variable_template_p (fns
))
2147 error ("%qD is not a variable template", fns
);
2148 return error_mark_node
;
2151 /* Count the number of template headers specified for this
2154 for (b
= current_binding_level
;
2155 b
->kind
== sk_template_parms
;
2159 tree orig_fns
= fns
;
2161 if (variable_template_p (fns
))
2163 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns
));
2164 targs
= coerce_template_parms (parms
, explicit_targs
, fns
,
2165 tf_warning_or_error
,
2166 /*req_all*/true, /*use_defarg*/true);
2167 if (targs
!= error_mark_node
)
2168 templates
= tree_cons (targs
, fns
, templates
);
2170 else for (lkp_iterator
iter (fns
); iter
; ++iter
)
2174 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2176 tree decl_arg_types
;
2180 /* In case of explicit specialization, we need to check if
2181 the number of template headers appearing in the specialization
2182 is correct. This is usually done in check_explicit_specialization,
2183 but the check done there cannot be exhaustive when specializing
2184 member functions. Consider the following code:
2186 template <> void A<int>::f(int);
2187 template <> template <> void A<int>::f(int);
2189 Assuming that A<int> is not itself an explicit specialization
2190 already, the first line specializes "f" which is a non-template
2191 member function, whilst the second line specializes "f" which
2192 is a template member function. So both lines are syntactically
2193 correct, and check_explicit_specialization does not reject
2196 Here, we can do better, as we are matching the specialization
2197 against the declarations. We count the number of template
2198 headers, and we check if they match TEMPLATE_COUNT + 1
2199 (TEMPLATE_COUNT is the number of qualifying template classes,
2200 plus there must be another header for the member template
2203 Notice that if header_count is zero, this is not a
2204 specialization but rather a template instantiation, so there
2205 is no check we can perform here. */
2206 if (header_count
&& header_count
!= template_count
+ 1)
2209 /* Check that the number of template arguments at the
2210 innermost level for DECL is the same as for FN. */
2211 if (current_binding_level
->kind
== sk_template_parms
2212 && !current_binding_level
->explicit_spec_p
2213 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
2214 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
2215 (current_template_parms
))))
2218 /* DECL might be a specialization of FN. */
2219 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2220 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2222 /* For a non-static member function, we need to make sure
2223 that the const qualification is the same. Since
2224 get_bindings does not try to merge the "this" parameter,
2225 we must do the comparison explicitly. */
2226 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
2228 if (!same_type_p (TREE_VALUE (fn_arg_types
),
2229 TREE_VALUE (decl_arg_types
)))
2232 /* And the ref-qualification. */
2233 if (type_memfn_rqual (TREE_TYPE (decl
))
2234 != type_memfn_rqual (TREE_TYPE (fn
)))
2238 /* Skip the "this" parameter and, for constructors of
2239 classes with virtual bases, the VTT parameter. A
2240 full specialization of a constructor will have a VTT
2241 parameter, but a template never will. */
2243 = skip_artificial_parms_for (decl
, decl_arg_types
);
2245 = skip_artificial_parms_for (fn
, fn_arg_types
);
2247 /* Function templates cannot be specializations; there are
2248 no partial specializations of functions. Therefore, if
2249 the type of DECL does not match FN, there is no
2252 Note that it should never be the case that we have both
2253 candidates added here, and for regular member functions
2255 if (tsk
== tsk_template
)
2257 if (compparms (fn_arg_types
, decl_arg_types
))
2258 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2262 /* See whether this function might be a specialization of this
2263 template. Suppress access control because we might be trying
2264 to make this specialization a friend, and we have already done
2265 access control for the declaration of the specialization. */
2266 push_deferring_access_checks (dk_no_check
);
2267 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
2268 pop_deferring_access_checks ();
2271 /* We cannot deduce template arguments that when used to
2272 specialize TMPL will produce DECL. */
2275 if (uses_template_parms (targs
))
2276 /* We deduced something involving 'auto', which isn't a valid
2277 template argument. */
2280 /* Remove, from the set of candidates, all those functions
2281 whose constraints are not satisfied. */
2282 if (flag_concepts
&& !constraints_satisfied_p (fn
, targs
))
2285 // Then, try to form the new function type.
2286 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_fndecl_type
, NULL_TREE
);
2287 if (insttype
== error_mark_node
)
2290 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
2291 if (!compparms (fn_arg_types
, decl_arg_types
))
2294 /* Save this template, and the arguments deduced. */
2295 templates
= tree_cons (targs
, fn
, templates
);
2297 else if (need_member_template
)
2298 /* FN is an ordinary member function, and we need a
2299 specialization of a member template. */
2301 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2302 /* We can get IDENTIFIER_NODEs here in certain erroneous
2305 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2306 /* This is just an ordinary non-member function. Nothing can
2307 be a specialization of that. */
2309 else if (DECL_ARTIFICIAL (fn
))
2310 /* Cannot specialize functions that are created implicitly. */
2314 tree decl_arg_types
;
2316 /* This is an ordinary member function. However, since
2317 we're here, we can assume its enclosing class is a
2318 template class. For example,
2320 template <typename T> struct S { void f(); };
2321 template <> void S<int>::f() {}
2323 Here, S<int>::f is a non-template, but S<int> is a
2324 template class. If FN has the same type as DECL, we
2325 might be in business. */
2327 if (!DECL_TEMPLATE_INFO (fn
))
2328 /* Its enclosing class is an explicit specialization
2329 of a template class. This is not a candidate. */
2332 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2333 TREE_TYPE (TREE_TYPE (fn
))))
2334 /* The return types differ. */
2337 /* Adjust the type of DECL in case FN is a static member. */
2338 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2339 if (DECL_STATIC_FUNCTION_P (fn
)
2340 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2341 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2343 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2347 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2348 && (type_memfn_rqual (TREE_TYPE (decl
))
2349 != type_memfn_rqual (TREE_TYPE (fn
))))
2352 // If the deduced arguments do not satisfy the constraints,
2353 // this is not a candidate.
2354 if (flag_concepts
&& !constraints_satisfied_p (fn
))
2357 // Add the candidate.
2358 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2362 if (templates
&& TREE_CHAIN (templates
))
2368 It is possible for a specialization with a given function
2369 signature to be instantiated from more than one function
2370 template. In such cases, explicit specification of the
2371 template arguments must be used to uniquely identify the
2372 function template specialization being specialized.
2374 Note that here, there's no suggestion that we're supposed to
2375 determine which of the candidate templates is most
2376 specialized. However, we, also have:
2380 Partial ordering of overloaded function template
2381 declarations is used in the following contexts to select
2382 the function template to which a function template
2383 specialization refers:
2385 -- when an explicit specialization refers to a function
2388 So, we do use the partial ordering rules, at least for now.
2389 This extension can only serve to make invalid programs valid,
2390 so it's safe. And, there is strong anecdotal evidence that
2391 the committee intended the partial ordering rules to apply;
2392 the EDG front end has that behavior, and John Spicer claims
2393 that the committee simply forgot to delete the wording in
2394 [temp.expl.spec]. */
2395 tree tmpl
= most_specialized_instantiation (templates
);
2396 if (tmpl
!= error_mark_node
)
2399 TREE_CHAIN (templates
) = NULL_TREE
;
2403 // Concepts allows multiple declarations of member functions
2404 // with the same signature. Like above, we need to rely on
2405 // on the partial ordering of those candidates to determine which
2407 if (flag_concepts
&& candidates
&& TREE_CHAIN (candidates
))
2409 if (tree cand
= most_constrained_function (candidates
))
2412 TREE_CHAIN (cand
) = NULL_TREE
;
2416 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2418 error ("template-id %qD for %q+D does not match any template "
2419 "declaration", template_id
, decl
);
2420 if (header_count
&& header_count
!= template_count
+ 1)
2421 inform (input_location
, "saw %d %<template<>%>, need %d for "
2422 "specializing a member function template",
2423 header_count
, template_count
+ 1);
2425 print_candidates (orig_fns
);
2426 return error_mark_node
;
2428 else if ((templates
&& TREE_CHAIN (templates
))
2429 || (candidates
&& TREE_CHAIN (candidates
))
2430 || (templates
&& candidates
))
2432 error ("ambiguous template specialization %qD for %q+D",
2434 candidates
= chainon (candidates
, templates
);
2435 print_candidates (candidates
);
2436 return error_mark_node
;
2439 /* We have one, and exactly one, match. */
2442 tree fn
= TREE_VALUE (candidates
);
2443 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2445 // Propagate the candidate's constraints to the declaration.
2446 set_constraints (decl
, get_constraints (fn
));
2448 /* DECL is a re-declaration or partial instantiation of a template
2450 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2452 /* It was a specialization of an ordinary member function in a
2454 return DECL_TI_TEMPLATE (fn
);
2457 /* It was a specialization of a template. */
2458 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2459 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2461 *targs_out
= copy_node (targs
);
2462 SET_TMPL_ARGS_LEVEL (*targs_out
,
2463 TMPL_ARGS_DEPTH (*targs_out
),
2464 TREE_PURPOSE (templates
));
2467 *targs_out
= TREE_PURPOSE (templates
);
2468 return TREE_VALUE (templates
);
2471 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2472 but with the default argument values filled in from those in the
2476 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2479 tree new_spec_types
;
2484 if (spec_types
== void_list_node
)
2485 return void_list_node
;
2487 /* Substitute into the rest of the list. */
2489 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2490 TREE_CHAIN (tmpl_types
));
2492 /* Add the default argument for this parameter. */
2493 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2494 TREE_VALUE (spec_types
),
2498 /* DECL is an explicit specialization. Replicate default arguments
2499 from the template it specializes. (That way, code like:
2501 template <class T> void f(T = 3);
2502 template <> void f(double);
2505 works, as required.) An alternative approach would be to look up
2506 the correct default arguments at the call-site, but this approach
2507 is consistent with how implicit instantiations are handled. */
2510 copy_default_args_to_explicit_spec (tree decl
)
2515 tree new_spec_types
;
2519 tree object_type
= NULL_TREE
;
2520 tree in_charge
= NULL_TREE
;
2521 tree vtt
= NULL_TREE
;
2523 /* See if there's anything we need to do. */
2524 tmpl
= DECL_TI_TEMPLATE (decl
);
2525 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2526 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2527 if (TREE_PURPOSE (t
))
2532 old_type
= TREE_TYPE (decl
);
2533 spec_types
= TYPE_ARG_TYPES (old_type
);
2535 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2537 /* Remove the this pointer, but remember the object's type for
2539 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2540 spec_types
= TREE_CHAIN (spec_types
);
2541 tmpl_types
= TREE_CHAIN (tmpl_types
);
2543 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2545 /* DECL may contain more parameters than TMPL due to the extra
2546 in-charge parameter in constructors and destructors. */
2547 in_charge
= spec_types
;
2548 spec_types
= TREE_CHAIN (spec_types
);
2550 if (DECL_HAS_VTT_PARM_P (decl
))
2553 spec_types
= TREE_CHAIN (spec_types
);
2557 /* Compute the merged default arguments. */
2559 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2561 /* Compute the new FUNCTION_TYPE. */
2565 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2570 /* Put the in-charge parameter back. */
2571 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2572 TREE_VALUE (in_charge
),
2575 new_type
= build_method_type_directly (object_type
,
2576 TREE_TYPE (old_type
),
2580 new_type
= build_function_type (TREE_TYPE (old_type
),
2582 new_type
= cp_build_type_attribute_variant (new_type
,
2583 TYPE_ATTRIBUTES (old_type
));
2584 new_type
= cxx_copy_lang_qualifiers (new_type
, old_type
);
2586 TREE_TYPE (decl
) = new_type
;
2589 /* Return the number of template headers we expect to see for a definition
2590 or specialization of CTYPE or one of its non-template members. */
2593 num_template_headers_for_class (tree ctype
)
2595 int num_templates
= 0;
2597 while (ctype
&& CLASS_TYPE_P (ctype
))
2599 /* You're supposed to have one `template <...>' for every
2600 template class, but you don't need one for a full
2601 specialization. For example:
2603 template <class T> struct S{};
2604 template <> struct S<int> { void f(); };
2605 void S<int>::f () {}
2607 is correct; there shouldn't be a `template <>' for the
2608 definition of `S<int>::f'. */
2609 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2610 /* If CTYPE does not have template information of any
2611 kind, then it is not a template, nor is it nested
2612 within a template. */
2614 if (explicit_class_specialization_p (ctype
))
2616 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2619 ctype
= TYPE_CONTEXT (ctype
);
2622 return num_templates
;
2625 /* Do a simple sanity check on the template headers that precede the
2626 variable declaration DECL. */
2629 check_template_variable (tree decl
)
2631 tree ctx
= CP_DECL_CONTEXT (decl
);
2632 int wanted
= num_template_headers_for_class (ctx
);
2633 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2634 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2636 if (cxx_dialect
< cxx14
)
2637 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2638 "variable templates only available with "
2639 "%<-std=c++14%> or %<-std=gnu++14%>");
2641 // Namespace-scope variable templates should have a template header.
2644 if (template_header_count
> wanted
)
2646 auto_diagnostic_group d
;
2647 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2648 "too many template headers for %qD "
2651 if (warned
&& CLASS_TYPE_P (ctx
)
2652 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2653 inform (DECL_SOURCE_LOCATION (decl
),
2654 "members of an explicitly specialized class are defined "
2655 "without a template header");
2659 /* An explicit specialization whose declarator-id or class-head-name is not
2660 qualified shall be declared in the nearest enclosing namespace of the
2661 template, or, if the namespace is inline (7.3.1), any namespace from its
2662 enclosing namespace set.
2664 If the name declared in the explicit instantiation is an unqualified name,
2665 the explicit instantiation shall appear in the namespace where its template
2666 is declared or, if that namespace is inline (7.3.1), any namespace from its
2667 enclosing namespace set. */
2670 check_unqualified_spec_or_inst (tree t
, location_t loc
)
2672 tree tmpl
= most_general_template (t
);
2673 if (DECL_NAMESPACE_SCOPE_P (tmpl
)
2674 && !is_nested_namespace (current_namespace
,
2675 CP_DECL_CONTEXT (tmpl
), true))
2677 if (processing_specialization
)
2678 permerror (loc
, "explicit specialization of %qD outside its "
2679 "namespace must use a nested-name-specifier", tmpl
);
2680 else if (processing_explicit_instantiation
2681 && cxx_dialect
>= cxx11
)
2682 /* This was allowed in C++98, so only pedwarn. */
2683 pedwarn (loc
, OPT_Wpedantic
, "explicit instantiation of %qD "
2684 "outside its namespace must use a nested-name-"
2689 /* Warn for a template specialization SPEC that is missing some of a set
2690 of function or type attributes that the template TEMPL is declared with.
2691 ATTRLIST is a list of additional attributes that SPEC should be taken
2692 to ultimately be declared with. */
2695 warn_spec_missing_attributes (tree tmpl
, tree spec
, tree attrlist
)
2697 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
2698 tmpl
= DECL_TEMPLATE_RESULT (tmpl
);
2700 /* Avoid warning if the difference between the primary and
2701 the specialization is not in one of the attributes below. */
2702 const char* const blacklist
[] = {
2703 "alloc_align", "alloc_size", "assume_aligned", "format",
2704 "format_arg", "malloc", "nonnull", NULL
2707 /* Put together a list of the black listed attributes that the primary
2708 template is declared with that the specialization is not, in case
2709 it's not apparent from the most recent declaration of the primary. */
2711 unsigned nattrs
= decls_mismatched_attributes (tmpl
, spec
, attrlist
,
2717 auto_diagnostic_group d
;
2718 if (warning_at (DECL_SOURCE_LOCATION (spec
), OPT_Wmissing_attributes
,
2719 "explicit specialization %q#D may be missing attributes",
2721 inform (DECL_SOURCE_LOCATION (tmpl
),
2723 ? G_("missing primary template attributes %s")
2724 : G_("missing primary template attribute %s"),
2725 pp_formatted_text (&str
));
2728 /* Check to see if the function just declared, as indicated in
2729 DECLARATOR, and in DECL, is a specialization of a function
2730 template. We may also discover that the declaration is an explicit
2731 instantiation at this point.
2733 Returns DECL, or an equivalent declaration that should be used
2734 instead if all goes well. Issues an error message if something is
2735 amiss. Returns error_mark_node if the error is not easily
2738 FLAGS is a bitmask consisting of the following flags:
2740 2: The function has a definition.
2741 4: The function is a friend.
2743 The TEMPLATE_COUNT is the number of references to qualifying
2744 template classes that appeared in the name of the function. For
2747 template <class T> struct S { void f(); };
2750 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2751 classes are not counted in the TEMPLATE_COUNT, so that in
2753 template <class T> struct S {};
2754 template <> struct S<int> { void f(); }
2755 template <> void S<int>::f();
2757 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2758 invalid; there should be no template <>.)
2760 If the function is a specialization, it is marked as such via
2761 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2762 is set up correctly, and it is added to the list of specializations
2763 for that template. */
2766 check_explicit_specialization (tree declarator
,
2772 int have_def
= flags
& 2;
2773 int is_friend
= flags
& 4;
2774 bool is_concept
= flags
& 8;
2775 int specialization
= 0;
2776 int explicit_instantiation
= 0;
2777 int member_specialization
= 0;
2778 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2779 tree dname
= DECL_NAME (decl
);
2784 if (!processing_specialization
)
2787 tsk
= tsk_excessive_parms
;
2790 tsk
= current_tmpl_spec_kind (template_count
);
2795 if (processing_specialization
&& !VAR_P (decl
))
2798 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2800 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2803 /* This could be something like:
2805 template <class T> void f(T);
2806 class S { friend void f<>(int); } */
2810 /* This case handles bogus declarations like template <>
2811 template <class T> void f<int>(); */
2813 error ("template-id %qD in declaration of primary template",
2820 case tsk_invalid_member_spec
:
2821 /* The error has already been reported in
2822 check_specialization_scope. */
2823 return error_mark_node
;
2825 case tsk_invalid_expl_inst
:
2826 error ("template parameter list used in explicit instantiation");
2832 error ("definition provided for explicit instantiation");
2834 explicit_instantiation
= 1;
2837 case tsk_excessive_parms
:
2838 case tsk_insufficient_parms
:
2839 if (tsk
== tsk_excessive_parms
)
2840 error ("too many template parameter lists in declaration of %qD",
2842 else if (template_header_count
)
2843 error("too few template parameter lists in declaration of %qD", decl
);
2845 error("explicit specialization of %qD must be introduced by "
2846 "%<template <>%>", decl
);
2851 error ("explicit specialization declared %<concept%>");
2853 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2854 /* In cases like template<> constexpr bool v = true;
2855 We'll give an error in check_template_variable. */
2858 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2860 member_specialization
= 1;
2866 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2868 /* This case handles bogus declarations like template <>
2869 template <class T> void f<int>(); */
2871 if (!uses_template_parms (TREE_OPERAND (declarator
, 1)))
2872 error ("template-id %qD in declaration of primary template",
2874 else if (variable_template_p (TREE_OPERAND (declarator
, 0)))
2876 /* Partial specialization of variable template. */
2877 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2881 else if (cxx_dialect
< cxx14
)
2882 error ("non-type partial specialization %qD "
2883 "is not allowed", declarator
);
2885 error ("non-class, non-variable partial specialization %qD "
2886 "is not allowed", declarator
);
2891 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2892 /* This is a specialization of a member template, without
2893 specialization the containing class. Something like:
2895 template <class T> struct S {
2896 template <class U> void f (U);
2898 template <> template <class U> void S<int>::f(U) {}
2900 That's a specialization -- but of the entire template. */
2908 if ((specialization
|| member_specialization
)
2909 /* This doesn't apply to variable templates. */
2910 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (decl
)))
2912 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2913 for (; t
; t
= TREE_CHAIN (t
))
2914 if (TREE_PURPOSE (t
))
2916 permerror (input_location
,
2917 "default argument specified in explicit specialization");
2922 if (specialization
|| member_specialization
|| explicit_instantiation
)
2924 tree tmpl
= NULL_TREE
;
2925 tree targs
= NULL_TREE
;
2926 bool was_template_id
= (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
);
2928 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2929 if (!was_template_id
)
2933 gcc_assert (identifier_p (declarator
));
2938 /* If there is no class context, the explicit instantiation
2939 must be at namespace scope. */
2940 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2942 /* Find the namespace binding, using the declaration
2944 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2946 if (fns
== error_mark_node
)
2947 /* If lookup fails, look for a friend declaration so we can
2948 give a better diagnostic. */
2949 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2950 /*type*/false, /*complain*/true,
2953 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2955 error ("%qD is not a template function", dname
);
2956 fns
= error_mark_node
;
2960 declarator
= lookup_template_function (fns
, NULL_TREE
);
2963 if (declarator
== error_mark_node
)
2964 return error_mark_node
;
2966 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2968 if (!explicit_instantiation
)
2969 /* A specialization in class scope. This is invalid,
2970 but the error will already have been flagged by
2971 check_specialization_scope. */
2972 return error_mark_node
;
2975 /* It's not valid to write an explicit instantiation in
2978 class C { template void f(); }
2980 This case is caught by the parser. However, on
2983 template class C { void f(); };
2985 (which is invalid) we can get here. The error will be
2992 else if (ctype
!= NULL_TREE
2993 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2995 // We'll match variable templates in start_decl.
2999 /* Find the list of functions in ctype that have the same
3000 name as the declared function. */
3001 tree name
= TREE_OPERAND (declarator
, 0);
3003 if (constructor_name_p (name
, ctype
))
3005 if (DECL_CONSTRUCTOR_P (decl
)
3006 ? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
3007 : !CLASSTYPE_DESTRUCTOR (ctype
))
3009 /* From [temp.expl.spec]:
3011 If such an explicit specialization for the member
3012 of a class template names an implicitly-declared
3013 special member function (clause _special_), the
3014 program is ill-formed.
3016 Similar language is found in [temp.explicit]. */
3017 error ("specialization of implicitly-declared special member function");
3018 return error_mark_node
;
3021 name
= DECL_NAME (decl
);
3024 /* For a type-conversion operator, We might be looking for
3025 `operator int' which will be a specialization of
3026 `operator T'. Grab all the conversion operators, and
3027 then select from them. */
3028 tree fns
= get_class_binding (ctype
, IDENTIFIER_CONV_OP_P (name
)
3029 ? conv_op_identifier
: name
);
3031 if (fns
== NULL_TREE
)
3033 error ("no member function %qD declared in %qT", name
, ctype
);
3034 return error_mark_node
;
3037 TREE_OPERAND (declarator
, 0) = fns
;
3040 /* Figure out what exactly is being specialized at this point.
3041 Note that for an explicit instantiation, even one for a
3042 member function, we cannot tell a priori whether the
3043 instantiation is for a member template, or just a member
3044 function of a template class. Even if a member template is
3045 being instantiated, the member template arguments may be
3046 elided if they can be deduced from the rest of the
3048 tmpl
= determine_specialization (declarator
, decl
,
3050 member_specialization
,
3054 if (!tmpl
|| tmpl
== error_mark_node
)
3055 /* We couldn't figure out what this declaration was
3057 return error_mark_node
;
3060 if (TREE_CODE (decl
) == FUNCTION_DECL
3061 && DECL_HIDDEN_FRIEND_P (tmpl
))
3063 auto_diagnostic_group d
;
3064 if (pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
3065 "friend declaration %qD is not visible to "
3066 "explicit specialization", tmpl
))
3067 inform (DECL_SOURCE_LOCATION (tmpl
),
3068 "friend declaration here");
3070 else if (!ctype
&& !is_friend
3071 && CP_DECL_CONTEXT (decl
) == current_namespace
)
3072 check_unqualified_spec_or_inst (tmpl
, DECL_SOURCE_LOCATION (decl
));
3074 tree gen_tmpl
= most_general_template (tmpl
);
3076 if (explicit_instantiation
)
3078 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
3079 is done by do_decl_instantiation later. */
3081 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
3082 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
3084 if (arg_depth
> parm_depth
)
3086 /* If TMPL is not the most general template (for
3087 example, if TMPL is a friend template that is
3088 injected into namespace scope), then there will
3089 be too many levels of TARGS. Remove some of them
3094 new_targs
= make_tree_vec (parm_depth
);
3095 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
3096 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
3097 = TREE_VEC_ELT (targs
, i
);
3101 return instantiate_template (tmpl
, targs
, tf_error
);
3104 /* If we thought that the DECL was a member function, but it
3105 turns out to be specializing a static member function,
3106 make DECL a static member function as well. */
3107 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
3108 && DECL_STATIC_FUNCTION_P (tmpl
)
3109 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
3110 revert_static_member_fn (decl
);
3112 /* If this is a specialization of a member template of a
3113 template class, we want to return the TEMPLATE_DECL, not
3114 the specialization of it. */
3115 if (tsk
== tsk_template
&& !was_template_id
)
3117 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
3118 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
3119 DECL_INITIAL (result
) = NULL_TREE
;
3123 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
3124 DECL_SOURCE_LOCATION (result
)
3125 = DECL_SOURCE_LOCATION (decl
);
3126 /* We want to use the argument list specified in the
3127 definition, not in the original declaration. */
3128 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
3129 for (parm
= DECL_ARGUMENTS (result
); parm
;
3130 parm
= DECL_CHAIN (parm
))
3131 DECL_CONTEXT (parm
) = result
;
3133 return register_specialization (tmpl
, gen_tmpl
, targs
,
3137 /* Set up the DECL_TEMPLATE_INFO for DECL. */
3138 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
3140 if (was_template_id
)
3141 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
)) = true;
3143 /* Inherit default function arguments from the template
3144 DECL is specializing. */
3145 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
3146 copy_default_args_to_explicit_spec (decl
);
3148 /* This specialization has the same protection as the
3149 template it specializes. */
3150 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
3151 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
3153 /* 7.1.1-1 [dcl.stc]
3155 A storage-class-specifier shall not be specified in an
3156 explicit specialization...
3158 The parser rejects these, so unless action is taken here,
3159 explicit function specializations will always appear with
3162 The action recommended by the C++ CWG in response to C++
3163 defect report 605 is to make the storage class and linkage
3164 of the explicit specialization match the templated function:
3166 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3168 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
3170 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
3171 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
3173 /* A concept cannot be specialized. */
3174 if (DECL_DECLARED_CONCEPT_P (tmpl_func
))
3176 error ("explicit specialization of function concept %qD",
3178 return error_mark_node
;
3181 /* This specialization has the same linkage and visibility as
3182 the function template it specializes. */
3183 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
3184 if (! TREE_PUBLIC (decl
))
3186 DECL_INTERFACE_KNOWN (decl
) = 1;
3187 DECL_NOT_REALLY_EXTERN (decl
) = 1;
3189 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
3190 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
3192 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3193 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
3197 /* If DECL is a friend declaration, declared using an
3198 unqualified name, the namespace associated with DECL may
3199 have been set incorrectly. For example, in:
3201 template <typename T> void f(T);
3203 struct S { friend void f<int>(int); }
3206 we will have set the DECL_CONTEXT for the friend
3207 declaration to N, rather than to the global namespace. */
3208 if (DECL_NAMESPACE_SCOPE_P (decl
))
3209 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
3211 if (is_friend
&& !have_def
)
3212 /* This is not really a declaration of a specialization.
3213 It's just the name of an instantiation. But, it's not
3214 a request for an instantiation, either. */
3215 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
3216 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3217 /* A specialization is not necessarily COMDAT. */
3218 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
3219 && DECL_DECLARED_INLINE_P (decl
));
3220 else if (VAR_P (decl
))
3221 DECL_COMDAT (decl
) = false;
3223 /* If this is a full specialization, register it so that we can find
3224 it again. Partial specializations will be registered in
3225 process_partial_specialization. */
3226 if (!processing_template_decl
)
3228 warn_spec_missing_attributes (gen_tmpl
, decl
, attrlist
);
3230 decl
= register_specialization (decl
, gen_tmpl
, targs
,
3235 /* A 'structor should already have clones. */
3236 gcc_assert (decl
== error_mark_node
3237 || variable_template_p (tmpl
)
3238 || !(DECL_CONSTRUCTOR_P (decl
)
3239 || DECL_DESTRUCTOR_P (decl
))
3240 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
3247 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3248 parameters. These are represented in the same format used for
3249 DECL_TEMPLATE_PARMS. */
3252 comp_template_parms (const_tree parms1
, const_tree parms2
)
3257 if (parms1
== parms2
)
3260 for (p1
= parms1
, p2
= parms2
;
3261 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
3262 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
3264 tree t1
= TREE_VALUE (p1
);
3265 tree t2
= TREE_VALUE (p2
);
3268 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
3269 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
3271 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3274 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
3276 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
3277 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
3279 /* If either of the template parameters are invalid, assume
3280 they match for the sake of error recovery. */
3281 if (error_operand_p (parm1
) || error_operand_p (parm2
))
3284 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
3287 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
3288 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
3289 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
3291 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
3296 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
3297 /* One set of parameters has more parameters lists than the
3304 /* Determine whether PARM is a parameter pack. */
3307 template_parameter_pack_p (const_tree parm
)
3309 /* Determine if we have a non-type template parameter pack. */
3310 if (TREE_CODE (parm
) == PARM_DECL
)
3311 return (DECL_TEMPLATE_PARM_P (parm
)
3312 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
3313 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
3314 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
3316 /* If this is a list of template parameters, we could get a
3317 TYPE_DECL or a TEMPLATE_DECL. */
3318 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
3319 parm
= TREE_TYPE (parm
);
3321 /* Otherwise it must be a type template parameter. */
3322 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
3323 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
3324 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
3327 /* Determine if T is a function parameter pack. */
3330 function_parameter_pack_p (const_tree t
)
3332 if (t
&& TREE_CODE (t
) == PARM_DECL
)
3333 return DECL_PACK_P (t
);
3337 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3338 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3341 get_function_template_decl (const_tree primary_func_tmpl_inst
)
3343 if (! primary_func_tmpl_inst
3344 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
3345 || ! primary_template_specialization_p (primary_func_tmpl_inst
))
3348 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
3351 /* Return true iff the function parameter PARAM_DECL was expanded
3352 from the function parameter pack PACK. */
3355 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
3357 if (DECL_ARTIFICIAL (param_decl
)
3358 || !function_parameter_pack_p (pack
))
3361 /* The parameter pack and its pack arguments have the same
3363 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
3366 /* Determine whether ARGS describes a variadic template args list,
3367 i.e., one that is terminated by a template argument pack. */
3370 template_args_variadic_p (tree args
)
3375 if (args
== NULL_TREE
)
3378 args
= INNERMOST_TEMPLATE_ARGS (args
);
3379 nargs
= TREE_VEC_LENGTH (args
);
3384 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
3386 return ARGUMENT_PACK_P (last_parm
);
3389 /* Generate a new name for the parameter pack name NAME (an
3390 IDENTIFIER_NODE) that incorporates its */
3393 make_ith_pack_parameter_name (tree name
, int i
)
3395 /* Munge the name to include the parameter index. */
3396 #define NUMBUF_LEN 128
3397 char numbuf
[NUMBUF_LEN
];
3401 if (name
== NULL_TREE
)
3403 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
3404 newname_len
= IDENTIFIER_LENGTH (name
)
3405 + strlen (numbuf
) + 2;
3406 newname
= (char*)alloca (newname_len
);
3407 snprintf (newname
, newname_len
,
3408 "%s#%i", IDENTIFIER_POINTER (name
), i
);
3409 return get_identifier (newname
);
3412 /* Return true if T is a primary function, class or alias template
3413 specialization, not including the template pattern. */
3416 primary_template_specialization_p (const_tree t
)
3421 if (TREE_CODE (t
) == FUNCTION_DECL
|| VAR_P (t
))
3422 return (DECL_LANG_SPECIFIC (t
)
3423 && DECL_USE_TEMPLATE (t
)
3424 && DECL_TEMPLATE_INFO (t
)
3425 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)));
3426 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3427 return (CLASSTYPE_TEMPLATE_INFO (t
)
3428 && CLASSTYPE_USE_TEMPLATE (t
)
3429 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
3430 else if (alias_template_specialization_p (t
))
3435 /* Return true if PARM is a template template parameter. */
3438 template_template_parameter_p (const_tree parm
)
3440 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3443 /* Return true iff PARM is a DECL representing a type template
3447 template_type_parameter_p (const_tree parm
)
3450 && (TREE_CODE (parm
) == TYPE_DECL
3451 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3452 && DECL_TEMPLATE_PARM_P (parm
));
3455 /* Return the template parameters of T if T is a
3456 primary template instantiation, NULL otherwise. */
3459 get_primary_template_innermost_parameters (const_tree t
)
3461 tree parms
= NULL
, template_info
= NULL
;
3463 if ((template_info
= get_template_info (t
))
3464 && primary_template_specialization_p (t
))
3465 parms
= INNERMOST_TEMPLATE_PARMS
3466 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3471 /* Return the template parameters of the LEVELth level from the full list
3472 of template parameters PARMS. */
3475 get_template_parms_at_level (tree parms
, int level
)
3479 || TREE_CODE (parms
) != TREE_LIST
3480 || level
> TMPL_PARMS_DEPTH (parms
))
3483 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3484 if (TMPL_PARMS_DEPTH (p
) == level
)
3490 /* Returns the template arguments of T if T is a template instantiation,
3494 get_template_innermost_arguments (const_tree t
)
3496 tree args
= NULL
, template_info
= NULL
;
3498 if ((template_info
= get_template_info (t
))
3499 && TI_ARGS (template_info
))
3500 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3505 /* Return the argument pack elements of T if T is a template argument pack,
3509 get_template_argument_pack_elems (const_tree t
)
3511 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3512 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3515 return ARGUMENT_PACK_ARGS (t
);
3518 /* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the
3519 ARGUMENT_PACK_SELECT represents. */
3522 argument_pack_select_arg (tree t
)
3524 tree args
= ARGUMENT_PACK_ARGS (ARGUMENT_PACK_SELECT_FROM_PACK (t
));
3525 tree arg
= TREE_VEC_ELT (args
, ARGUMENT_PACK_SELECT_INDEX (t
));
3527 /* If the selected argument is an expansion E, that most likely means we were
3528 called from gen_elem_of_pack_expansion_instantiation during the
3529 substituting of an argument pack (of which the Ith element is a pack
3530 expansion, where I is ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
3531 In this case, the Ith element resulting from this substituting is going to
3532 be a pack expansion, which pattern is the pattern of E. Let's return the
3533 pattern of E, and gen_elem_of_pack_expansion_instantiation will build the
3534 resulting pack expansion from it. */
3535 if (PACK_EXPANSION_P (arg
))
3537 /* Make sure we aren't throwing away arg info. */
3538 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
3539 arg
= PACK_EXPANSION_PATTERN (arg
);
3546 /* True iff FN is a function representing a built-in variadic parameter
3550 builtin_pack_fn_p (tree fn
)
3553 || TREE_CODE (fn
) != FUNCTION_DECL
3554 || !DECL_IS_BUILTIN (fn
))
3557 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3563 /* True iff CALL is a call to a function representing a built-in variadic
3567 builtin_pack_call_p (tree call
)
3569 if (TREE_CODE (call
) != CALL_EXPR
)
3571 return builtin_pack_fn_p (CALL_EXPR_FN (call
));
3574 /* Return a TREE_VEC for the expansion of __integer_pack(HI). */
3577 expand_integer_pack (tree call
, tree args
, tsubst_flags_t complain
,
3580 tree ohi
= CALL_EXPR_ARG (call
, 0);
3581 tree hi
= tsubst_copy_and_build (ohi
, args
, complain
, in_decl
,
3582 false/*fn*/, true/*int_cst*/);
3584 if (value_dependent_expression_p (hi
))
3588 call
= copy_node (call
);
3589 CALL_EXPR_ARG (call
, 0) = hi
;
3591 tree ex
= make_pack_expansion (call
, complain
);
3592 tree vec
= make_tree_vec (1);
3593 TREE_VEC_ELT (vec
, 0) = ex
;
3598 hi
= cxx_constant_value (hi
);
3599 int len
= valid_constant_size_p (hi
) ? tree_to_shwi (hi
) : -1;
3601 /* Calculate the largest value of len that won't make the size of the vec
3602 overflow an int. The compiler will exceed resource limits long before
3603 this, but it seems a decent place to diagnose. */
3604 int max
= ((INT_MAX
- sizeof (tree_vec
)) / sizeof (tree
)) + 1;
3606 if (len
< 0 || len
> max
)
3608 if ((complain
& tf_error
)
3609 && hi
!= error_mark_node
)
3610 error ("argument to %<__integer_pack%> must be between 0 and %d",
3612 return error_mark_node
;
3615 tree vec
= make_tree_vec (len
);
3617 for (int i
= 0; i
< len
; ++i
)
3618 TREE_VEC_ELT (vec
, i
) = size_int (i
);
3624 /* Return a TREE_VEC for the expansion of built-in template parameter pack
3628 expand_builtin_pack_call (tree call
, tree args
, tsubst_flags_t complain
,
3631 if (!builtin_pack_call_p (call
))
3634 tree fn
= CALL_EXPR_FN (call
);
3636 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3637 return expand_integer_pack (call
, args
, complain
, in_decl
);
3642 /* Structure used to track the progress of find_parameter_packs_r. */
3643 struct find_parameter_pack_data
3645 /* TREE_LIST that will contain all of the parameter packs found by
3647 tree
* parameter_packs
;
3649 /* Set of AST nodes that have been visited by the traversal. */
3650 hash_set
<tree
> *visited
;
3652 /* True iff we're making a type pack expansion. */
3653 bool type_pack_expansion_p
;
3656 /* Identifies all of the argument packs that occur in a template
3657 argument and appends them to the TREE_LIST inside DATA, which is a
3658 find_parameter_pack_data structure. This is a subroutine of
3659 make_pack_expansion and uses_parameter_packs. */
3661 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3664 struct find_parameter_pack_data
* ppd
=
3665 (struct find_parameter_pack_data
*)data
;
3666 bool parameter_pack_p
= false;
3668 /* Handle type aliases/typedefs. */
3669 if (TYPE_ALIAS_P (t
))
3671 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
3672 cp_walk_tree (&TI_ARGS (tinfo
),
3673 &find_parameter_packs_r
,
3679 /* Identify whether this is a parameter pack or not. */
3680 switch (TREE_CODE (t
))
3682 case TEMPLATE_PARM_INDEX
:
3683 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3684 parameter_pack_p
= true;
3687 case TEMPLATE_TYPE_PARM
:
3688 t
= TYPE_MAIN_VARIANT (t
);
3690 case TEMPLATE_TEMPLATE_PARM
:
3691 /* If the placeholder appears in the decl-specifier-seq of a function
3692 parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3693 is a pack expansion, the invented template parameter is a template
3695 if (ppd
->type_pack_expansion_p
&& is_auto (t
))
3696 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
3697 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3698 parameter_pack_p
= true;
3703 if (DECL_PACK_P (t
))
3705 /* We don't want to walk into the type of a PARM_DECL,
3706 because we don't want to see the type parameter pack. */
3708 parameter_pack_p
= true;
3713 if (DECL_PACK_P (t
))
3715 /* We don't want to walk into the type of a variadic capture proxy,
3716 because we don't want to see the type parameter pack. */
3718 parameter_pack_p
= true;
3720 else if (variable_template_specialization_p (t
))
3722 cp_walk_tree (&DECL_TI_ARGS (t
),
3723 find_parameter_packs_r
,
3730 if (builtin_pack_call_p (t
))
3731 parameter_pack_p
= true;
3735 parameter_pack_p
= true;
3738 /* Not a parameter pack. */
3742 if (parameter_pack_p
)
3744 /* Add this parameter pack to the list. */
3745 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3749 cp_walk_tree (&TYPE_CONTEXT (t
),
3750 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3752 /* This switch statement will return immediately if we don't find a
3754 switch (TREE_CODE (t
))
3756 case TEMPLATE_PARM_INDEX
:
3759 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3760 /* Check the template itself. */
3761 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3762 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3763 /* Check the template arguments. */
3764 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3769 case TEMPLATE_TYPE_PARM
:
3770 case TEMPLATE_TEMPLATE_PARM
:
3777 /* Ignore the declaration of a capture proxy for a parameter pack. */
3778 if (is_capture_proxy (DECL_EXPR_DECL (t
)))
3783 if (TYPE_PTRMEMFUNC_P (t
))
3789 if (TYPE_TEMPLATE_INFO (t
))
3790 cp_walk_tree (&TYPE_TI_ARGS (t
),
3791 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3797 if (!DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
3802 cp_walk_tree (&TREE_TYPE (t
),
3803 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3807 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3812 case TYPE_PACK_EXPANSION
:
3813 case EXPR_PACK_EXPANSION
:
3818 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3823 case IDENTIFIER_NODE
:
3824 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3831 /* Look at explicit captures. */
3832 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
);
3833 cap
; cap
= TREE_CHAIN (cap
))
3834 cp_walk_tree (&TREE_VALUE (cap
), &find_parameter_packs_r
, ppd
,
3836 /* Since we defer implicit capture, look in the parms and body. */
3837 tree fn
= lambda_function (t
);
3838 cp_walk_tree (&TREE_TYPE (fn
), &find_parameter_packs_r
, ppd
,
3840 cp_walk_tree (&DECL_SAVED_TREE (fn
), &find_parameter_packs_r
, ppd
,
3848 /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
3849 type_pack_expansion_p to false so that any placeholders
3850 within the expression don't get marked as parameter packs. */
3851 bool type_pack_expansion_p
= ppd
->type_pack_expansion_p
;
3852 ppd
->type_pack_expansion_p
= false;
3853 cp_walk_tree (&DECLTYPE_TYPE_EXPR (t
), &find_parameter_packs_r
,
3855 ppd
->type_pack_expansion_p
= type_pack_expansion_p
;
3861 cp_walk_tree (&IF_COND (t
), &find_parameter_packs_r
,
3863 cp_walk_tree (&THEN_CLAUSE (t
), &find_parameter_packs_r
,
3865 cp_walk_tree (&ELSE_CLAUSE (t
), &find_parameter_packs_r
,
3867 /* Don't walk into IF_STMT_EXTRA_ARGS. */
3878 /* Determines if the expression or type T uses any parameter packs. */
3880 uses_parameter_packs (tree t
)
3882 tree parameter_packs
= NULL_TREE
;
3883 struct find_parameter_pack_data ppd
;
3884 ppd
.parameter_packs
= ¶meter_packs
;
3885 ppd
.visited
= new hash_set
<tree
>;
3886 ppd
.type_pack_expansion_p
= false;
3887 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3889 return parameter_packs
!= NULL_TREE
;
3892 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3893 representation a base-class initializer into a parameter pack
3894 expansion. If all goes well, the resulting node will be an
3895 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3898 make_pack_expansion (tree arg
, tsubst_flags_t complain
)
3901 tree parameter_packs
= NULL_TREE
;
3902 bool for_types
= false;
3903 struct find_parameter_pack_data ppd
;
3905 if (!arg
|| arg
== error_mark_node
)
3908 if (TREE_CODE (arg
) == TREE_LIST
&& TREE_PURPOSE (arg
))
3910 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3911 class initializer. In this case, the TREE_PURPOSE will be a
3912 _TYPE node (representing the base class expansion we're
3913 initializing) and the TREE_VALUE will be a TREE_LIST
3914 containing the initialization arguments.
3916 The resulting expansion looks somewhat different from most
3917 expansions. Rather than returning just one _EXPANSION, we
3918 return a TREE_LIST whose TREE_PURPOSE is a
3919 TYPE_PACK_EXPANSION containing the bases that will be
3920 initialized. The TREE_VALUE will be identical to the
3921 original TREE_VALUE, which is a list of arguments that will
3922 be passed to each base. We do not introduce any new pack
3923 expansion nodes into the TREE_VALUE (although it is possible
3924 that some already exist), because the TREE_PURPOSE and
3925 TREE_VALUE all need to be expanded together with the same
3926 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3927 resulting TREE_PURPOSE will mention the parameter packs in
3928 both the bases and the arguments to the bases. */
3931 tree parameter_packs
= NULL_TREE
;
3933 /* Determine which parameter packs will be used by the base
3935 ppd
.visited
= new hash_set
<tree
>;
3936 ppd
.parameter_packs
= ¶meter_packs
;
3937 ppd
.type_pack_expansion_p
= false;
3938 gcc_assert (TYPE_P (TREE_PURPOSE (arg
)));
3939 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3942 if (parameter_packs
== NULL_TREE
)
3944 if (complain
& tf_error
)
3945 error ("base initializer expansion %qT contains no parameter packs",
3948 return error_mark_node
;
3951 if (TREE_VALUE (arg
) != void_type_node
)
3953 /* Collect the sets of parameter packs used in each of the
3954 initialization arguments. */
3955 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3957 /* Determine which parameter packs will be expanded in this
3959 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3966 /* Create the pack expansion type for the base type. */
3967 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3968 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3969 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3970 PACK_EXPANSION_LOCAL_P (purpose
) = at_function_scope_p ();
3972 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3973 they will rarely be compared to anything. */
3974 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3976 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3979 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3982 /* Build the PACK_EXPANSION_* node. */
3984 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3985 : make_node (EXPR_PACK_EXPANSION
);
3986 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3987 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3989 /* Propagate type and const-expression information. */
3990 TREE_TYPE (result
) = TREE_TYPE (arg
);
3991 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3992 /* Mark this read now, since the expansion might be length 0. */
3993 mark_exp_read (arg
);
3996 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3997 they will rarely be compared to anything. */
3998 SET_TYPE_STRUCTURAL_EQUALITY (result
);
4000 /* Determine which parameter packs will be expanded. */
4001 ppd
.parameter_packs
= ¶meter_packs
;
4002 ppd
.visited
= new hash_set
<tree
>;
4003 ppd
.type_pack_expansion_p
= TYPE_P (arg
);
4004 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
4007 /* Make sure we found some parameter packs. */
4008 if (parameter_packs
== NULL_TREE
)
4010 if (complain
& tf_error
)
4013 error ("expansion pattern %qT contains no parameter packs", arg
);
4015 error ("expansion pattern %qE contains no parameter packs", arg
);
4017 return error_mark_node
;
4019 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
4021 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
4026 /* Checks T for any "bare" parameter packs, which have not yet been
4027 expanded, and issues an error if any are found. This operation can
4028 only be done on full expressions or types (e.g., an expression
4029 statement, "if" condition, etc.), because we could have expressions like:
4031 foo(f(g(h(args)))...)
4033 where "args" is a parameter pack. check_for_bare_parameter_packs
4034 should not be called for the subexpressions args, h(args),
4035 g(h(args)), or f(g(h(args))), because we would produce erroneous
4038 Returns TRUE and emits an error if there were bare parameter packs,
4039 returns FALSE otherwise. */
4041 check_for_bare_parameter_packs (tree t
, location_t loc
/* = UNKNOWN_LOCATION */)
4043 tree parameter_packs
= NULL_TREE
;
4044 struct find_parameter_pack_data ppd
;
4046 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
4049 /* A lambda might use a parameter pack from the containing context. */
4050 if (current_class_type
&& LAMBDA_TYPE_P (current_class_type
)
4051 && CLASSTYPE_TEMPLATE_INFO (current_class_type
))
4054 if (TREE_CODE (t
) == TYPE_DECL
)
4057 ppd
.parameter_packs
= ¶meter_packs
;
4058 ppd
.visited
= new hash_set
<tree
>;
4059 ppd
.type_pack_expansion_p
= false;
4060 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
4063 if (parameter_packs
)
4065 if (loc
== UNKNOWN_LOCATION
)
4066 loc
= cp_expr_loc_or_loc (t
, input_location
);
4067 error_at (loc
, "parameter packs not expanded with %<...%>:");
4068 while (parameter_packs
)
4070 tree pack
= TREE_VALUE (parameter_packs
);
4071 tree name
= NULL_TREE
;
4073 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
4074 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
4075 name
= TYPE_NAME (pack
);
4076 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
4077 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
4078 else if (TREE_CODE (pack
) == CALL_EXPR
)
4079 name
= DECL_NAME (CALL_EXPR_FN (pack
));
4081 name
= DECL_NAME (pack
);
4084 inform (loc
, " %qD", name
);
4086 inform (loc
, " %s", "<anonymous>");
4088 parameter_packs
= TREE_CHAIN (parameter_packs
);
4097 /* Expand any parameter packs that occur in the template arguments in
4100 expand_template_argument_pack (tree args
)
4102 if (args
== error_mark_node
)
4103 return error_mark_node
;
4105 tree result_args
= NULL_TREE
;
4106 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
4107 int num_result_args
= -1;
4108 int non_default_args_count
= -1;
4110 /* First, determine if we need to expand anything, and the number of
4111 slots we'll need. */
4112 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
4114 tree arg
= TREE_VEC_ELT (args
, in_arg
);
4115 if (arg
== NULL_TREE
)
4117 if (ARGUMENT_PACK_P (arg
))
4119 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
4120 if (num_result_args
< 0)
4121 num_result_args
= in_arg
+ num_packed
;
4123 num_result_args
+= num_packed
;
4127 if (num_result_args
>= 0)
4132 /* If no expansion is necessary, we're done. */
4133 if (num_result_args
< 0)
4136 /* Expand arguments. */
4137 result_args
= make_tree_vec (num_result_args
);
4138 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
4139 non_default_args_count
=
4140 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
4141 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
4143 tree arg
= TREE_VEC_ELT (args
, in_arg
);
4144 if (ARGUMENT_PACK_P (arg
))
4146 tree packed
= ARGUMENT_PACK_ARGS (arg
);
4147 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
4148 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
4149 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
4150 if (non_default_args_count
> 0)
4151 non_default_args_count
+= num_packed
- 1;
4155 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
4159 if (non_default_args_count
>= 0)
4160 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
4164 /* Checks if DECL shadows a template parameter.
4166 [temp.local]: A template-parameter shall not be redeclared within its
4167 scope (including nested scopes).
4169 Emits an error and returns TRUE if the DECL shadows a parameter,
4170 returns FALSE otherwise. */
4173 check_template_shadow (tree decl
)
4177 /* If we're not in a template, we can't possibly shadow a template
4179 if (!current_template_parms
)
4182 /* Figure out what we're shadowing. */
4183 decl
= OVL_FIRST (decl
);
4184 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
4186 /* If there's no previous binding for this name, we're not shadowing
4187 anything, let alone a template parameter. */
4191 /* If we're not shadowing a template parameter, we're done. Note
4192 that OLDDECL might be an OVERLOAD (or perhaps even an
4193 ERROR_MARK), so we can't just blithely assume it to be a _DECL
4195 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
4198 /* We check for decl != olddecl to avoid bogus errors for using a
4199 name inside a class. We check TPFI to avoid duplicate errors for
4200 inline member templates. */
4202 || (DECL_TEMPLATE_PARM_P (decl
)
4203 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
4206 /* Don't complain about the injected class name, as we've already
4207 complained about the class itself. */
4208 if (DECL_SELF_REFERENCE_P (decl
))
4211 if (DECL_TEMPLATE_PARM_P (decl
))
4212 error ("declaration of template parameter %q+D shadows "
4213 "template parameter", decl
);
4215 error ("declaration of %q+#D shadows template parameter", decl
);
4216 inform (DECL_SOURCE_LOCATION (olddecl
),
4217 "template parameter %qD declared here", olddecl
);
4221 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
4222 ORIG_LEVEL, DECL, and TYPE. */
4225 build_template_parm_index (int index
,
4231 tree t
= make_node (TEMPLATE_PARM_INDEX
);
4232 TEMPLATE_PARM_IDX (t
) = index
;
4233 TEMPLATE_PARM_LEVEL (t
) = level
;
4234 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
4235 TEMPLATE_PARM_DECL (t
) = decl
;
4236 TREE_TYPE (t
) = type
;
4237 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
4238 TREE_READONLY (t
) = TREE_READONLY (decl
);
4243 /* Find the canonical type parameter for the given template type
4244 parameter. Returns the canonical type parameter, which may be TYPE
4245 if no such parameter existed. */
4248 canonical_type_parameter (tree type
)
4251 int idx
= TEMPLATE_TYPE_IDX (type
);
4252 if (!canonical_template_parms
)
4253 vec_alloc (canonical_template_parms
, idx
+ 1);
4255 if (canonical_template_parms
->length () <= (unsigned) idx
)
4256 vec_safe_grow_cleared (canonical_template_parms
, idx
+ 1);
4258 list
= (*canonical_template_parms
)[idx
];
4259 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
4260 list
= TREE_CHAIN (list
);
4263 return TREE_VALUE (list
);
4266 (*canonical_template_parms
)[idx
]
4267 = tree_cons (NULL_TREE
, type
, (*canonical_template_parms
)[idx
]);
4272 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
4273 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
4274 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
4275 new one is created. */
4278 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
4279 tsubst_flags_t complain
)
4281 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
4282 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
4283 != TEMPLATE_PARM_LEVEL (index
) - levels
)
4284 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
4286 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
4289 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
4290 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
4291 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
4292 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
4293 DECL_ARTIFICIAL (decl
) = 1;
4294 SET_DECL_TEMPLATE_PARM_P (decl
);
4296 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
4297 TEMPLATE_PARM_LEVEL (index
) - levels
,
4298 TEMPLATE_PARM_ORIG_LEVEL (index
),
4300 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
4301 TEMPLATE_PARM_PARAMETER_PACK (t
)
4302 = TEMPLATE_PARM_PARAMETER_PACK (index
);
4304 /* Template template parameters need this. */
4305 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4307 DECL_TEMPLATE_RESULT (decl
)
4308 = build_decl (DECL_SOURCE_LOCATION (decl
),
4309 TYPE_DECL
, DECL_NAME (decl
), type
);
4310 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (decl
)) = true;
4311 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
4312 (DECL_TEMPLATE_PARMS (orig_decl
), args
, complain
);
4316 return TEMPLATE_PARM_DESCENDANTS (index
);
4319 /* Process information from new template parameter PARM and append it
4320 to the LIST being built. This new parameter is a non-type
4321 parameter iff IS_NON_TYPE is true. This new parameter is a
4322 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4326 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
4327 bool is_non_type
, bool is_parameter_pack
)
4332 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
4333 tree defval
= TREE_PURPOSE (parm
);
4334 tree constr
= TREE_TYPE (parm
);
4338 tree p
= tree_last (list
);
4340 if (p
&& TREE_VALUE (p
) != error_mark_node
)
4343 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
4344 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
4346 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
4354 parm
= TREE_VALUE (parm
);
4356 SET_DECL_TEMPLATE_PARM_P (parm
);
4358 if (TREE_TYPE (parm
) != error_mark_node
)
4362 The top-level cv-qualifiers on the template-parameter are
4363 ignored when determining its type. */
4364 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
4365 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
4366 TREE_TYPE (parm
) = error_mark_node
;
4367 else if (uses_parameter_packs (TREE_TYPE (parm
))
4368 && !is_parameter_pack
4369 /* If we're in a nested template parameter list, the template
4370 template parameter could be a parameter pack. */
4371 && processing_template_parmlist
== 1)
4373 /* This template parameter is not a parameter pack, but it
4374 should be. Complain about "bare" parameter packs. */
4375 check_for_bare_parameter_packs (TREE_TYPE (parm
));
4377 /* Recover by calling this a parameter pack. */
4378 is_parameter_pack
= true;
4382 /* A template parameter is not modifiable. */
4383 TREE_CONSTANT (parm
) = 1;
4384 TREE_READONLY (parm
) = 1;
4385 decl
= build_decl (parm_loc
,
4386 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
4387 TREE_CONSTANT (decl
) = 1;
4388 TREE_READONLY (decl
) = 1;
4389 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
4390 = build_template_parm_index (idx
, processing_template_decl
,
4391 processing_template_decl
,
4392 decl
, TREE_TYPE (parm
));
4394 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
4395 = is_parameter_pack
;
4400 parm
= TREE_VALUE (TREE_VALUE (parm
));
4402 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
4404 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
4405 /* This is for distinguishing between real templates and template
4406 template parameters */
4407 TREE_TYPE (parm
) = t
;
4408 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
4413 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
4414 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4415 decl
= build_decl (parm_loc
,
4416 TYPE_DECL
, parm
, t
);
4419 TYPE_NAME (t
) = decl
;
4420 TYPE_STUB_DECL (t
) = decl
;
4422 TEMPLATE_TYPE_PARM_INDEX (t
)
4423 = build_template_parm_index (idx
, processing_template_decl
,
4424 processing_template_decl
,
4425 decl
, TREE_TYPE (parm
));
4426 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
4427 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
4429 DECL_ARTIFICIAL (decl
) = 1;
4430 SET_DECL_TEMPLATE_PARM_P (decl
);
4432 /* Build requirements for the type/template parameter.
4433 This must be done after SET_DECL_TEMPLATE_PARM_P or
4434 process_template_parm could fail. */
4435 tree reqs
= finish_shorthand_constraint (parm
, constr
);
4437 decl
= pushdecl (decl
);
4441 /* Build the parameter node linking the parameter declaration,
4442 its default argument (if any), and its constraints (if any). */
4443 parm
= build_tree_list (defval
, parm
);
4444 TEMPLATE_PARM_CONSTRAINTS (parm
) = reqs
;
4446 return chainon (list
, parm
);
4449 /* The end of a template parameter list has been reached. Process the
4450 tree list into a parameter vector, converting each parameter into a more
4451 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4455 end_template_parm_list (tree parms
)
4459 tree saved_parmlist
= make_tree_vec (list_length (parms
));
4461 /* Pop the dummy parameter level and add the real one. */
4462 current_template_parms
= TREE_CHAIN (current_template_parms
);
4464 current_template_parms
4465 = tree_cons (size_int (processing_template_decl
),
4466 saved_parmlist
, current_template_parms
);
4468 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
4470 next
= TREE_CHAIN (parm
);
4471 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
4472 TREE_CHAIN (parm
) = NULL_TREE
;
4475 --processing_template_parmlist
;
4477 return saved_parmlist
;
4480 // Explicitly indicate the end of the template parameter list. We assume
4481 // that the current template parameters have been constructed and/or
4482 // managed explicitly, as when creating new template template parameters
4483 // from a shorthand constraint.
4485 end_template_parm_list ()
4487 --processing_template_parmlist
;
4490 /* end_template_decl is called after a template declaration is seen. */
4493 end_template_decl (void)
4495 reset_specialization ();
4497 if (! processing_template_decl
)
4500 /* This matches the pushlevel in begin_template_parm_list. */
4503 --processing_template_decl
;
4504 current_template_parms
= TREE_CHAIN (current_template_parms
);
4507 /* Takes a TREE_LIST representing a template parameter and convert it
4508 into an argument suitable to be passed to the type substitution
4509 functions. Note that If the TREE_LIST contains an error_mark
4510 node, the returned argument is error_mark_node. */
4513 template_parm_to_arg (tree t
)
4517 || TREE_CODE (t
) != TREE_LIST
)
4520 if (error_operand_p (TREE_VALUE (t
)))
4521 return error_mark_node
;
4525 if (TREE_CODE (t
) == TYPE_DECL
4526 || TREE_CODE (t
) == TEMPLATE_DECL
)
4530 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
4532 /* Turn this argument into a TYPE_ARGUMENT_PACK
4533 with a single element, which expands T. */
4534 tree vec
= make_tree_vec (1);
4536 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4538 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4540 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
4541 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4546 t
= DECL_INITIAL (t
);
4548 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
4550 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4551 with a single element, which expands T. */
4552 tree vec
= make_tree_vec (1);
4554 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4556 t
= convert_from_reference (t
);
4557 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4559 t
= make_node (NONTYPE_ARGUMENT_PACK
);
4560 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4563 t
= convert_from_reference (t
);
4568 /* Given a single level of template parameters (a TREE_VEC), return it
4569 as a set of template arguments. */
4572 template_parms_level_to_args (tree parms
)
4574 tree a
= copy_node (parms
);
4575 TREE_TYPE (a
) = NULL_TREE
;
4576 for (int i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
4577 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
4580 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
4585 /* Given a set of template parameters, return them as a set of template
4586 arguments. The template parameters are represented as a TREE_VEC, in
4587 the form documented in cp-tree.h for template arguments. */
4590 template_parms_to_args (tree parms
)
4593 tree args
= NULL_TREE
;
4594 int length
= TMPL_PARMS_DEPTH (parms
);
4597 /* If there is only one level of template parameters, we do not
4598 create a TREE_VEC of TREE_VECs. Instead, we return a single
4599 TREE_VEC containing the arguments. */
4601 args
= make_tree_vec (length
);
4603 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
4605 tree a
= template_parms_level_to_args (TREE_VALUE (header
));
4608 TREE_VEC_ELT (args
, --l
) = a
;
4616 /* Within the declaration of a template, return the currently active
4617 template parameters as an argument TREE_VEC. */
4620 current_template_args (void)
4622 return template_parms_to_args (current_template_parms
);
4625 /* Update the declared TYPE by doing any lookups which were thought to be
4626 dependent, but are not now that we know the SCOPE of the declarator. */
4629 maybe_update_decl_type (tree orig_type
, tree scope
)
4631 tree type
= orig_type
;
4633 if (type
== NULL_TREE
)
4636 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4637 type
= TREE_TYPE (type
);
4639 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
4640 && dependent_type_p (type
)
4641 /* Don't bother building up the args in this case. */
4642 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
4644 /* tsubst in the args corresponding to the template parameters,
4645 including auto if present. Most things will be unchanged, but
4646 make_typename_type and tsubst_qualified_id will resolve
4647 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4648 tree args
= current_template_args ();
4649 tree auto_node
= type_uses_auto (type
);
4653 tree auto_vec
= make_tree_vec (1);
4654 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4655 args
= add_to_template_args (args
, auto_vec
);
4657 pushed
= push_scope (scope
);
4658 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4663 if (type
== error_mark_node
)
4666 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4668 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4671 type
= TYPE_NAME (type
);
4676 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4677 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4678 the new template is a member template. */
4681 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4683 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4684 SET_DECL_LANGUAGE (tmpl
, DECL_LANGUAGE (decl
));
4685 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4686 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4687 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4688 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4693 struct template_parm_data
4695 /* The level of the template parameters we are currently
4699 /* The index of the specialization argument we are currently
4703 /* An array whose size is the number of template parameters. The
4704 elements are nonzero if the parameter has been used in any one
4705 of the arguments processed so far. */
4708 /* An array whose size is the number of template arguments. The
4709 elements are nonzero if the argument makes use of template
4710 parameters of this level. */
4711 int* arg_uses_template_parms
;
4714 /* Subroutine of push_template_decl used to see if each template
4715 parameter in a partial specialization is used in the explicit
4716 argument list. If T is of the LEVEL given in DATA (which is
4717 treated as a template_parm_data*), then DATA->PARMS is marked
4721 mark_template_parm (tree t
, void* data
)
4725 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4727 template_parm_level_and_index (t
, &level
, &idx
);
4729 if (level
== tpd
->level
)
4731 tpd
->parms
[idx
] = 1;
4732 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4735 /* In C++17 the type of a non-type argument is a deduced context. */
4736 if (cxx_dialect
>= cxx17
4737 && TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4738 for_each_template_parm (TREE_TYPE (t
),
4739 &mark_template_parm
,
4742 /*include_nondeduced_p=*/false);
4744 /* Return zero so that for_each_template_parm will continue the
4745 traversal of the tree; we want to mark *every* template parm. */
4749 /* Process the partial specialization DECL. */
4752 process_partial_specialization (tree decl
)
4754 tree type
= TREE_TYPE (decl
);
4755 tree tinfo
= get_template_info (decl
);
4756 tree maintmpl
= TI_TEMPLATE (tinfo
);
4757 tree specargs
= TI_ARGS (tinfo
);
4758 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4759 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4762 int nargs
= TREE_VEC_LENGTH (inner_args
);
4765 bool did_error_intro
= false;
4766 struct template_parm_data tpd
;
4767 struct template_parm_data tpd2
;
4769 gcc_assert (current_template_parms
);
4771 /* A concept cannot be specialized. */
4772 if (flag_concepts
&& variable_concept_p (maintmpl
))
4774 error ("specialization of variable concept %q#D", maintmpl
);
4775 return error_mark_node
;
4778 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4779 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4781 /* We check that each of the template parameters given in the
4782 partial specialization is used in the argument list to the
4783 specialization. For example:
4785 template <class T> struct S;
4786 template <class T> struct S<T*>;
4788 The second declaration is OK because `T*' uses the template
4789 parameter T, whereas
4791 template <class T> struct S<int>;
4793 is no good. Even trickier is:
4804 The S2<T> declaration is actually invalid; it is a
4805 full-specialization. Of course,
4808 struct S2<T (*)(U)>;
4810 or some such would have been OK. */
4811 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4812 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4813 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4815 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4816 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4817 for (i
= 0; i
< nargs
; ++i
)
4819 tpd
.current_arg
= i
;
4820 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4821 &mark_template_parm
,
4824 /*include_nondeduced_p=*/false);
4826 for (i
= 0; i
< ntparms
; ++i
)
4827 if (tpd
.parms
[i
] == 0)
4829 /* One of the template parms was not used in a deduced context in the
4831 if (!did_error_intro
)
4833 error ("template parameters not deducible in "
4834 "partial specialization:");
4835 did_error_intro
= true;
4838 inform (input_location
, " %qD",
4839 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4842 if (did_error_intro
)
4843 return error_mark_node
;
4845 /* [temp.class.spec]
4847 The argument list of the specialization shall not be identical to
4848 the implicit argument list of the primary template. */
4850 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl
)));
4851 if (comp_template_args (inner_args
, INNERMOST_TEMPLATE_ARGS (main_args
))
4853 || !strictly_subsumes (current_template_constraints (),
4854 get_constraints (maintmpl
))))
4857 error ("partial specialization %q+D does not specialize "
4858 "any template arguments; to define the primary template, "
4859 "remove the template argument list", decl
);
4861 error ("partial specialization %q+D does not specialize any "
4862 "template arguments and is not more constrained than "
4863 "the primary template; to define the primary template, "
4864 "remove the template argument list", decl
);
4865 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4868 /* A partial specialization that replaces multiple parameters of the
4869 primary template with a pack expansion is less specialized for those
4871 if (nargs
< DECL_NTPARMS (maintmpl
))
4873 error ("partial specialization is not more specialized than the "
4874 "primary template because it replaces multiple parameters "
4875 "with a pack expansion");
4876 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4877 /* Avoid crash in process_partial_specialization. */
4881 /* If we aren't in a dependent class, we can actually try deduction. */
4882 else if (tpd
.level
== 1
4883 /* FIXME we should be able to handle a partial specialization of a
4884 partial instantiation, but currently we can't (c++/41727). */
4885 && TMPL_ARGS_DEPTH (specargs
) == 1
4886 && !get_partial_spec_bindings (maintmpl
, maintmpl
, specargs
))
4888 auto_diagnostic_group d
;
4889 if (permerror (input_location
, "partial specialization %qD is not "
4890 "more specialized than", decl
))
4891 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template %qD",
4895 /* [temp.class.spec]
4897 A partially specialized non-type argument expression shall not
4898 involve template parameters of the partial specialization except
4899 when the argument expression is a simple identifier.
4901 The type of a template parameter corresponding to a specialized
4902 non-type argument shall not be dependent on a parameter of the
4905 Also, we verify that pack expansions only occur at the
4906 end of the argument list. */
4907 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4909 for (i
= 0; i
< nargs
; ++i
)
4911 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4912 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4913 tree packed_args
= NULL_TREE
;
4916 if (ARGUMENT_PACK_P (arg
))
4918 /* Extract the arguments from the argument pack. We'll be
4919 iterating over these in the following loop. */
4920 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4921 len
= TREE_VEC_LENGTH (packed_args
);
4924 for (j
= 0; j
< len
; j
++)
4927 /* Get the Jth argument in the parameter pack. */
4928 arg
= TREE_VEC_ELT (packed_args
, j
);
4930 if (PACK_EXPANSION_P (arg
))
4932 /* Pack expansions must come at the end of the
4934 if ((packed_args
&& j
< len
- 1)
4935 || (!packed_args
&& i
< nargs
- 1))
4937 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4938 error ("parameter pack argument %qE must be at the "
4939 "end of the template argument list", arg
);
4941 error ("parameter pack argument %qT must be at the "
4942 "end of the template argument list", arg
);
4946 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4947 /* We only care about the pattern. */
4948 arg
= PACK_EXPANSION_PATTERN (arg
);
4950 if (/* These first two lines are the `non-type' bit. */
4952 && TREE_CODE (arg
) != TEMPLATE_DECL
4953 /* This next two lines are the `argument expression is not just a
4954 simple identifier' condition and also the `specialized
4955 non-type argument' bit. */
4956 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4957 && !(REFERENCE_REF_P (arg
)
4958 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4960 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4961 || (packed_args
&& uses_template_parms (arg
)))
4962 error ("template argument %qE involves template parameter(s)",
4966 /* Look at the corresponding template parameter,
4967 marking which template parameters its type depends
4969 tree type
= TREE_TYPE (parm
);
4973 /* We haven't yet initialized TPD2. Do so now. */
4974 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4975 /* The number of parameters here is the number in the
4976 main template, which, as checked in the assertion
4978 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4980 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4983 /* Mark the template parameters. But this time, we're
4984 looking for the template parameters of the main
4985 template, not in the specialization. */
4986 tpd2
.current_arg
= i
;
4987 tpd2
.arg_uses_template_parms
[i
] = 0;
4988 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4989 for_each_template_parm (type
,
4990 &mark_template_parm
,
4993 /*include_nondeduced_p=*/false);
4995 if (tpd2
.arg_uses_template_parms
[i
])
4997 /* The type depended on some template parameters.
4998 If they are fully specialized in the
4999 specialization, that's OK. */
5002 for (j
= 0; j
< nargs
; ++j
)
5003 if (tpd2
.parms
[j
] != 0
5004 && tpd
.arg_uses_template_parms
[j
])
5007 error_n (input_location
, count
,
5008 "type %qT of template argument %qE depends "
5009 "on a template parameter",
5010 "type %qT of template argument %qE depends "
5011 "on template parameters",
5020 /* We should only get here once. */
5021 if (TREE_CODE (decl
) == TYPE_DECL
)
5022 gcc_assert (!COMPLETE_TYPE_P (type
));
5024 // Build the template decl.
5025 tree tmpl
= build_template_decl (decl
, current_template_parms
,
5026 DECL_MEMBER_TEMPLATE_P (maintmpl
));
5027 TREE_TYPE (tmpl
) = type
;
5028 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5029 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5030 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
5031 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
5033 /* Give template template parms a DECL_CONTEXT of the template
5034 for which they are a parameter. */
5035 for (i
= 0; i
< ntparms
; ++i
)
5037 tree parm
= TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
));
5038 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5039 DECL_CONTEXT (parm
) = tmpl
;
5043 /* We didn't register this in check_explicit_specialization so we could
5044 wait until the constraints were set. */
5045 decl
= register_specialization (decl
, maintmpl
, specargs
, false, 0);
5047 associate_classtype_constraints (type
);
5049 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
5050 = tree_cons (specargs
, tmpl
,
5051 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
5052 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
5054 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
5055 inst
= TREE_CHAIN (inst
))
5057 tree instance
= TREE_VALUE (inst
);
5058 if (TYPE_P (instance
)
5059 ? (COMPLETE_TYPE_P (instance
)
5060 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance
))
5061 : DECL_TEMPLATE_INSTANTIATION (instance
))
5063 tree spec
= most_specialized_partial_spec (instance
, tf_none
);
5064 tree inst_decl
= (DECL_P (instance
)
5065 ? instance
: TYPE_NAME (instance
));
5068 else if (spec
== error_mark_node
)
5069 permerror (input_location
,
5070 "declaration of %qD ambiguates earlier template "
5071 "instantiation for %qD", decl
, inst_decl
);
5072 else if (TREE_VALUE (spec
) == tmpl
)
5073 permerror (input_location
,
5074 "partial specialization of %qD after instantiation "
5075 "of %qD", decl
, inst_decl
);
5082 /* PARM is a template parameter of some form; return the corresponding
5083 TEMPLATE_PARM_INDEX. */
5086 get_template_parm_index (tree parm
)
5088 if (TREE_CODE (parm
) == PARM_DECL
5089 || TREE_CODE (parm
) == CONST_DECL
)
5090 parm
= DECL_INITIAL (parm
);
5091 else if (TREE_CODE (parm
) == TYPE_DECL
5092 || TREE_CODE (parm
) == TEMPLATE_DECL
)
5093 parm
= TREE_TYPE (parm
);
5094 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
5095 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
5096 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
5097 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
5098 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
5102 /* Subroutine of fixed_parameter_pack_p below. Look for any template
5103 parameter packs used by the template parameter PARM. */
5106 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
5108 /* A type parm can't refer to another parm. */
5109 if (TREE_CODE (parm
) == TYPE_DECL
|| parm
== error_mark_node
)
5111 else if (TREE_CODE (parm
) == PARM_DECL
)
5113 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
5118 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
5120 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
5121 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
5123 tree p
= TREE_VALUE (TREE_VEC_ELT (vec
, i
));
5124 if (template_parameter_pack_p (p
))
5125 /* Any packs in the type are expanded by this parameter. */;
5127 fixed_parameter_pack_p_1 (p
, ppd
);
5131 /* PARM is a template parameter pack. Return any parameter packs used in
5132 its type or the type of any of its template parameters. If there are
5133 any such packs, it will be instantiated into a fixed template parameter
5134 list by partial instantiation rather than be fully deduced. */
5137 fixed_parameter_pack_p (tree parm
)
5139 /* This can only be true in a member template. */
5140 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
5142 /* This can only be true for a parameter pack. */
5143 if (!template_parameter_pack_p (parm
))
5145 /* A type parm can't refer to another parm. */
5146 if (TREE_CODE (parm
) == TYPE_DECL
)
5149 tree parameter_packs
= NULL_TREE
;
5150 struct find_parameter_pack_data ppd
;
5151 ppd
.parameter_packs
= ¶meter_packs
;
5152 ppd
.visited
= new hash_set
<tree
>;
5153 ppd
.type_pack_expansion_p
= false;
5155 fixed_parameter_pack_p_1 (parm
, &ppd
);
5158 return parameter_packs
;
5161 /* Check that a template declaration's use of default arguments and
5162 parameter packs is not invalid. Here, PARMS are the template
5163 parameters. IS_PRIMARY is true if DECL is the thing declared by
5164 a primary template. IS_PARTIAL is true if DECL is a partial
5167 IS_FRIEND_DECL is nonzero if DECL is either a non-defining friend
5168 function template declaration or a friend class template
5169 declaration. In the function case, 1 indicates a declaration, 2
5170 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
5171 emitted for extraneous default arguments.
5173 Returns TRUE if there were no errors found, FALSE otherwise. */
5176 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
5177 bool is_partial
, int is_friend_decl
)
5180 int last_level_to_check
;
5182 bool no_errors
= true;
5186 A default template-argument shall not be specified in a
5187 function template declaration or a function template definition, nor
5188 in the template-parameter-list of the definition of a member of a
5191 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
5192 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
5193 /* You can't have a function template declaration in a local
5194 scope, nor you can you define a member of a class template in a
5198 if ((TREE_CODE (decl
) == TYPE_DECL
5200 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5201 || (TREE_CODE (decl
) == FUNCTION_DECL
5202 && LAMBDA_FUNCTION_P (decl
)))
5203 /* A lambda doesn't have an explicit declaration; don't complain
5204 about the parms of the enclosing class. */
5207 if (current_class_type
5208 && !TYPE_BEING_DEFINED (current_class_type
)
5209 && DECL_LANG_SPECIFIC (decl
)
5210 && DECL_DECLARES_FUNCTION_P (decl
)
5211 /* If this is either a friend defined in the scope of the class
5212 or a member function. */
5213 && (DECL_FUNCTION_MEMBER_P (decl
)
5214 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
5215 : DECL_FRIEND_CONTEXT (decl
)
5216 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
5218 /* And, if it was a member function, it really was defined in
5219 the scope of the class. */
5220 && (!DECL_FUNCTION_MEMBER_P (decl
)
5221 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
5222 /* We already checked these parameters when the template was
5223 declared, so there's no need to do it again now. This function
5224 was defined in class scope, but we're processing its body now
5225 that the class is complete. */
5228 /* Core issue 226 (C++0x only): the following only applies to class
5231 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
5235 If a template-parameter has a default template-argument, all
5236 subsequent template-parameters shall have a default
5237 template-argument supplied. */
5238 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
5240 tree inner_parms
= TREE_VALUE (parm_level
);
5241 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
5242 int seen_def_arg_p
= 0;
5245 for (i
= 0; i
< ntparms
; ++i
)
5247 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
5249 if (parm
== error_mark_node
)
5252 if (TREE_PURPOSE (parm
))
5254 else if (seen_def_arg_p
5255 && !template_parameter_pack_p (TREE_VALUE (parm
)))
5257 error ("no default argument for %qD", TREE_VALUE (parm
));
5258 /* For better subsequent error-recovery, we indicate that
5259 there should have been a default argument. */
5260 TREE_PURPOSE (parm
) = error_mark_node
;
5263 else if (!is_partial
5265 /* Don't complain about an enclosing partial
5267 && parm_level
== parms
5268 && TREE_CODE (decl
) == TYPE_DECL
5270 && template_parameter_pack_p (TREE_VALUE (parm
))
5271 /* A fixed parameter pack will be partially
5272 instantiated into a fixed length list. */
5273 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
5275 /* A primary class template can only have one
5276 parameter pack, at the end of the template
5279 error ("parameter pack %q+D must be at the end of the"
5280 " template parameter list", TREE_VALUE (parm
));
5282 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
5290 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
5294 /* For an ordinary class template, default template arguments are
5295 allowed at the innermost level, e.g.:
5296 template <class T = int>
5298 but, in a partial specialization, they're not allowed even
5299 there, as we have in [temp.class.spec]:
5301 The template parameter list of a specialization shall not
5302 contain default template argument values.
5304 So, for a partial specialization, or for a function template
5305 (in C++98/C++03), we look at all of them. */
5308 /* But, for a primary class template that is not a partial
5309 specialization we look at all template parameters except the
5311 parms
= TREE_CHAIN (parms
);
5313 /* Figure out what error message to issue. */
5314 if (is_friend_decl
== 2)
5315 msg
= G_("default template arguments may not be used in function template "
5316 "friend re-declaration");
5317 else if (is_friend_decl
)
5318 msg
= G_("default template arguments may not be used in template "
5319 "friend declarations");
5320 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
5321 msg
= G_("default template arguments may not be used in function templates "
5322 "without %<-std=c++11%> or %<-std=gnu++11%>");
5323 else if (is_partial
)
5324 msg
= G_("default template arguments may not be used in "
5325 "partial specializations");
5326 else if (current_class_type
&& CLASSTYPE_IS_TEMPLATE (current_class_type
))
5327 msg
= G_("default argument for template parameter for class enclosing %qD");
5329 /* Per [temp.param]/9, "A default template-argument shall not be
5330 specified in the template-parameter-lists of the definition of
5331 a member of a class template that appears outside of the member's
5332 class.", thus if we aren't handling a member of a class template
5333 there is no need to examine the parameters. */
5336 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
5337 /* If we're inside a class definition, there's no need to
5338 examine the parameters to the class itself. On the one
5339 hand, they will be checked when the class is defined, and,
5340 on the other, default arguments are valid in things like:
5341 template <class T = double>
5342 struct S { template <class U> void f(U); };
5343 Here the default argument for `S' has no bearing on the
5344 declaration of `f'. */
5345 last_level_to_check
= template_class_depth (current_class_type
) + 1;
5347 /* Check everything. */
5348 last_level_to_check
= 0;
5350 for (parm_level
= parms
;
5351 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
5352 parm_level
= TREE_CHAIN (parm_level
))
5354 tree inner_parms
= TREE_VALUE (parm_level
);
5358 ntparms
= TREE_VEC_LENGTH (inner_parms
);
5359 for (i
= 0; i
< ntparms
; ++i
)
5361 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
5364 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
5369 if (is_friend_decl
== 2)
5376 /* Clear out the default argument so that we are not
5378 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
5382 /* At this point, if we're still interested in issuing messages,
5383 they must apply to classes surrounding the object declared. */
5385 msg
= G_("default argument for template parameter for class "
5392 /* Worker for push_template_decl_real, called via
5393 for_each_template_parm. DATA is really an int, indicating the
5394 level of the parameters we are interested in. If T is a template
5395 parameter of that level, return nonzero. */
5398 template_parm_this_level_p (tree t
, void* data
)
5400 int this_level
= *(int *)data
;
5403 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5404 level
= TEMPLATE_PARM_LEVEL (t
);
5406 level
= TEMPLATE_TYPE_LEVEL (t
);
5407 return level
== this_level
;
5410 /* Worker for uses_outer_template_parms, called via for_each_template_parm.
5411 DATA is really an int, indicating the innermost outer level of parameters.
5412 If T is a template parameter of that level or further out, return
5416 template_parm_outer_level (tree t
, void *data
)
5418 int this_level
= *(int *)data
;
5421 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5422 level
= TEMPLATE_PARM_LEVEL (t
);
5424 level
= TEMPLATE_TYPE_LEVEL (t
);
5425 return level
<= this_level
;
5428 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5429 parameters given by current_template_args, or reuses a
5430 previously existing one, if appropriate. Returns the DECL, or an
5431 equivalent one, if it is replaced via a call to duplicate_decls.
5433 If IS_FRIEND is true, DECL is a friend declaration. */
5436 push_template_decl_real (tree decl
, bool is_friend
)
5444 int new_template_p
= 0;
5445 /* True if the template is a member template, in the sense of
5447 bool member_template_p
= false;
5449 if (decl
== error_mark_node
|| !current_template_parms
)
5450 return error_mark_node
;
5452 /* See if this is a partial specialization. */
5453 is_partial
= ((DECL_IMPLICIT_TYPEDEF_P (decl
)
5454 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
5455 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
5457 && DECL_LANG_SPECIFIC (decl
)
5458 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5459 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
))));
5461 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
5465 /* For a friend, we want the context of the friend, not
5466 the type of which it is a friend. */
5467 ctx
= CP_DECL_CONTEXT (decl
);
5468 else if (CP_DECL_CONTEXT (decl
)
5469 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
5470 /* In the case of a virtual function, we want the class in which
5472 ctx
= CP_DECL_CONTEXT (decl
);
5474 /* Otherwise, if we're currently defining some class, the DECL
5475 is assumed to be a member of the class. */
5476 ctx
= current_scope ();
5478 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5481 if (!DECL_CONTEXT (decl
))
5482 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
5484 /* See if this is a primary template. */
5485 if (is_friend
&& ctx
5486 && uses_template_parms_level (ctx
, processing_template_decl
))
5487 /* A friend template that specifies a class context, i.e.
5488 template <typename T> friend void A<T>::f();
5491 else if (TREE_CODE (decl
) == TYPE_DECL
5492 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5495 is_primary
= template_parm_scope_p ();
5499 warning (OPT_Wtemplates
, "template %qD declared", decl
);
5501 if (DECL_CLASS_SCOPE_P (decl
))
5502 member_template_p
= true;
5503 if (TREE_CODE (decl
) == TYPE_DECL
5504 && IDENTIFIER_ANON_P (DECL_NAME (decl
)))
5506 error ("template class without a name");
5507 return error_mark_node
;
5509 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
5511 if (member_template_p
)
5513 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
5514 error ("member template %qD may not have virt-specifiers", decl
);
5516 if (DECL_DESTRUCTOR_P (decl
))
5520 A destructor shall not be a member template. */
5521 error ("destructor %qD declared as member template", decl
);
5522 return error_mark_node
;
5524 if (IDENTIFIER_NEWDEL_OP_P (DECL_NAME (decl
))
5525 && (!prototype_p (TREE_TYPE (decl
))
5526 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
5527 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5528 || (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5529 == void_list_node
)))
5531 /* [basic.stc.dynamic.allocation]
5533 An allocation function can be a function
5534 template. ... Template allocation functions shall
5535 have two or more parameters. */
5536 error ("invalid template declaration of %qD", decl
);
5537 return error_mark_node
;
5540 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5541 && CLASS_TYPE_P (TREE_TYPE (decl
)))
5543 /* Class template, set TEMPLATE_TYPE_PARM_FOR_CLASS. */
5544 tree parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
5545 for (int i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
5547 tree t
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5548 if (TREE_CODE (t
) == TYPE_DECL
)
5550 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
5551 TEMPLATE_TYPE_PARM_FOR_CLASS (t
) = true;
5554 else if (TREE_CODE (decl
) == TYPE_DECL
5555 && TYPE_DECL_ALIAS_P (decl
))
5556 /* alias-declaration */
5557 gcc_assert (!DECL_ARTIFICIAL (decl
));
5558 else if (VAR_P (decl
))
5559 /* C++14 variable template. */;
5562 error ("template declaration of %q#D", decl
);
5563 return error_mark_node
;
5567 /* Check to see that the rules regarding the use of default
5568 arguments are not being violated. We check args for a friend
5569 functions when we know whether it's a definition, introducing
5570 declaration or re-declaration. */
5571 if (!is_friend
|| TREE_CODE (decl
) != FUNCTION_DECL
)
5572 check_default_tmpl_args (decl
, current_template_parms
,
5573 is_primary
, is_partial
, is_friend
);
5575 /* Ensure that there are no parameter packs in the type of this
5576 declaration that have not been expanded. */
5577 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5579 /* Check each of the arguments individually to see if there are
5580 any bare parameter packs. */
5581 tree type
= TREE_TYPE (decl
);
5582 tree arg
= DECL_ARGUMENTS (decl
);
5583 tree argtype
= TYPE_ARG_TYPES (type
);
5585 while (arg
&& argtype
)
5587 if (!DECL_PACK_P (arg
)
5588 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
5590 /* This is a PARM_DECL that contains unexpanded parameter
5591 packs. We have already complained about this in the
5592 check_for_bare_parameter_packs call, so just replace
5593 these types with ERROR_MARK_NODE. */
5594 TREE_TYPE (arg
) = error_mark_node
;
5595 TREE_VALUE (argtype
) = error_mark_node
;
5598 arg
= DECL_CHAIN (arg
);
5599 argtype
= TREE_CHAIN (argtype
);
5602 /* Check for bare parameter packs in the return type and the
5603 exception specifiers. */
5604 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
5605 /* Errors were already issued, set return type to int
5606 as the frontend doesn't expect error_mark_node as
5608 TREE_TYPE (type
) = integer_type_node
;
5609 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
5610 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
5612 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
5613 && TYPE_DECL_ALIAS_P (decl
))
5614 ? DECL_ORIGINAL_TYPE (decl
)
5615 : TREE_TYPE (decl
)))
5617 TREE_TYPE (decl
) = error_mark_node
;
5618 return error_mark_node
;
5622 return process_partial_specialization (decl
);
5624 args
= current_template_args ();
5627 || TREE_CODE (ctx
) == FUNCTION_DECL
5628 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
5629 || (TREE_CODE (decl
) == TYPE_DECL
5630 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5631 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
5633 if (DECL_LANG_SPECIFIC (decl
)
5634 && DECL_TEMPLATE_INFO (decl
)
5635 && DECL_TI_TEMPLATE (decl
))
5636 tmpl
= DECL_TI_TEMPLATE (decl
);
5637 /* If DECL is a TYPE_DECL for a class-template, then there won't
5638 be DECL_LANG_SPECIFIC. The information equivalent to
5639 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5640 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5641 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
5642 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
5644 /* Since a template declaration already existed for this
5645 class-type, we must be redeclaring it here. Make sure
5646 that the redeclaration is valid. */
5647 redeclare_class_template (TREE_TYPE (decl
),
5648 current_template_parms
,
5649 current_template_constraints ());
5650 /* We don't need to create a new TEMPLATE_DECL; just use the
5651 one we already had. */
5652 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
5656 tmpl
= build_template_decl (decl
, current_template_parms
,
5660 if (DECL_LANG_SPECIFIC (decl
)
5661 && DECL_TEMPLATE_SPECIALIZATION (decl
))
5663 /* A specialization of a member template of a template
5665 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5666 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
5667 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
5673 tree a
, t
, current
, parms
;
5675 tree tinfo
= get_template_info (decl
);
5679 error ("template definition of non-template %q#D", decl
);
5680 return error_mark_node
;
5683 tmpl
= TI_TEMPLATE (tinfo
);
5685 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
5686 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
5687 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5688 && DECL_MEMBER_TEMPLATE_P (tmpl
))
5692 /* The declaration is a specialization of a member
5693 template, declared outside the class. Therefore, the
5694 innermost template arguments will be NULL, so we
5695 replace them with the arguments determined by the
5696 earlier call to check_explicit_specialization. */
5697 args
= DECL_TI_ARGS (decl
);
5700 = build_template_decl (decl
, current_template_parms
,
5702 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
5703 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
5704 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
5705 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
5706 DECL_TEMPLATE_INFO (new_tmpl
)
5707 = build_template_info (tmpl
, args
);
5709 register_specialization (new_tmpl
,
5710 most_general_template (tmpl
),
5716 /* Make sure the template headers we got make sense. */
5718 parms
= DECL_TEMPLATE_PARMS (tmpl
);
5719 i
= TMPL_PARMS_DEPTH (parms
);
5720 if (TMPL_ARGS_DEPTH (args
) != i
)
5722 error ("expected %d levels of template parms for %q#D, got %d",
5723 i
, decl
, TMPL_ARGS_DEPTH (args
));
5724 DECL_INTERFACE_KNOWN (decl
) = 1;
5725 return error_mark_node
;
5728 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
5730 a
= TMPL_ARGS_LEVEL (args
, i
);
5731 t
= INNERMOST_TEMPLATE_PARMS (parms
);
5733 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
5735 if (current
== decl
)
5736 error ("got %d template parameters for %q#D",
5737 TREE_VEC_LENGTH (a
), decl
);
5739 error ("got %d template parameters for %q#T",
5740 TREE_VEC_LENGTH (a
), current
);
5741 error (" but %d required", TREE_VEC_LENGTH (t
));
5742 /* Avoid crash in import_export_decl. */
5743 DECL_INTERFACE_KNOWN (decl
) = 1;
5744 return error_mark_node
;
5747 if (current
== decl
)
5749 else if (current
== NULL_TREE
)
5750 /* Can happen in erroneous input. */
5753 current
= get_containing_scope (current
);
5756 /* Check that the parms are used in the appropriate qualifying scopes
5757 in the declarator. */
5758 if (!comp_template_args
5760 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
5762 error ("template arguments to %qD do not match original "
5763 "template %qD", decl
, DECL_TEMPLATE_RESULT (tmpl
));
5764 if (!uses_template_parms (TI_ARGS (tinfo
)))
5765 inform (input_location
, "use %<template<>%> for"
5766 " an explicit specialization");
5767 /* Avoid crash in import_export_decl. */
5768 DECL_INTERFACE_KNOWN (decl
) = 1;
5769 return error_mark_node
;
5773 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5774 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5776 /* Push template declarations for global functions and types. Note
5777 that we do not try to push a global template friend declared in a
5778 template class; such a thing may well depend on the template
5779 parameters of the class. */
5780 if (new_template_p
&& !ctx
5781 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5783 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5784 if (tmpl
== error_mark_node
)
5785 return error_mark_node
;
5787 /* Hide template friend classes that haven't been declared yet. */
5788 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5790 DECL_ANTICIPATED (tmpl
) = 1;
5791 DECL_FRIEND_P (tmpl
) = 1;
5797 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5799 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5801 /* Give template template parms a DECL_CONTEXT of the template
5802 for which they are a parameter. */
5803 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5804 for (int i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5806 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5807 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5808 DECL_CONTEXT (parm
) = tmpl
;
5811 if (TREE_CODE (decl
) == TYPE_DECL
5812 && TYPE_DECL_ALIAS_P (decl
)
5813 && complex_alias_template_p (tmpl
))
5814 TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl
) = true;
5817 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5818 back to its most general template. If TMPL is a specialization,
5819 ARGS may only have the innermost set of arguments. Add the missing
5820 argument levels if necessary. */
5821 if (DECL_TEMPLATE_INFO (tmpl
))
5822 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5824 info
= build_template_info (tmpl
, args
);
5826 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5827 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5831 retrofit_lang_decl (decl
);
5832 if (DECL_LANG_SPECIFIC (decl
))
5833 DECL_TEMPLATE_INFO (decl
) = info
;
5836 if (flag_implicit_templates
5838 && TREE_PUBLIC (decl
)
5839 && VAR_OR_FUNCTION_DECL_P (decl
))
5840 /* Set DECL_COMDAT on template instantiations; if we force
5841 them to be emitted by explicit instantiation or -frepo,
5842 mark_needed will tell cgraph to do the right thing. */
5843 DECL_COMDAT (decl
) = true;
5845 return DECL_TEMPLATE_RESULT (tmpl
);
5849 push_template_decl (tree decl
)
5851 return push_template_decl_real (decl
, false);
5854 /* FN is an inheriting constructor that inherits from the constructor
5855 template INHERITED; turn FN into a constructor template with a matching
5859 add_inherited_template_parms (tree fn
, tree inherited
)
5862 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5863 inner_parms
= copy_node (inner_parms
);
5865 = tree_cons (size_int (processing_template_decl
+ 1),
5866 inner_parms
, current_template_parms
);
5867 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5868 tree args
= template_parms_to_args (parms
);
5869 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5870 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5871 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5872 DECL_ARTIFICIAL (tmpl
) = true;
5873 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5877 /* Called when a class template TYPE is redeclared with the indicated
5878 template PARMS, e.g.:
5880 template <class T> struct S;
5881 template <class T> struct S {}; */
5884 redeclare_class_template (tree type
, tree parms
, tree cons
)
5890 if (!TYPE_TEMPLATE_INFO (type
))
5892 error ("%qT is not a template type", type
);
5896 tmpl
= TYPE_TI_TEMPLATE (type
);
5897 if (!PRIMARY_TEMPLATE_P (tmpl
))
5898 /* The type is nested in some template class. Nothing to worry
5899 about here; there are no new template parameters for the nested
5905 error ("template specifiers not specified in declaration of %qD",
5910 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5911 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5913 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5915 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5916 "redeclared with %d template parameter",
5917 "redeclared with %d template parameters",
5918 TREE_VEC_LENGTH (parms
));
5919 inform_n (DECL_SOURCE_LOCATION (tmpl
), TREE_VEC_LENGTH (tmpl_parms
),
5920 "previous declaration %qD used %d template parameter",
5921 "previous declaration %qD used %d template parameters",
5922 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5926 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5933 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5934 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5937 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5938 if (error_operand_p (tmpl_parm
))
5941 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5942 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5943 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5945 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5947 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5948 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5949 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5950 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5951 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5952 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5953 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5954 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5955 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5957 error ("template parameter %q+#D", tmpl_parm
);
5958 error ("redeclared here as %q#D", parm
);
5962 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5964 /* We have in [temp.param]:
5966 A template-parameter may not be given default arguments
5967 by two different declarations in the same scope. */
5968 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5969 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5970 "original definition appeared here");
5974 if (parm_default
!= NULL_TREE
)
5975 /* Update the previous template parameters (which are the ones
5976 that will really count) with the new default value. */
5977 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5978 else if (tmpl_default
!= NULL_TREE
)
5979 /* Update the new parameters, too; they'll be used as the
5980 parameters for any members. */
5981 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5983 /* Give each template template parm in this redeclaration a
5984 DECL_CONTEXT of the template for which they are a parameter. */
5985 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5987 gcc_assert (DECL_CONTEXT (parm
) == NULL_TREE
);
5988 DECL_CONTEXT (parm
) = tmpl
;
5991 if (TREE_CODE (parm
) == TYPE_DECL
)
5992 TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (parm
)) = true;
5995 // Cannot redeclare a class template with a different set of constraints.
5996 if (!equivalent_constraints (get_constraints (tmpl
), cons
))
5998 error_at (input_location
, "redeclaration %q#D with different "
5999 "constraints", tmpl
);
6000 inform (DECL_SOURCE_LOCATION (tmpl
),
6001 "original declaration appeared here");
6007 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
6008 to be used when the caller has already checked
6009 (processing_template_decl
6010 && !instantiation_dependent_expression_p (expr)
6011 && potential_constant_expression (expr))
6012 and cleared processing_template_decl. */
6015 instantiate_non_dependent_expr_internal (tree expr
, tsubst_flags_t complain
)
6017 return tsubst_copy_and_build (expr
,
6020 /*in_decl=*/NULL_TREE
,
6021 /*function_p=*/false,
6022 /*integral_constant_expression_p=*/true);
6025 /* Simplify EXPR if it is a non-dependent expression. Returns the
6026 (possibly simplified) expression. */
6029 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
6031 if (expr
== NULL_TREE
)
6034 /* If we're in a template, but EXPR isn't value dependent, simplify
6035 it. We're supposed to treat:
6037 template <typename T> void f(T[1 + 1]);
6038 template <typename T> void f(T[2]);
6040 as two declarations of the same function, for example. */
6041 if (processing_template_decl
6042 && is_nondependent_constant_expression (expr
))
6044 processing_template_decl_sentinel s
;
6045 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6051 instantiate_non_dependent_expr (tree expr
)
6053 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
6056 /* Like instantiate_non_dependent_expr, but return NULL_TREE rather than
6057 an uninstantiated expression. */
6060 instantiate_non_dependent_or_null (tree expr
)
6062 if (expr
== NULL_TREE
)
6064 if (processing_template_decl
)
6066 if (!is_nondependent_constant_expression (expr
))
6070 processing_template_decl_sentinel s
;
6071 expr
= instantiate_non_dependent_expr_internal (expr
, tf_error
);
6077 /* True iff T is a specialization of a variable template. */
6080 variable_template_specialization_p (tree t
)
6082 if (!VAR_P (t
) || !DECL_LANG_SPECIFIC (t
) || !DECL_TEMPLATE_INFO (t
))
6084 tree tmpl
= DECL_TI_TEMPLATE (t
);
6085 return variable_template_p (tmpl
);
6088 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
6089 template declaration, or a TYPE_DECL for an alias declaration. */
6092 alias_type_or_template_p (tree t
)
6096 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
6099 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
6100 || DECL_ALIAS_TEMPLATE_P (t
));
6103 /* Return TRUE iff T is a specialization of an alias template. */
6106 alias_template_specialization_p (const_tree t
)
6108 /* It's an alias template specialization if it's an alias and its
6109 TYPE_NAME is a specialization of a primary template. */
6110 if (TYPE_ALIAS_P (t
))
6111 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
6112 return PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
));
6117 /* An alias template is complex from a SFINAE perspective if a template-id
6118 using that alias can be ill-formed when the expansion is not, as with
6119 the void_t template. We determine this by checking whether the
6120 expansion for the alias template uses all its template parameters. */
6122 struct uses_all_template_parms_data
6129 uses_all_template_parms_r (tree t
, void *data_
)
6131 struct uses_all_template_parms_data
&data
6132 = *(struct uses_all_template_parms_data
*)data_
;
6133 tree idx
= get_template_parm_index (t
);
6135 if (TEMPLATE_PARM_LEVEL (idx
) == data
.level
)
6136 data
.seen
[TEMPLATE_PARM_IDX (idx
)] = true;
6141 complex_alias_template_p (const_tree tmpl
)
6143 struct uses_all_template_parms_data data
;
6144 tree pat
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
6145 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
6146 data
.level
= TMPL_PARMS_DEPTH (parms
);
6147 int len
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms
));
6148 data
.seen
= XALLOCAVEC (bool, len
);
6149 for (int i
= 0; i
< len
; ++i
)
6150 data
.seen
[i
] = false;
6152 for_each_template_parm (pat
, uses_all_template_parms_r
, &data
, NULL
, true);
6153 for (int i
= 0; i
< len
; ++i
)
6159 /* Return TRUE iff T is a specialization of a complex alias template with
6160 dependent template-arguments. */
6163 dependent_alias_template_spec_p (const_tree t
)
6165 if (!alias_template_specialization_p (t
))
6168 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
);
6169 if (!TEMPLATE_DECL_COMPLEX_ALIAS_P (TI_TEMPLATE (tinfo
)))
6172 tree args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
));
6173 if (!any_dependent_template_arguments_p (args
))
6179 /* Return the number of innermost template parameters in TMPL. */
6182 num_innermost_template_parms (tree tmpl
)
6184 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
6185 return TREE_VEC_LENGTH (parms
);
6188 /* Return either TMPL or another template that it is equivalent to under DR
6189 1286: An alias that just changes the name of a template is equivalent to
6190 the other template. */
6193 get_underlying_template (tree tmpl
)
6195 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
6196 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
6198 /* Determine if the alias is equivalent to an underlying template. */
6199 tree orig_type
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
6200 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (orig_type
);
6204 tree underlying
= TI_TEMPLATE (tinfo
);
6205 if (!PRIMARY_TEMPLATE_P (underlying
)
6206 || (num_innermost_template_parms (tmpl
)
6207 != num_innermost_template_parms (underlying
)))
6210 tree alias_args
= INNERMOST_TEMPLATE_ARGS
6211 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
6212 if (!comp_template_args (TI_ARGS (tinfo
), alias_args
))
6215 /* Alias is equivalent. Strip it and repeat. */
6222 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
6223 must be a reference-to-function or a pointer-to-function type, as specified
6224 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
6225 and check that the resulting function has external linkage. */
6228 convert_nontype_argument_function (tree type
, tree expr
,
6229 tsubst_flags_t complain
)
6233 linkage_kind linkage
;
6235 fn
= instantiate_type (type
, fns
, tf_none
);
6236 if (fn
== error_mark_node
)
6237 return error_mark_node
;
6239 if (value_dependent_expression_p (fn
))
6242 fn_no_ptr
= strip_fnptr_conv (fn
);
6243 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
6244 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
6245 if (BASELINK_P (fn_no_ptr
))
6246 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
6248 /* [temp.arg.nontype]/1
6250 A template-argument for a non-type, non-template template-parameter
6253 -- the address of an object or function with external [C++11: or
6254 internal] linkage. */
6256 STRIP_ANY_LOCATION_WRAPPER (fn_no_ptr
);
6257 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
6259 if (complain
& tf_error
)
6261 error ("%qE is not a valid template argument for type %qT",
6263 if (TYPE_PTR_P (type
))
6264 inform (input_location
, "it must be the address of a function "
6265 "with external linkage");
6267 inform (input_location
, "it must be the name of a function with "
6268 "external linkage");
6273 linkage
= decl_linkage (fn_no_ptr
);
6274 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
6276 if (complain
& tf_error
)
6278 if (cxx_dialect
>= cxx11
)
6279 error ("%qE is not a valid template argument for type %qT "
6280 "because %qD has no linkage",
6281 expr
, type
, fn_no_ptr
);
6283 error ("%qE is not a valid template argument for type %qT "
6284 "because %qD does not have external linkage",
6285 expr
, type
, fn_no_ptr
);
6291 if (TYPE_REF_P (type
))
6293 if (REFERENCE_REF_P (fn
))
6294 fn
= TREE_OPERAND (fn
, 0);
6296 fn
= build_address (fn
);
6298 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (fn
)))
6299 fn
= build_nop (type
, fn
);
6304 /* Subroutine of convert_nontype_argument.
6305 Check if EXPR of type TYPE is a valid pointer-to-member constant.
6306 Emit an error otherwise. */
6309 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
6310 tsubst_flags_t complain
)
6312 location_t loc
= cp_expr_loc_or_loc (expr
, input_location
);
6313 tree orig_expr
= expr
;
6315 if (null_ptr_cst_p (expr
))
6317 if (TREE_CODE (expr
) == PTRMEM_CST
6318 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
6319 PTRMEM_CST_CLASS (expr
)))
6321 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
6323 if (processing_template_decl
6324 && TREE_CODE (expr
) == ADDR_EXPR
6325 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
6327 if (complain
& tf_error
)
6329 error_at (loc
, "%qE is not a valid template argument for type %qT",
6331 if (TREE_CODE (expr
) != PTRMEM_CST
)
6332 inform (loc
, "it must be a pointer-to-member of the form %<&X::Y%>");
6334 inform (loc
, "because it is a member of %qT", PTRMEM_CST_CLASS (expr
));
6339 /* Returns TRUE iff the address of OP is value-dependent.
6341 14.6.2.4 [temp.dep.temp]:
6342 A non-integral non-type template-argument is dependent if its type is
6343 dependent or it has either of the following forms
6346 and contains a nested-name-specifier which specifies a class-name that
6347 names a dependent type.
6349 We generalize this to just say that the address of a member of a
6350 dependent class is value-dependent; the above doesn't cover the
6351 address of a static data member named with an unqualified-id. */
6354 has_value_dependent_address (tree op
)
6356 /* We could use get_inner_reference here, but there's no need;
6357 this is only relevant for template non-type arguments, which
6358 can only be expressed as &id-expression. */
6361 tree ctx
= CP_DECL_CONTEXT (op
);
6362 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
6369 /* The next set of functions are used for providing helpful explanatory
6370 diagnostics for failed overload resolution. Their messages should be
6371 indented by two spaces for consistency with the messages in
6375 unify_success (bool /*explain_p*/)
6380 /* Other failure functions should call this one, to provide a single function
6381 for setting a breakpoint on. */
6384 unify_invalid (bool /*explain_p*/)
6390 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
6393 inform (input_location
,
6394 " couldn%'t deduce template parameter %qD", parm
);
6395 return unify_invalid (explain_p
);
6399 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
6402 inform (input_location
,
6403 " types %qT and %qT have incompatible cv-qualifiers",
6405 return unify_invalid (explain_p
);
6409 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
6412 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
6413 return unify_invalid (explain_p
);
6417 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
6420 inform (input_location
,
6421 " template parameter %qD is not a parameter pack, but "
6424 return unify_invalid (explain_p
);
6428 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
6431 inform (input_location
,
6432 " template argument %qE does not match "
6433 "pointer-to-member constant %qE",
6435 return unify_invalid (explain_p
);
6439 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
6442 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
6443 return unify_invalid (explain_p
);
6447 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
6450 inform (input_location
,
6451 " inconsistent parameter pack deduction with %qT and %qT",
6453 return unify_invalid (explain_p
);
6457 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
6462 inform (input_location
,
6463 " deduced conflicting types for parameter %qT (%qT and %qT)",
6464 parm
, first
, second
);
6466 inform (input_location
,
6467 " deduced conflicting values for non-type parameter "
6468 "%qE (%qE and %qE)", parm
, first
, second
);
6470 return unify_invalid (explain_p
);
6474 unify_vla_arg (bool explain_p
, tree arg
)
6477 inform (input_location
,
6478 " variable-sized array type %qT is not "
6479 "a valid template argument",
6481 return unify_invalid (explain_p
);
6485 unify_method_type_error (bool explain_p
, tree arg
)
6488 inform (input_location
,
6489 " member function type %qT is not a valid template argument",
6491 return unify_invalid (explain_p
);
6495 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
6500 inform_n (input_location
, wanted
,
6501 " candidate expects at least %d argument, %d provided",
6502 " candidate expects at least %d arguments, %d provided",
6505 inform_n (input_location
, wanted
,
6506 " candidate expects %d argument, %d provided",
6507 " candidate expects %d arguments, %d provided",
6510 return unify_invalid (explain_p
);
6514 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
6516 return unify_arity (explain_p
, have
, wanted
);
6520 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
6521 bool least_p
= false)
6523 return unify_arity (explain_p
, have
, wanted
, least_p
);
6527 unify_arg_conversion (bool explain_p
, tree to_type
,
6528 tree from_type
, tree arg
)
6531 inform (cp_expr_loc_or_loc (arg
, input_location
),
6532 " cannot convert %qE (type %qT) to type %qT",
6533 arg
, from_type
, to_type
);
6534 return unify_invalid (explain_p
);
6538 unify_no_common_base (bool explain_p
, enum template_base_result r
,
6539 tree parm
, tree arg
)
6544 case tbr_ambiguous_baseclass
:
6545 inform (input_location
, " %qT is an ambiguous base class of %qT",
6549 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
6552 return unify_invalid (explain_p
);
6556 unify_inconsistent_template_template_parameters (bool explain_p
)
6559 inform (input_location
,
6560 " template parameters of a template template argument are "
6561 "inconsistent with other deduced template arguments");
6562 return unify_invalid (explain_p
);
6566 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
6569 inform (input_location
,
6570 " cannot deduce a template for %qT from non-template type %qT",
6572 return unify_invalid (explain_p
);
6576 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
6579 inform (input_location
,
6580 " template argument %qE does not match %qE", arg
, parm
);
6581 return unify_invalid (explain_p
);
6584 /* True if T is a C++20 template parameter object to store the argument for a
6585 template parameter of class type. */
6588 template_parm_object_p (const_tree t
)
6590 return (TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
) && DECL_NAME (t
)
6591 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (t
)), "_ZTA", 4));
6594 /* Subroutine of convert_nontype_argument, to check whether EXPR, as an
6595 argument for TYPE, points to an unsuitable object. */
6598 invalid_tparm_referent_p (tree type
, tree expr
, tsubst_flags_t complain
)
6600 switch (TREE_CODE (expr
))
6603 return invalid_tparm_referent_p (type
, TREE_OPERAND (expr
, 0),
6607 return invalid_tparm_referent_p (type
, TARGET_EXPR_INITIAL (expr
),
6612 unsigned i
; tree elt
;
6613 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), i
, elt
)
6614 if (invalid_tparm_referent_p (TREE_TYPE (elt
), elt
, complain
))
6621 tree decl
= TREE_OPERAND (expr
, 0);
6625 if (complain
& tf_error
)
6626 error ("%qE is not a valid template argument of type %qT "
6627 "because %qE is not a variable", expr
, type
, decl
);
6630 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
6632 if (complain
& tf_error
)
6633 error ("%qE is not a valid template argument of type %qT "
6634 "in C++98 because %qD does not have external linkage",
6638 else if ((cxx_dialect
>= cxx11
&& cxx_dialect
< cxx17
)
6639 && decl_linkage (decl
) == lk_none
)
6641 if (complain
& tf_error
)
6642 error ("%qE is not a valid template argument of type %qT "
6643 "because %qD has no linkage", expr
, type
, decl
);
6646 /* C++17: For a non-type template-parameter of reference or pointer
6647 type, the value of the constant expression shall not refer to (or
6648 for a pointer type, shall not be the address of):
6649 * a subobject (4.5),
6650 * a temporary object (15.2),
6651 * a string literal (5.13.5),
6652 * the result of a typeid expression (8.2.8), or
6653 * a predefined __func__ variable (11.4.1). */
6654 else if (DECL_ARTIFICIAL (decl
))
6656 if (complain
& tf_error
)
6657 error ("the address of %qD is not a valid template argument",
6661 else if (!same_type_ignoring_top_level_qualifiers_p
6662 (strip_array_types (TREE_TYPE (type
)),
6663 strip_array_types (TREE_TYPE (decl
))))
6665 if (complain
& tf_error
)
6666 error ("the address of the %qT subobject of %qD is not a "
6667 "valid template argument", TREE_TYPE (type
), decl
);
6670 else if (!TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
6672 if (complain
& tf_error
)
6673 error ("the address of %qD is not a valid template argument "
6674 "because it does not have static storage duration",
6682 if (!INDIRECT_TYPE_P (type
))
6683 /* We're only concerned about pointers and references here. */;
6684 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6685 /* Null pointer values are OK in C++11. */;
6690 if (complain
& tf_error
)
6691 error ("%qD is not a valid template argument "
6692 "because %qD is a variable, not the address of "
6693 "a variable", expr
, expr
);
6698 if (complain
& tf_error
)
6699 error ("%qE is not a valid template argument for %qT "
6700 "because it is not the address of a variable",
6710 /* Return a VAR_DECL for the C++20 template parameter object corresponding to
6711 template argument EXPR. */
6714 get_template_parm_object (tree expr
, tsubst_flags_t complain
)
6716 if (TREE_CODE (expr
) == TARGET_EXPR
)
6717 expr
= TARGET_EXPR_INITIAL (expr
);
6719 if (!TREE_CONSTANT (expr
))
6721 if ((complain
& tf_error
)
6722 && require_rvalue_constant_expression (expr
))
6723 cxx_constant_value (expr
);
6724 return error_mark_node
;
6726 if (invalid_tparm_referent_p (TREE_TYPE (expr
), expr
, complain
))
6727 return error_mark_node
;
6729 tree name
= mangle_template_parm_object (expr
);
6730 tree decl
= get_global_binding (name
);
6734 tree type
= cp_build_qualified_type (TREE_TYPE (expr
), TYPE_QUAL_CONST
);
6735 decl
= create_temporary_var (type
);
6736 TREE_STATIC (decl
) = true;
6737 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
6738 TREE_READONLY (decl
) = true;
6739 DECL_NAME (decl
) = name
;
6740 SET_DECL_ASSEMBLER_NAME (decl
, name
);
6741 DECL_CONTEXT (decl
) = global_namespace
;
6742 comdat_linkage (decl
);
6743 pushdecl_top_level_and_finish (decl
, expr
);
6747 /* Attempt to convert the non-type template parameter EXPR to the
6748 indicated TYPE. If the conversion is successful, return the
6749 converted value. If the conversion is unsuccessful, return
6750 NULL_TREE if we issued an error message, or error_mark_node if we
6751 did not. We issue error messages for out-and-out bad template
6752 parameters, but not simply because the conversion failed, since we
6753 might be just trying to do argument deduction. Both TYPE and EXPR
6754 must be non-dependent.
6756 The conversion follows the special rules described in
6757 [temp.arg.nontype], and it is much more strict than an implicit
6760 This function is called twice for each template argument (see
6761 lookup_template_class for a more accurate description of this
6762 problem). This means that we need to handle expressions which
6763 are not valid in a C++ source, but can be created from the
6764 first call (for instance, casts to perform conversions). These
6765 hacks can go away after we fix the double coercion problem. */
6768 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
6771 location_t loc
= cp_expr_loc_or_loc (expr
, input_location
);
6773 /* Detect immediately string literals as invalid non-type argument.
6774 This special-case is not needed for correctness (we would easily
6775 catch this later), but only to provide better diagnostic for this
6776 common user mistake. As suggested by DR 100, we do not mention
6777 linkage issues in the diagnostic as this is not the point. */
6778 if (TREE_CODE (expr
) == STRING_CST
&& !CLASS_TYPE_P (type
))
6780 if (complain
& tf_error
)
6781 error ("%qE is not a valid template argument for type %qT "
6782 "because string literals can never be used in this context",
6787 /* Add the ADDR_EXPR now for the benefit of
6788 value_dependent_expression_p. */
6789 if (TYPE_PTROBV_P (type
)
6790 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
6792 expr
= decay_conversion (expr
, complain
);
6793 if (expr
== error_mark_node
)
6794 return error_mark_node
;
6797 /* If we are in a template, EXPR may be non-dependent, but still
6798 have a syntactic, rather than semantic, form. For example, EXPR
6799 might be a SCOPE_REF, rather than the VAR_DECL to which the
6800 SCOPE_REF refers. Preserving the qualifying scope is necessary
6801 so that access checking can be performed when the template is
6802 instantiated -- but here we need the resolved form so that we can
6803 convert the argument. */
6804 bool non_dep
= false;
6805 if (TYPE_REF_OBJ_P (type
)
6806 && has_value_dependent_address (expr
))
6807 /* If we want the address and it's value-dependent, don't fold. */;
6808 else if (processing_template_decl
6809 && is_nondependent_constant_expression (expr
))
6811 if (error_operand_p (expr
))
6812 return error_mark_node
;
6813 expr_type
= TREE_TYPE (expr
);
6815 /* If the argument is non-dependent, perform any conversions in
6816 non-dependent context as well. */
6817 processing_template_decl_sentinel
s (non_dep
);
6819 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6821 if (value_dependent_expression_p (expr
))
6822 expr
= canonicalize_expr_argument (expr
, complain
);
6824 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
6825 to a non-type argument of "nullptr". */
6826 if (NULLPTR_TYPE_P (expr_type
) && TYPE_PTR_OR_PTRMEM_P (type
))
6827 expr
= fold_simple (convert (type
, expr
));
6829 /* In C++11, integral or enumeration non-type template arguments can be
6830 arbitrary constant expressions. Pointer and pointer to
6831 member arguments can be general constant expressions that evaluate
6832 to a null value, but otherwise still need to be of a specific form. */
6833 if (cxx_dialect
>= cxx11
)
6835 if (TREE_CODE (expr
) == PTRMEM_CST
&& TYPE_PTRMEM_P (type
))
6836 /* A PTRMEM_CST is already constant, and a valid template
6837 argument for a parameter of pointer to member type, we just want
6838 to leave it in that form rather than lower it to a
6840 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
6841 || cxx_dialect
>= cxx17
)
6843 /* Calling build_converted_constant_expr might create a call to
6844 a conversion function with a value-dependent argument, which
6845 could invoke taking the address of a temporary representing
6846 the result of the conversion. */
6847 if (COMPOUND_LITERAL_P (expr
)
6848 && CONSTRUCTOR_IS_DEPENDENT (expr
)
6849 && MAYBE_CLASS_TYPE_P (expr_type
)
6850 && TYPE_HAS_CONVERSION (expr_type
))
6852 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
6853 IMPLICIT_CONV_EXPR_NONTYPE_ARG (expr
) = true;
6856 /* C++17: A template-argument for a non-type template-parameter shall
6857 be a converted constant expression (8.20) of the type of the
6858 template-parameter. */
6859 expr
= build_converted_constant_expr (type
, expr
, complain
);
6860 if (expr
== error_mark_node
)
6861 /* Make sure we return NULL_TREE only if we have really issued
6862 an error, as described above. */
6863 return (complain
& tf_error
) ? NULL_TREE
: error_mark_node
;
6864 expr
= maybe_constant_value (expr
, NULL_TREE
,
6865 /*manifestly_const_eval=*/true);
6866 expr
= convert_from_reference (expr
);
6868 else if (TYPE_PTR_OR_PTRMEM_P (type
))
6870 tree folded
= maybe_constant_value (expr
, NULL_TREE
,
6871 /*manifestly_const_eval=*/true);
6872 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
6873 : null_member_pointer_value_p (folded
))
6878 if (TYPE_REF_P (type
))
6879 expr
= mark_lvalue_use (expr
);
6881 expr
= mark_rvalue_use (expr
);
6883 /* HACK: Due to double coercion, we can get a
6884 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
6885 which is the tree that we built on the first call (see
6886 below when coercing to reference to object or to reference to
6887 function). We just strip everything and get to the arg.
6888 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
6890 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
6892 tree probe_type
, probe
= expr
;
6893 if (REFERENCE_REF_P (probe
))
6894 probe
= TREE_OPERAND (probe
, 0);
6895 probe_type
= TREE_TYPE (probe
);
6896 if (TREE_CODE (probe
) == NOP_EXPR
)
6898 /* ??? Maybe we could use convert_from_reference here, but we
6899 would need to relax its constraints because the NOP_EXPR
6900 could actually change the type to something more cv-qualified,
6901 and this is not folded by convert_from_reference. */
6902 tree addr
= TREE_OPERAND (probe
, 0);
6903 if (TYPE_REF_P (probe_type
)
6904 && TREE_CODE (addr
) == ADDR_EXPR
6905 && TYPE_PTR_P (TREE_TYPE (addr
))
6906 && (same_type_ignoring_top_level_qualifiers_p
6907 (TREE_TYPE (probe_type
),
6908 TREE_TYPE (TREE_TYPE (addr
)))))
6910 expr
= TREE_OPERAND (addr
, 0);
6911 expr_type
= TREE_TYPE (probe_type
);
6916 /* [temp.arg.nontype]/5, bullet 1
6918 For a non-type template-parameter of integral or enumeration type,
6919 integral promotions (_conv.prom_) and integral conversions
6920 (_conv.integral_) are applied. */
6921 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6923 if (cxx_dialect
< cxx11
)
6925 tree t
= build_converted_constant_expr (type
, expr
, complain
);
6926 t
= maybe_constant_value (t
);
6927 if (t
!= error_mark_node
)
6931 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
6932 return error_mark_node
;
6934 /* Notice that there are constant expressions like '4 % 0' which
6935 do not fold into integer constants. */
6936 if (TREE_CODE (expr
) != INTEGER_CST
6937 && !value_dependent_expression_p (expr
))
6939 if (complain
& tf_error
)
6941 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
6942 if (!require_potential_constant_expression (expr
))
6943 expr
= error_mark_node
;
6945 expr
= cxx_constant_value (expr
);
6946 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
6947 inform (loc
, "in template argument for type %qT", type
);
6948 if (expr
== error_mark_node
)
6950 /* else cxx_constant_value complained but gave us
6951 a real constant, so go ahead. */
6952 if (TREE_CODE (expr
) != INTEGER_CST
)
6954 /* Some assemble time constant expressions like
6955 (intptr_t)&&lab1 - (intptr_t)&&lab2 or
6956 4 + (intptr_t)&&var satisfy reduced_constant_expression_p
6957 as we can emit them into .rodata initializers of
6958 variables, yet they can't fold into an INTEGER_CST at
6959 compile time. Refuse them here. */
6960 gcc_checking_assert (reduced_constant_expression_p (expr
));
6961 error_at (loc
, "template argument %qE for type %qT not "
6962 "a constant integer", expr
, type
);
6970 /* Avoid typedef problems. */
6971 if (TREE_TYPE (expr
) != type
)
6972 expr
= fold_convert (type
, expr
);
6974 /* [temp.arg.nontype]/5, bullet 2
6976 For a non-type template-parameter of type pointer to object,
6977 qualification conversions (_conv.qual_) and the array-to-pointer
6978 conversion (_conv.array_) are applied. */
6979 else if (TYPE_PTROBV_P (type
))
6981 tree decayed
= expr
;
6983 /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
6984 decay_conversion or an explicit cast. If it's a problematic cast,
6985 we'll complain about it below. */
6986 if (TREE_CODE (expr
) == NOP_EXPR
)
6990 if (TREE_CODE (probe
) == ADDR_EXPR
6991 && TYPE_PTR_P (TREE_TYPE (probe
)))
6994 expr_type
= TREE_TYPE (expr
);
6998 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
7000 A template-argument for a non-type, non-template template-parameter
7001 shall be one of: [...]
7003 -- the name of a non-type template-parameter;
7004 -- the address of an object or function with external linkage, [...]
7005 expressed as "& id-expression" where the & is optional if the name
7006 refers to a function or array, or if the corresponding
7007 template-parameter is a reference.
7009 Here, we do not care about functions, as they are invalid anyway
7010 for a parameter of type pointer-to-object. */
7012 if (value_dependent_expression_p (expr
))
7013 /* Non-type template parameters are OK. */
7015 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
7016 /* Null pointer values are OK in C++11. */;
7017 else if (TREE_CODE (expr
) != ADDR_EXPR
7018 && !INDIRECT_TYPE_P (expr_type
))
7019 /* Other values, like integer constants, might be valid
7020 non-type arguments of some other type. */
7021 return error_mark_node
;
7022 else if (invalid_tparm_referent_p (type
, expr
, complain
))
7027 expr
= perform_qualification_conversions (type
, expr
);
7028 if (expr
== error_mark_node
)
7029 return error_mark_node
;
7031 /* [temp.arg.nontype]/5, bullet 3
7033 For a non-type template-parameter of type reference to object, no
7034 conversions apply. The type referred to by the reference may be more
7035 cv-qualified than the (otherwise identical) type of the
7036 template-argument. The template-parameter is bound directly to the
7037 template-argument, which must be an lvalue. */
7038 else if (TYPE_REF_OBJ_P (type
))
7040 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
7042 return error_mark_node
;
7044 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
7046 if (complain
& tf_error
)
7047 error ("%qE is not a valid template argument for type %qT "
7048 "because of conflicts in cv-qualification", expr
, type
);
7052 if (!lvalue_p (expr
))
7054 if (complain
& tf_error
)
7055 error ("%qE is not a valid template argument for type %qT "
7056 "because it is not an lvalue", expr
, type
);
7060 /* [temp.arg.nontype]/1
7062 A template-argument for a non-type, non-template template-parameter
7063 shall be one of: [...]
7065 -- the address of an object or function with external linkage. */
7066 if (INDIRECT_REF_P (expr
)
7067 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
7069 expr
= TREE_OPERAND (expr
, 0);
7072 if (complain
& tf_error
)
7073 error ("%q#D is not a valid template argument for type %qT "
7074 "because a reference variable does not have a constant "
7075 "address", expr
, type
);
7080 if (TYPE_REF_OBJ_P (TREE_TYPE (expr
))
7081 && value_dependent_expression_p (expr
))
7082 /* OK, dependent reference. We don't want to ask whether a DECL is
7083 itself value-dependent, since what we want here is its address. */;
7086 expr
= build_address (expr
);
7088 if (invalid_tparm_referent_p (type
, expr
, complain
))
7092 if (!same_type_p (type
, TREE_TYPE (expr
)))
7093 expr
= build_nop (type
, expr
);
7095 /* [temp.arg.nontype]/5, bullet 4
7097 For a non-type template-parameter of type pointer to function, only
7098 the function-to-pointer conversion (_conv.func_) is applied. If the
7099 template-argument represents a set of overloaded functions (or a
7100 pointer to such), the matching function is selected from the set
7102 else if (TYPE_PTRFN_P (type
))
7104 /* If the argument is a template-id, we might not have enough
7105 context information to decay the pointer. */
7106 if (!type_unknown_p (expr_type
))
7108 expr
= decay_conversion (expr
, complain
);
7109 if (expr
== error_mark_node
)
7110 return error_mark_node
;
7113 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
7114 /* Null pointer values are OK in C++11. */
7115 return perform_qualification_conversions (type
, expr
);
7117 expr
= convert_nontype_argument_function (type
, expr
, complain
);
7118 if (!expr
|| expr
== error_mark_node
)
7121 /* [temp.arg.nontype]/5, bullet 5
7123 For a non-type template-parameter of type reference to function, no
7124 conversions apply. If the template-argument represents a set of
7125 overloaded functions, the matching function is selected from the set
7127 else if (TYPE_REFFN_P (type
))
7129 if (TREE_CODE (expr
) == ADDR_EXPR
)
7131 if (complain
& tf_error
)
7133 error ("%qE is not a valid template argument for type %qT "
7134 "because it is a pointer", expr
, type
);
7135 inform (input_location
, "try using %qE instead",
7136 TREE_OPERAND (expr
, 0));
7141 expr
= convert_nontype_argument_function (type
, expr
, complain
);
7142 if (!expr
|| expr
== error_mark_node
)
7145 /* [temp.arg.nontype]/5, bullet 6
7147 For a non-type template-parameter of type pointer to member function,
7148 no conversions apply. If the template-argument represents a set of
7149 overloaded member functions, the matching member function is selected
7150 from the set (_over.over_). */
7151 else if (TYPE_PTRMEMFUNC_P (type
))
7153 expr
= instantiate_type (type
, expr
, tf_none
);
7154 if (expr
== error_mark_node
)
7155 return error_mark_node
;
7157 /* [temp.arg.nontype] bullet 1 says the pointer to member
7158 expression must be a pointer-to-member constant. */
7159 if (!value_dependent_expression_p (expr
)
7160 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
7163 /* Repeated conversion can't deal with a conversion that turns PTRMEM_CST
7164 into a CONSTRUCTOR, so build up a new PTRMEM_CST instead. */
7165 if (fnptr_conv_p (type
, TREE_TYPE (expr
)))
7166 expr
= make_ptrmem_cst (type
, PTRMEM_CST_MEMBER (expr
));
7168 /* [temp.arg.nontype]/5, bullet 7
7170 For a non-type template-parameter of type pointer to data member,
7171 qualification conversions (_conv.qual_) are applied. */
7172 else if (TYPE_PTRDATAMEM_P (type
))
7174 /* [temp.arg.nontype] bullet 1 says the pointer to member
7175 expression must be a pointer-to-member constant. */
7176 if (!value_dependent_expression_p (expr
)
7177 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
7180 expr
= perform_qualification_conversions (type
, expr
);
7181 if (expr
== error_mark_node
)
7184 else if (NULLPTR_TYPE_P (type
))
7186 if (!NULLPTR_TYPE_P (TREE_TYPE (expr
)))
7188 if (complain
& tf_error
)
7189 error ("%qE is not a valid template argument for type %qT "
7190 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
7195 else if (CLASS_TYPE_P (type
))
7197 /* Replace the argument with a reference to the corresponding template
7198 parameter object. */
7199 if (!value_dependent_expression_p (expr
))
7200 expr
= get_template_parm_object (expr
, complain
);
7201 if (expr
== error_mark_node
)
7204 /* A template non-type parameter must be one of the above. */
7208 /* Sanity check: did we actually convert the argument to the
7210 gcc_assert (same_type_ignoring_top_level_qualifiers_p
7211 (type
, TREE_TYPE (expr
)));
7212 return convert_from_reference (expr
);
7215 /* Subroutine of coerce_template_template_parms, which returns 1 if
7216 PARM_PARM and ARG_PARM match using the rule for the template
7217 parameters of template template parameters. Both PARM and ARG are
7218 template parameters; the rest of the arguments are the same as for
7219 coerce_template_template_parms.
7222 coerce_template_template_parm (tree parm
,
7224 tsubst_flags_t complain
,
7228 if (arg
== NULL_TREE
|| error_operand_p (arg
)
7229 || parm
== NULL_TREE
|| error_operand_p (parm
))
7232 if (TREE_CODE (arg
) != TREE_CODE (parm
))
7235 switch (TREE_CODE (parm
))
7238 /* We encounter instantiations of templates like
7239 template <template <template <class> class> class TT>
7242 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
7243 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
7245 if (!coerce_template_template_parms
7246 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
7252 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
7253 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
7254 /* Argument is a parameter pack but parameter is not. */
7259 /* The tsubst call is used to handle cases such as
7261 template <int> class C {};
7262 template <class T, template <T> class TT> class D {};
7265 i.e. the parameter list of TT depends on earlier parameters. */
7266 if (!uses_template_parms (TREE_TYPE (arg
)))
7268 tree t
= tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
);
7269 if (!uses_template_parms (t
)
7270 && !same_type_p (t
, TREE_TYPE (arg
)))
7274 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
7275 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
7276 /* Argument is a parameter pack but parameter is not. */
7288 /* Coerce template argument list ARGLIST for use with template
7289 template-parameter TEMPL. */
7292 coerce_template_args_for_ttp (tree templ
, tree arglist
,
7293 tsubst_flags_t complain
)
7295 /* Consider an example where a template template parameter declared as
7297 template <class T, class U = std::allocator<T> > class TT
7299 The template parameter level of T and U are one level larger than
7300 of TT. To proper process the default argument of U, say when an
7301 instantiation `TT<int>' is seen, we need to build the full
7302 arguments containing {int} as the innermost level. Outer levels,
7303 available when not appearing as default template argument, can be
7304 obtained from the arguments of the enclosing template.
7306 Suppose that TT is later substituted with std::vector. The above
7307 instantiation is `TT<int, std::allocator<T> >' with TT at
7308 level 1, and T at level 2, while the template arguments at level 1
7309 becomes {std::vector} and the inner level 2 is {int}. */
7311 tree outer
= DECL_CONTEXT (templ
);
7314 if (DECL_TEMPLATE_SPECIALIZATION (outer
))
7315 /* We want arguments for the partial specialization, not arguments for
7316 the primary template. */
7317 outer
= template_parms_to_args (DECL_TEMPLATE_PARMS (outer
));
7319 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7321 else if (current_template_parms
)
7323 /* This is an argument of the current template, so we haven't set
7324 DECL_CONTEXT yet. */
7325 tree relevant_template_parms
;
7327 /* Parameter levels that are greater than the level of the given
7328 template template parm are irrelevant. */
7329 relevant_template_parms
= current_template_parms
;
7330 while (TMPL_PARMS_DEPTH (relevant_template_parms
)
7331 != TEMPLATE_TYPE_LEVEL (TREE_TYPE (templ
)))
7332 relevant_template_parms
= TREE_CHAIN (relevant_template_parms
);
7334 outer
= template_parms_to_args (relevant_template_parms
);
7338 arglist
= add_to_template_args (outer
, arglist
);
7340 tree parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7341 return coerce_template_parms (parmlist
, arglist
, templ
,
7343 /*require_all_args=*/true,
7344 /*use_default_args=*/true);
7347 /* A cache of template template parameters with match-all default
7349 static GTY((deletable
)) hash_map
<tree
,tree
> *defaulted_ttp_cache
;
7351 store_defaulted_ttp (tree v
, tree t
)
7353 if (!defaulted_ttp_cache
)
7354 defaulted_ttp_cache
= hash_map
<tree
,tree
>::create_ggc (13);
7355 defaulted_ttp_cache
->put (v
, t
);
7358 lookup_defaulted_ttp (tree v
)
7360 if (defaulted_ttp_cache
)
7361 if (tree
*p
= defaulted_ttp_cache
->get (v
))
7366 /* T is a bound template template-parameter. Copy its arguments into default
7367 arguments of the template template-parameter's template parameters. */
7370 add_defaults_to_ttp (tree otmpl
)
7372 if (tree c
= lookup_defaulted_ttp (otmpl
))
7375 tree ntmpl
= copy_node (otmpl
);
7377 tree ntype
= copy_node (TREE_TYPE (otmpl
));
7378 TYPE_STUB_DECL (ntype
) = TYPE_NAME (ntype
) = ntmpl
;
7379 TYPE_MAIN_VARIANT (ntype
) = ntype
;
7380 TYPE_POINTER_TO (ntype
) = TYPE_REFERENCE_TO (ntype
) = NULL_TREE
;
7381 TYPE_NAME (ntype
) = ntmpl
;
7382 SET_TYPE_STRUCTURAL_EQUALITY (ntype
);
7384 tree idx
= TEMPLATE_TYPE_PARM_INDEX (ntype
)
7385 = copy_node (TEMPLATE_TYPE_PARM_INDEX (ntype
));
7386 TEMPLATE_PARM_DECL (idx
) = ntmpl
;
7387 TREE_TYPE (ntmpl
) = TREE_TYPE (idx
) = ntype
;
7389 tree oparms
= DECL_TEMPLATE_PARMS (otmpl
);
7390 tree parms
= DECL_TEMPLATE_PARMS (ntmpl
) = copy_node (oparms
);
7391 TREE_CHAIN (parms
) = TREE_CHAIN (oparms
);
7392 tree vec
= TREE_VALUE (parms
) = copy_node (TREE_VALUE (parms
));
7393 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
7395 tree o
= TREE_VEC_ELT (vec
, i
);
7396 if (!template_parameter_pack_p (TREE_VALUE (o
)))
7398 tree n
= TREE_VEC_ELT (vec
, i
) = copy_node (o
);
7399 TREE_PURPOSE (n
) = any_targ_node
;
7403 store_defaulted_ttp (otmpl
, ntmpl
);
7407 /* ARG is a bound potential template template-argument, and PARGS is a list
7408 of arguments for the corresponding template template-parameter. Adjust
7409 PARGS as appropriate for application to ARG's template, and if ARG is a
7410 BOUND_TEMPLATE_TEMPLATE_PARM, possibly adjust it to add default template
7411 arguments to the template template parameter. */
7414 coerce_ttp_args_for_tta (tree
& arg
, tree pargs
, tsubst_flags_t complain
)
7416 ++processing_template_decl
;
7417 tree arg_tmpl
= TYPE_TI_TEMPLATE (arg
);
7418 if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg_tmpl
))
7420 /* When comparing two template template-parameters in partial ordering,
7421 rewrite the one currently being used as an argument to have default
7422 arguments for all parameters. */
7423 arg_tmpl
= add_defaults_to_ttp (arg_tmpl
);
7424 pargs
= coerce_template_args_for_ttp (arg_tmpl
, pargs
, complain
);
7425 if (pargs
!= error_mark_node
)
7426 arg
= bind_template_template_parm (TREE_TYPE (arg_tmpl
),
7427 TYPE_TI_ARGS (arg
));
7432 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (arg_tmpl
));
7433 pargs
= coerce_template_parms (aparms
, pargs
, arg_tmpl
, complain
,
7434 /*require_all*/true,
7435 /*use_default*/true);
7437 --processing_template_decl
;
7441 /* Subroutine of unify for the case when PARM is a
7442 BOUND_TEMPLATE_TEMPLATE_PARM. */
7445 unify_bound_ttp_args (tree tparms
, tree targs
, tree parm
, tree
& arg
,
7448 tree parmvec
= TYPE_TI_ARGS (parm
);
7449 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
7451 /* The template template parm might be variadic and the argument
7452 not, so flatten both argument lists. */
7453 parmvec
= expand_template_argument_pack (parmvec
);
7454 argvec
= expand_template_argument_pack (argvec
);
7458 /* In keeping with P0522R0, adjust P's template arguments
7459 to apply to A's template; then flatten it again. */
7460 tree nparmvec
= parmvec
;
7461 nparmvec
= coerce_ttp_args_for_tta (arg
, parmvec
, tf_none
);
7462 nparmvec
= expand_template_argument_pack (nparmvec
);
7464 if (unify (tparms
, targs
, nparmvec
, argvec
,
7465 UNIFY_ALLOW_NONE
, explain_p
))
7468 /* If the P0522 adjustment eliminated a pack expansion, deduce
7471 && TREE_VEC_LENGTH (nparmvec
) < TREE_VEC_LENGTH (parmvec
)
7472 && unify_pack_expansion (tparms
, targs
, parmvec
, argvec
,
7473 DEDUCE_EXACT
, /*sub*/true, explain_p
))
7478 /* Deduce arguments T, i from TT<T> or TT<i>.
7479 We check each element of PARMVEC and ARGVEC individually
7480 rather than the whole TREE_VEC since they can have
7481 different number of elements, which is allowed under N2555. */
7483 int len
= TREE_VEC_LENGTH (parmvec
);
7485 /* Check if the parameters end in a pack, making them
7487 int parm_variadic_p
= 0;
7489 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
7490 parm_variadic_p
= 1;
7492 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7493 /* If the template argument list of P contains a pack
7494 expansion that is not the last template argument, the
7495 entire template argument list is a non-deduced
7497 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
7498 return unify_success (explain_p
);
7500 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
7501 return unify_too_few_arguments (explain_p
,
7502 TREE_VEC_LENGTH (argvec
), len
);
7504 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7505 if (unify (tparms
, targs
,
7506 TREE_VEC_ELT (parmvec
, i
),
7507 TREE_VEC_ELT (argvec
, i
),
7508 UNIFY_ALLOW_NONE
, explain_p
))
7512 && unify_pack_expansion (tparms
, targs
,
7515 /*subr=*/true, explain_p
))
7522 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
7523 template template parameters. Both PARM_PARMS and ARG_PARMS are
7524 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
7527 Consider the example:
7528 template <class T> class A;
7529 template<template <class U> class TT> class B;
7531 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
7532 the parameters to A, and OUTER_ARGS contains A. */
7535 coerce_template_template_parms (tree parm_parms
,
7537 tsubst_flags_t complain
,
7541 int nparms
, nargs
, i
;
7545 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
7546 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
7548 nparms
= TREE_VEC_LENGTH (parm_parms
);
7549 nargs
= TREE_VEC_LENGTH (arg_parms
);
7553 /* P0522R0: A template template-parameter P is at least as specialized as
7554 a template template-argument A if, given the following rewrite to two
7555 function templates, the function template corresponding to P is at
7556 least as specialized as the function template corresponding to A
7557 according to the partial ordering rules for function templates
7558 ([temp.func.order]). Given an invented class template X with the
7559 template parameter list of A (including default arguments):
7561 * Each of the two function templates has the same template parameters,
7562 respectively, as P or A.
7564 * Each function template has a single function parameter whose type is
7565 a specialization of X with template arguments corresponding to the
7566 template parameters from the respective function template where, for
7567 each template parameter PP in the template parameter list of the
7568 function template, a corresponding template argument AA is formed. If
7569 PP declares a parameter pack, then AA is the pack expansion
7570 PP... ([temp.variadic]); otherwise, AA is the id-expression PP.
7572 If the rewrite produces an invalid type, then P is not at least as
7573 specialized as A. */
7575 /* So coerce P's args to apply to A's parms, and then deduce between A's
7576 args and the converted args. If that succeeds, A is at least as
7577 specialized as P, so they match.*/
7578 tree pargs
= template_parms_level_to_args (parm_parms
);
7579 pargs
= add_outermost_template_args (outer_args
, pargs
);
7580 ++processing_template_decl
;
7581 pargs
= coerce_template_parms (arg_parms
, pargs
, NULL_TREE
, tf_none
,
7582 /*require_all*/true, /*use_default*/true);
7583 --processing_template_decl
;
7584 if (pargs
!= error_mark_node
)
7586 tree targs
= make_tree_vec (nargs
);
7587 tree aargs
= template_parms_level_to_args (arg_parms
);
7588 if (!unify (arg_parms
, targs
, aargs
, pargs
, UNIFY_ALLOW_NONE
,
7594 /* Determine whether we have a parameter pack at the end of the
7595 template template parameter's template parameter list. */
7596 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
7598 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
7600 if (error_operand_p (parm
))
7603 switch (TREE_CODE (parm
))
7607 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
7612 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
7622 && !(variadic_p
&& nargs
>= nparms
- 1))
7625 /* Check all of the template parameters except the parameter pack at
7626 the end (if any). */
7627 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
7629 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
7630 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7633 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7634 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7636 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7644 /* Check each of the template parameters in the template
7645 argument against the template parameter pack at the end of
7646 the template template parameter. */
7647 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
7650 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7652 for (; i
< nargs
; ++i
)
7654 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7657 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7659 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7668 /* Verifies that the deduced template arguments (in TARGS) for the
7669 template template parameters (in TPARMS) represent valid bindings,
7670 by comparing the template parameter list of each template argument
7671 to the template parameter list of its corresponding template
7672 template parameter, in accordance with DR150. This
7673 routine can only be called after all template arguments have been
7674 deduced. It will return TRUE if all of the template template
7675 parameter bindings are okay, FALSE otherwise. */
7677 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
7679 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
7682 /* We're dealing with template parms in this process. */
7683 ++processing_template_decl
;
7685 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
7687 for (i
= 0; i
< ntparms
; ++i
)
7689 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
7690 tree targ
= TREE_VEC_ELT (targs
, i
);
7692 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
7694 tree packed_args
= NULL_TREE
;
7697 if (ARGUMENT_PACK_P (targ
))
7699 /* Look inside the argument pack. */
7700 packed_args
= ARGUMENT_PACK_ARGS (targ
);
7701 len
= TREE_VEC_LENGTH (packed_args
);
7704 for (idx
= 0; idx
< len
; ++idx
)
7706 tree targ_parms
= NULL_TREE
;
7709 /* Extract the next argument from the argument
7711 targ
= TREE_VEC_ELT (packed_args
, idx
);
7713 if (PACK_EXPANSION_P (targ
))
7714 /* Look at the pattern of the pack expansion. */
7715 targ
= PACK_EXPANSION_PATTERN (targ
);
7717 /* Extract the template parameters from the template
7719 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
7720 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
7721 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
7722 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
7724 /* Verify that we can coerce the template template
7725 parameters from the template argument to the template
7726 parameter. This requires an exact match. */
7728 && !coerce_template_template_parms
7729 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
7744 --processing_template_decl
;
7748 /* Since type attributes aren't mangled, we need to strip them from
7749 template type arguments. */
7752 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
7754 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
7756 bool removed_attributes
= false;
7757 tree canon
= strip_typedefs (arg
, &removed_attributes
);
7758 if (removed_attributes
7759 && (complain
& tf_warning
))
7760 warning (OPT_Wignored_attributes
,
7761 "ignoring attributes on template argument %qT", arg
);
7765 /* And from inside dependent non-type arguments like sizeof(Type). */
7768 canonicalize_expr_argument (tree arg
, tsubst_flags_t complain
)
7770 if (!arg
|| arg
== error_mark_node
)
7772 bool removed_attributes
= false;
7773 tree canon
= strip_typedefs_expr (arg
, &removed_attributes
);
7774 if (removed_attributes
7775 && (complain
& tf_warning
))
7776 warning (OPT_Wignored_attributes
,
7777 "ignoring attributes in template argument %qE", arg
);
7781 // A template declaration can be substituted for a constrained
7782 // template template parameter only when the argument is more
7783 // constrained than the parameter.
7785 is_compatible_template_arg (tree parm
, tree arg
)
7787 tree parm_cons
= get_constraints (parm
);
7789 /* For now, allow constrained template template arguments
7790 and unconstrained template template parameters. */
7791 if (parm_cons
== NULL_TREE
)
7794 tree arg_cons
= get_constraints (arg
);
7796 // If the template parameter is constrained, we need to rewrite its
7797 // constraints in terms of the ARG's template parameters. This ensures
7798 // that all of the template parameter types will have the same depth.
7800 // Note that this is only valid when coerce_template_template_parm is
7801 // true for the innermost template parameters of PARM and ARG. In other
7802 // words, because coercion is successful, this conversion will be valid.
7805 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (arg
));
7806 parm_cons
= tsubst_constraint_info (parm_cons
,
7807 INNERMOST_TEMPLATE_ARGS (args
),
7808 tf_none
, NULL_TREE
);
7809 if (parm_cons
== error_mark_node
)
7813 return subsumes (parm_cons
, arg_cons
);
7816 // Convert a placeholder argument into a binding to the original
7817 // parameter. The original parameter is saved as the TREE_TYPE of
7820 convert_wildcard_argument (tree parm
, tree arg
)
7822 TREE_TYPE (arg
) = parm
;
7826 /* We can't fully resolve ARG given as a non-type template argument to TYPE,
7827 because one of them is dependent. But we need to represent the
7828 conversion for the benefit of cp_tree_equal. */
7831 maybe_convert_nontype_argument (tree type
, tree arg
)
7833 /* Auto parms get no conversion. */
7834 if (type_uses_auto (type
))
7836 /* We don't need or want to add this conversion now if we're going to use the
7837 argument for deduction. */
7838 if (value_dependent_expression_p (arg
))
7841 type
= cv_unqualified (type
);
7842 tree argtype
= TREE_TYPE (arg
);
7843 if (same_type_p (type
, argtype
))
7846 arg
= build1 (IMPLICIT_CONV_EXPR
, type
, arg
);
7847 IMPLICIT_CONV_EXPR_NONTYPE_ARG (arg
) = true;
7851 /* Convert the indicated template ARG as necessary to match the
7852 indicated template PARM. Returns the converted ARG, or
7853 error_mark_node if the conversion was unsuccessful. Error and
7854 warning messages are issued under control of COMPLAIN. This
7855 conversion is for the Ith parameter in the parameter list. ARGS is
7856 the full set of template arguments deduced so far. */
7859 convert_template_argument (tree parm
,
7862 tsubst_flags_t complain
,
7868 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
7870 if (parm
== error_mark_node
|| error_operand_p (arg
))
7871 return error_mark_node
;
7873 /* Trivially convert placeholders. */
7874 if (TREE_CODE (arg
) == WILDCARD_DECL
)
7875 return convert_wildcard_argument (parm
, arg
);
7877 if (arg
== any_targ_node
)
7880 if (TREE_CODE (arg
) == TREE_LIST
7881 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
7883 /* The template argument was the name of some
7884 member function. That's usually
7885 invalid, but static members are OK. In any
7886 case, grab the underlying fields/functions
7887 and issue an error later if required. */
7888 orig_arg
= TREE_VALUE (arg
);
7889 TREE_TYPE (arg
) = unknown_type_node
;
7894 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
7895 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
7896 || requires_tmpl_type
);
7898 /* When determining whether an argument pack expansion is a template,
7899 look at the pattern. */
7900 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
7901 arg
= PACK_EXPANSION_PATTERN (arg
);
7903 /* Deal with an injected-class-name used as a template template arg. */
7904 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
7906 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
7907 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7909 if (cxx_dialect
>= cxx11
)
7910 /* OK under DR 1004. */;
7911 else if (complain
& tf_warning_or_error
)
7912 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
7913 " used as template template argument", TYPE_NAME (arg
));
7914 else if (flag_pedantic_errors
)
7922 ((TREE_CODE (arg
) == TEMPLATE_DECL
7923 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
7924 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
7925 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7926 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
7929 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7930 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
7931 arg
= TYPE_STUB_DECL (arg
);
7933 is_type
= TYPE_P (arg
) || is_tmpl_type
;
7935 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
7936 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
7938 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
7940 if (complain
& tf_error
)
7941 error ("invalid use of destructor %qE as a type", orig_arg
);
7942 return error_mark_node
;
7945 permerror (input_location
,
7946 "to refer to a type member of a template parameter, "
7947 "use %<typename %E%>", orig_arg
);
7949 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
7950 TREE_OPERAND (arg
, 1),
7956 if (is_type
!= requires_type
)
7960 if (complain
& tf_error
)
7962 error ("type/value mismatch at argument %d in template "
7963 "parameter list for %qD",
7967 /* The template argument is a type, but we're expecting
7969 inform (input_location
,
7970 " expected a constant of type %qT, got %qT",
7972 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
7973 /* [temp.arg]/2: "In a template-argument, an ambiguity
7974 between a type-id and an expression is resolved to a
7975 type-id, regardless of the form of the corresponding
7976 template-parameter." So give the user a clue. */
7977 if (TREE_CODE (arg
) == FUNCTION_TYPE
)
7978 inform (input_location
, " ambiguous template argument "
7979 "for non-type template parameter is treated as "
7982 else if (requires_tmpl_type
)
7983 inform (input_location
,
7984 " expected a class template, got %qE", orig_arg
);
7986 inform (input_location
,
7987 " expected a type, got %qE", orig_arg
);
7990 return error_mark_node
;
7992 if (is_tmpl_type
^ requires_tmpl_type
)
7994 if (in_decl
&& (complain
& tf_error
))
7996 error ("type/value mismatch at argument %d in template "
7997 "parameter list for %qD",
8000 inform (input_location
,
8001 " expected a type, got %qT", DECL_NAME (arg
));
8003 inform (input_location
,
8004 " expected a class template, got %qT", orig_arg
);
8006 return error_mark_node
;
8009 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
8010 /* We already did the appropriate conversion when packing args. */
8014 if (requires_tmpl_type
)
8016 if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
8017 /* The number of argument required is not known yet.
8018 Just accept it for now. */
8022 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
8025 /* Strip alias templates that are equivalent to another
8027 arg
= get_underlying_template (arg
);
8028 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
8030 if (coerce_template_template_parms (parmparm
, argparm
,
8036 /* TEMPLATE_TEMPLATE_PARM node is preferred over
8038 if (val
!= error_mark_node
)
8040 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
8041 val
= TREE_TYPE (val
);
8042 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
8043 val
= make_pack_expansion (val
, complain
);
8048 if (in_decl
&& (complain
& tf_error
))
8050 error ("type/value mismatch at argument %d in "
8051 "template parameter list for %qD",
8053 inform (input_location
,
8054 " expected a template of type %qD, got %qT",
8058 val
= error_mark_node
;
8061 // Check that the constraints are compatible before allowing the
8063 if (val
!= error_mark_node
)
8064 if (!is_compatible_template_arg (parm
, arg
))
8066 if (in_decl
&& (complain
& tf_error
))
8068 error ("constraint mismatch at argument %d in "
8069 "template parameter list for %qD",
8071 inform (input_location
, " expected %qD but got %qD",
8074 val
= error_mark_node
;
8080 /* We only form one instance of each template specialization.
8081 Therefore, if we use a non-canonical variant (i.e., a
8082 typedef), any future messages referring to the type will use
8083 the typedef, which is confusing if those future uses do not
8084 themselves also use the typedef. */
8086 val
= canonicalize_type_argument (val
, complain
);
8090 tree t
= TREE_TYPE (parm
);
8092 if (TEMPLATE_PARM_LEVEL (get_template_parm_index (parm
))
8093 > TMPL_ARGS_DEPTH (args
))
8094 /* We don't have enough levels of args to do any substitution. This
8095 can happen in the context of -fnew-ttp-matching. */;
8096 else if (tree a
= type_uses_auto (t
))
8098 t
= do_auto_deduction (t
, arg
, a
, complain
, adc_unify
, args
);
8099 if (t
== error_mark_node
)
8100 return error_mark_node
;
8103 t
= tsubst (t
, args
, complain
, in_decl
);
8105 if (invalid_nontype_parm_type_p (t
, complain
))
8106 return error_mark_node
;
8108 if (t
!= TREE_TYPE (parm
))
8109 t
= canonicalize_type_argument (t
, complain
);
8111 if (!type_dependent_expression_p (orig_arg
)
8112 && !uses_template_parms (t
))
8113 /* We used to call digest_init here. However, digest_init
8114 will report errors, which we don't want when complain
8115 is zero. More importantly, digest_init will try too
8116 hard to convert things: for example, `0' should not be
8117 converted to pointer type at this point according to
8118 the standard. Accepting this is not merely an
8119 extension, since deciding whether or not these
8120 conversions can occur is part of determining which
8121 function template to call, or whether a given explicit
8122 argument specification is valid. */
8123 val
= convert_nontype_argument (t
, orig_arg
, complain
);
8126 val
= canonicalize_expr_argument (orig_arg
, complain
);
8127 val
= maybe_convert_nontype_argument (t
, val
);
8131 if (val
== NULL_TREE
)
8132 val
= error_mark_node
;
8133 else if (val
== error_mark_node
&& (complain
& tf_error
))
8134 error ("could not convert template argument %qE from %qT to %qT",
8135 orig_arg
, TREE_TYPE (orig_arg
), t
);
8137 if (INDIRECT_REF_P (val
))
8139 /* Reject template arguments that are references to built-in
8140 functions with no library fallbacks. */
8141 const_tree inner
= TREE_OPERAND (val
, 0);
8142 const_tree innertype
= TREE_TYPE (inner
);
8144 && TYPE_REF_P (innertype
)
8145 && TREE_CODE (TREE_TYPE (innertype
)) == FUNCTION_TYPE
8146 && TREE_OPERAND_LENGTH (inner
) > 0
8147 && reject_gcc_builtin (TREE_OPERAND (inner
, 0)))
8148 return error_mark_node
;
8151 if (TREE_CODE (val
) == SCOPE_REF
)
8153 /* Strip typedefs from the SCOPE_REF. */
8154 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
8155 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
8157 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
8158 QUALIFIED_NAME_IS_TEMPLATE (val
));
8165 /* Coerces the remaining template arguments in INNER_ARGS (from
8166 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
8167 Returns the coerced argument pack. PARM_IDX is the position of this
8168 parameter in the template parameter list. ARGS is the original
8169 template argument list. */
8171 coerce_template_parameter_pack (tree parms
,
8179 tsubst_flags_t complain
)
8181 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
8182 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
8185 tree packed_parms
= NULL_TREE
;
8187 if (arg_idx
> nargs
)
8190 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
8192 /* When the template parameter is a non-type template parameter pack
8193 or template template parameter pack whose type or template
8194 parameters use parameter packs, we know exactly how many arguments
8195 we are looking for. Build a vector of the instantiated decls for
8196 these template parameters in PACKED_PARMS. */
8197 /* We can't use make_pack_expansion here because it would interpret a
8198 _DECL as a use rather than a declaration. */
8199 tree decl
= TREE_VALUE (parm
);
8200 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
8201 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
8202 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
8203 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
8205 TREE_VEC_LENGTH (args
)--;
8206 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
8207 TREE_VEC_LENGTH (args
)++;
8209 if (packed_parms
== error_mark_node
)
8210 return error_mark_node
;
8212 /* If we're doing a partial instantiation of a member template,
8213 verify that all of the types used for the non-type
8214 template parameter pack are, in fact, valid for non-type
8215 template parameters. */
8217 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
8219 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
8220 for (j
= 0; j
< len
; ++j
)
8222 tree t
= TREE_VEC_ELT (packed_parms
, j
);
8223 if (TREE_CODE (t
) == PARM_DECL
8224 && invalid_nontype_parm_type_p (TREE_TYPE (t
), complain
))
8225 return error_mark_node
;
8227 /* We don't know how many args we have yet, just
8228 use the unconverted ones for now. */
8232 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
8234 /* Check if we have a placeholder pack, which indicates we're
8235 in the context of a introduction list. In that case we want
8236 to match this pack to the single placeholder. */
8237 else if (arg_idx
< nargs
8238 && TREE_CODE (TREE_VEC_ELT (inner_args
, arg_idx
)) == WILDCARD_DECL
8239 && WILDCARD_PACK_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
8241 nargs
= arg_idx
+ 1;
8242 packed_args
= make_tree_vec (1);
8245 packed_args
= make_tree_vec (nargs
- arg_idx
);
8247 /* Convert the remaining arguments, which will be a part of the
8248 parameter pack "parm". */
8249 int first_pack_arg
= arg_idx
;
8250 for (; arg_idx
< nargs
; ++arg_idx
)
8252 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
8253 tree actual_parm
= TREE_VALUE (parm
);
8254 int pack_idx
= arg_idx
- first_pack_arg
;
8258 /* Once we've packed as many args as we have types, stop. */
8259 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
8261 else if (PACK_EXPANSION_P (arg
))
8262 /* We don't know how many args we have yet, just
8263 use the unconverted ones for now. */
8266 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
8269 if (arg
== error_mark_node
)
8271 if (complain
& tf_error
)
8272 error ("template argument %d is invalid", arg_idx
+ 1);
8275 arg
= convert_template_argument (actual_parm
,
8276 arg
, new_args
, complain
, parm_idx
,
8278 if (arg
== error_mark_node
)
8280 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
8283 if (arg_idx
- first_pack_arg
< TREE_VEC_LENGTH (packed_args
)
8284 && TREE_VEC_LENGTH (packed_args
) > 0)
8286 if (complain
& tf_error
)
8287 error ("wrong number of template arguments (%d, should be %d)",
8288 arg_idx
- first_pack_arg
, TREE_VEC_LENGTH (packed_args
));
8289 return error_mark_node
;
8292 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
8293 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
8294 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
8297 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
8298 TREE_CONSTANT (argument_pack
) = 1;
8301 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
8303 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
8304 TREE_VEC_LENGTH (packed_args
));
8305 return argument_pack
;
8308 /* Returns the number of pack expansions in the template argument vector
8312 pack_expansion_args_count (tree args
)
8317 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
8319 tree elt
= TREE_VEC_ELT (args
, i
);
8320 if (elt
&& PACK_EXPANSION_P (elt
))
8326 /* Convert all template arguments to their appropriate types, and
8327 return a vector containing the innermost resulting template
8328 arguments. If any error occurs, return error_mark_node. Error and
8329 warning messages are issued under control of COMPLAIN.
8331 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
8332 for arguments not specified in ARGS. Otherwise, if
8333 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
8334 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
8335 USE_DEFAULT_ARGS is false, then all arguments must be specified in
8339 coerce_template_parms (tree parms
,
8342 tsubst_flags_t complain
,
8343 bool require_all_args
,
8344 bool use_default_args
)
8346 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
8347 tree orig_inner_args
;
8350 tree new_inner_args
;
8352 /* When used as a boolean value, indicates whether this is a
8353 variadic template parameter list. Since it's an int, we can also
8354 subtract it from nparms to get the number of non-variadic
8357 int variadic_args_p
= 0;
8358 int post_variadic_parms
= 0;
8360 /* Adjustment to nparms for fixed parameter packs. */
8361 int fixed_pack_adjust
= 0;
8362 int fixed_packs
= 0;
8365 /* Likewise for parameters with default arguments. */
8368 if (args
== error_mark_node
)
8369 return error_mark_node
;
8371 nparms
= TREE_VEC_LENGTH (parms
);
8373 /* Determine if there are any parameter packs or default arguments. */
8374 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
8376 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
8378 ++post_variadic_parms
;
8379 if (template_parameter_pack_p (TREE_VALUE (parm
)))
8381 if (TREE_PURPOSE (parm
))
8385 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
8386 /* If there are no parameters that follow a parameter pack, we need to
8387 expand any argument packs so that we can deduce a parameter pack from
8388 some non-packed args followed by an argument pack, as in variadic85.C.
8389 If there are such parameters, we need to leave argument packs intact
8390 so the arguments are assigned properly. This can happen when dealing
8391 with a nested class inside a partial specialization of a class
8392 template, as in variadic92.C, or when deducing a template parameter pack
8393 from a sub-declarator, as in variadic114.C. */
8394 if (!post_variadic_parms
)
8395 inner_args
= expand_template_argument_pack (inner_args
);
8397 /* Count any pack expansion args. */
8398 variadic_args_p
= pack_expansion_args_count (inner_args
);
8400 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
8401 if ((nargs
- variadic_args_p
> nparms
&& !variadic_p
)
8402 || (nargs
< nparms
- variadic_p
8405 && (!use_default_args
8406 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
8407 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
8410 if (complain
& tf_error
)
8412 if (variadic_p
|| default_p
)
8414 nparms
-= variadic_p
+ default_p
;
8415 error ("wrong number of template arguments "
8416 "(%d, should be at least %d)", nargs
, nparms
);
8419 error ("wrong number of template arguments "
8420 "(%d, should be %d)", nargs
, nparms
);
8423 inform (DECL_SOURCE_LOCATION (in_decl
),
8424 "provided for %qD", in_decl
);
8427 return error_mark_node
;
8429 /* We can't pass a pack expansion to a non-pack parameter of an alias
8430 template (DR 1430). */
8432 && (DECL_ALIAS_TEMPLATE_P (in_decl
)
8433 || concept_template_p (in_decl
))
8435 && nargs
- variadic_args_p
< nparms
- variadic_p
)
8437 if (complain
& tf_error
)
8439 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
8441 tree arg
= TREE_VEC_ELT (inner_args
, i
);
8442 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
8444 if (PACK_EXPANSION_P (arg
)
8445 && !template_parameter_pack_p (parm
))
8447 if (DECL_ALIAS_TEMPLATE_P (in_decl
))
8448 error_at (location_of (arg
),
8449 "pack expansion argument for non-pack parameter "
8450 "%qD of alias template %qD", parm
, in_decl
);
8452 error_at (location_of (arg
),
8453 "pack expansion argument for non-pack parameter "
8454 "%qD of concept %qD", parm
, in_decl
);
8455 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
8462 return error_mark_node
;
8465 /* We need to evaluate the template arguments, even though this
8466 template-id may be nested within a "sizeof". */
8469 new_inner_args
= make_tree_vec (nparms
);
8470 new_args
= add_outermost_template_args (args
, new_inner_args
);
8471 int pack_adjust
= 0;
8472 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
8477 /* Get the Ith template parameter. */
8478 parm
= TREE_VEC_ELT (parms
, parm_idx
);
8480 if (parm
== error_mark_node
)
8482 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
8486 /* Calculate the next argument. */
8487 if (arg_idx
< nargs
)
8488 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
8492 if (template_parameter_pack_p (TREE_VALUE (parm
))
8493 && (arg
|| require_all_args
|| !(complain
& tf_partial
))
8494 && !(arg
&& ARGUMENT_PACK_P (arg
)))
8496 /* Some arguments will be placed in the
8497 template parameter pack PARM. */
8498 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
8499 inner_args
, arg_idx
,
8503 if (arg
== NULL_TREE
)
8505 /* We don't know how many args we have yet, just use the
8506 unconverted (and still packed) ones for now. */
8507 new_inner_args
= orig_inner_args
;
8512 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
8514 /* Store this argument. */
8515 if (arg
== error_mark_node
)
8518 /* We are done with all of the arguments. */
8524 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
8525 arg_idx
+= pack_adjust
;
8526 if (fixed_parameter_pack_p (TREE_VALUE (parm
)))
8529 fixed_pack_adjust
+= pack_adjust
;
8537 if (PACK_EXPANSION_P (arg
))
8539 /* "If every valid specialization of a variadic template
8540 requires an empty template parameter pack, the template is
8541 ill-formed, no diagnostic required." So check that the
8542 pattern works with this parameter. */
8543 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
8544 tree conv
= convert_template_argument (TREE_VALUE (parm
),
8548 if (conv
== error_mark_node
)
8550 if (complain
& tf_error
)
8551 inform (input_location
, "so any instantiation with a "
8552 "non-empty parameter pack would be ill-formed");
8555 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
8556 /* Recover from missing typename. */
8557 TREE_VEC_ELT (inner_args
, arg_idx
)
8558 = make_pack_expansion (conv
, complain
);
8560 /* We don't know how many args we have yet, just
8561 use the unconverted ones for now. */
8562 new_inner_args
= inner_args
;
8567 else if (require_all_args
)
8569 /* There must be a default arg in this case. */
8570 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
8572 /* The position of the first default template argument,
8573 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
8575 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8576 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8577 arg_idx
- pack_adjust
);
8582 if (arg
== error_mark_node
)
8584 if (complain
& tf_error
)
8585 error ("template argument %d is invalid", arg_idx
+ 1);
8589 /* This can occur if there was an error in the template
8590 parameter list itself (which we would already have
8591 reported) that we are trying to recover from, e.g., a class
8592 template with a parameter list such as
8593 template<typename..., typename> (cpp0x/variadic150.C). */
8596 /* This can also happen with a fixed parameter pack (71834). */
8597 if (arg_idx
>= nargs
)
8601 arg
= convert_template_argument (TREE_VALUE (parm
),
8602 arg
, new_args
, complain
,
8605 if (arg
== error_mark_node
)
8607 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
8610 if (missing
|| arg_idx
< nargs
- variadic_args_p
)
8612 /* If we had fixed parameter packs, we didn't know how many arguments we
8613 actually needed earlier; now we do. */
8614 nparms
+= fixed_pack_adjust
;
8615 variadic_p
-= fixed_packs
;
8619 if (arg_idx
< nargs
)
8621 /* We had some pack expansion arguments that will only work if the packs
8622 are empty, but wait until instantiation time to complain.
8623 See variadic-ttp3.C. */
8624 int len
= nparms
+ (nargs
- arg_idx
);
8625 tree args
= make_tree_vec (len
);
8627 for (; i
< nparms
; ++i
)
8628 TREE_VEC_ELT (args
, i
) = TREE_VEC_ELT (new_inner_args
, i
);
8629 for (; i
< len
; ++i
, ++arg_idx
)
8630 TREE_VEC_ELT (args
, i
) = TREE_VEC_ELT (inner_args
,
8631 arg_idx
- pack_adjust
);
8632 new_inner_args
= args
;
8637 gcc_assert (!(complain
& tf_error
) || seen_error ());
8638 return error_mark_node
;
8641 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8642 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8643 TREE_VEC_LENGTH (new_inner_args
));
8645 return new_inner_args
;
8648 /* Convert all template arguments to their appropriate types, and
8649 return a vector containing the innermost resulting template
8650 arguments. If any error occurs, return error_mark_node. Error and
8651 warning messages are not issued.
8653 Note that no function argument deduction is performed, and default
8654 arguments are used to fill in unspecified arguments. */
8656 coerce_template_parms (tree parms
, tree args
, tree in_decl
)
8658 return coerce_template_parms (parms
, args
, in_decl
, tf_none
, true, true);
8661 /* Convert all template arguments to their appropriate type, and
8662 instantiate default arguments as needed. This returns a vector
8663 containing the innermost resulting template arguments, or
8664 error_mark_node if unsuccessful. */
8666 coerce_template_parms (tree parms
, tree args
, tree in_decl
,
8667 tsubst_flags_t complain
)
8669 return coerce_template_parms (parms
, args
, in_decl
, complain
, true, true);
8672 /* Like coerce_template_parms. If PARMS represents all template
8673 parameters levels, this function returns a vector of vectors
8674 representing all the resulting argument levels. Note that in this
8675 case, only the innermost arguments are coerced because the
8676 outermost ones are supposed to have been coerced already.
8678 Otherwise, if PARMS represents only (the innermost) vector of
8679 parameters, this function returns a vector containing just the
8680 innermost resulting arguments. */
8683 coerce_innermost_template_parms (tree parms
,
8686 tsubst_flags_t complain
,
8687 bool require_all_args
,
8688 bool use_default_args
)
8690 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
8691 int args_depth
= TMPL_ARGS_DEPTH (args
);
8694 if (parms_depth
> 1)
8696 coerced_args
= make_tree_vec (parms_depth
);
8700 for (level
= parms
, cur_depth
= parms_depth
;
8701 parms_depth
> 0 && level
!= NULL_TREE
;
8702 level
= TREE_CHAIN (level
), --cur_depth
)
8705 if (cur_depth
== args_depth
)
8706 l
= coerce_template_parms (TREE_VALUE (level
),
8707 args
, in_decl
, complain
,
8711 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
8713 if (l
== error_mark_node
)
8714 return error_mark_node
;
8716 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
8720 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
8721 args
, in_decl
, complain
,
8724 return coerced_args
;
8727 /* Returns 1 if template args OT and NT are equivalent. */
8730 template_args_equal (tree ot
, tree nt
, bool partial_order
/* = false */)
8734 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
8736 if (nt
== any_targ_node
|| ot
== any_targ_node
)
8739 if (TREE_CODE (nt
) == TREE_VEC
)
8740 /* For member templates */
8741 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
8742 else if (PACK_EXPANSION_P (ot
))
8743 return (PACK_EXPANSION_P (nt
)
8744 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
8745 PACK_EXPANSION_PATTERN (nt
))
8746 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
8747 PACK_EXPANSION_EXTRA_ARGS (nt
)));
8748 else if (ARGUMENT_PACK_P (ot
))
8753 if (!ARGUMENT_PACK_P (nt
))
8756 opack
= ARGUMENT_PACK_ARGS (ot
);
8757 npack
= ARGUMENT_PACK_ARGS (nt
);
8758 len
= TREE_VEC_LENGTH (opack
);
8759 if (TREE_VEC_LENGTH (npack
) != len
)
8761 for (i
= 0; i
< len
; ++i
)
8762 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
8763 TREE_VEC_ELT (npack
, i
)))
8767 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
8769 else if (TYPE_P (nt
))
8773 /* Don't treat an alias template specialization with dependent
8774 arguments as equivalent to its underlying type when used as a
8775 template argument; we need them to be distinct so that we
8776 substitute into the specialization arguments at instantiation
8777 time. And aliases can't be equivalent without being ==, so
8778 we don't need to look any deeper.
8780 During partial ordering, however, we need to treat them normally so
8781 that we can order uses of the same alias with different
8782 cv-qualification (79960). */
8784 && (TYPE_ALIAS_P (nt
) || TYPE_ALIAS_P (ot
)))
8787 return same_type_p (ot
, nt
);
8789 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
8793 /* Try to treat a template non-type argument that has been converted
8794 to the parameter type as equivalent to one that hasn't yet. */
8795 for (enum tree_code code1
= TREE_CODE (ot
);
8796 CONVERT_EXPR_CODE_P (code1
)
8797 || code1
== NON_LVALUE_EXPR
;
8798 code1
= TREE_CODE (ot
))
8799 ot
= TREE_OPERAND (ot
, 0);
8800 for (enum tree_code code2
= TREE_CODE (nt
);
8801 CONVERT_EXPR_CODE_P (code2
)
8802 || code2
== NON_LVALUE_EXPR
;
8803 code2
= TREE_CODE (nt
))
8804 nt
= TREE_OPERAND (nt
, 0);
8806 return cp_tree_equal (ot
, nt
);
8810 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
8811 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
8812 NEWARG_PTR with the offending arguments if they are non-NULL. */
8815 comp_template_args (tree oldargs
, tree newargs
,
8816 tree
*oldarg_ptr
, tree
*newarg_ptr
,
8821 if (oldargs
== newargs
)
8824 if (!oldargs
|| !newargs
)
8827 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
8830 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
8832 tree nt
= TREE_VEC_ELT (newargs
, i
);
8833 tree ot
= TREE_VEC_ELT (oldargs
, i
);
8835 if (! template_args_equal (ot
, nt
, partial_order
))
8837 if (oldarg_ptr
!= NULL
)
8839 if (newarg_ptr
!= NULL
)
8848 comp_template_args_porder (tree oargs
, tree nargs
)
8850 return comp_template_args (oargs
, nargs
, NULL
, NULL
, true);
8853 /* Implement a freelist interface for objects of type T.
8855 Head is a separate object, rather than a regular member, so that we
8856 can define it as a GTY deletable pointer, which is highly
8857 desirable. A data member could be declared that way, but then the
8858 containing object would implicitly get GTY((user)), which would
8859 prevent us from instantiating freelists as global objects.
8860 Although this way we can create freelist global objects, they're
8861 such thin wrappers that instantiating temporaries at every use
8862 loses nothing and saves permanent storage for the freelist object.
8864 Member functions next, anew, poison and reinit have default
8865 implementations that work for most of the types we're interested
8866 in, but if they don't work for some type, they should be explicitly
8867 specialized. See the comments before them for requirements, and
8868 the example specializations for the tree_list_freelist. */
8869 template <typename T
>
8872 /* Return the next object in a chain. We could just do type
8873 punning, but if we access the object with its underlying type, we
8874 avoid strict-aliasing trouble. This needs only work between
8875 poison and reinit. */
8876 static T
*&next (T
*obj
) { return obj
->next
; }
8878 /* Return a newly allocated, uninitialized or minimally-initialized
8879 object of type T. Any initialization performed by anew should
8880 either remain across the life of the object and the execution of
8881 poison, or be redone by reinit. */
8882 static T
*anew () { return ggc_alloc
<T
> (); }
8884 /* Optionally scribble all over the bits holding the object, so that
8885 they become (mostly?) uninitialized memory. This is called while
8886 preparing to make the object part of the free list. */
8887 static void poison (T
*obj
) {
8888 T
*p ATTRIBUTE_UNUSED
= obj
;
8889 T
**q ATTRIBUTE_UNUSED
= &next (obj
);
8891 #ifdef ENABLE_GC_CHECKING
8892 /* Poison the data, to indicate the data is garbage. */
8893 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (p
, sizeof (*p
)));
8894 memset (p
, 0xa5, sizeof (*p
));
8896 /* Let valgrind know the object is free. */
8897 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (p
, sizeof (*p
)));
8899 /* Let valgrind know the next portion of the object is available,
8900 but uninitialized. */
8901 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (q
, sizeof (*q
)));
8904 /* Bring an object that underwent at least one lifecycle after anew
8905 and before the most recent free and poison, back to a usable
8906 state, reinitializing whatever is needed for it to be
8907 functionally equivalent to an object just allocated and returned
8908 by anew. This may poison or clear the next field, used by
8909 freelist housekeeping after poison was called. */
8910 static void reinit (T
*obj
) {
8911 T
**q ATTRIBUTE_UNUSED
= &next (obj
);
8913 #ifdef ENABLE_GC_CHECKING
8914 memset (q
, 0xa5, sizeof (*q
));
8916 /* Let valgrind know the entire object is available, but
8918 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (*obj
)));
8921 /* Reference a GTY-deletable pointer that points to the first object
8922 in the free list proper. */
8925 /* Construct a freelist object chaining objects off of HEAD. */
8926 freelist (T
*&head
) : head(head
) {}
8928 /* Add OBJ to the free object list. The former head becomes OBJ's
8937 /* Take an object from the free list, if one is available, or
8938 allocate a new one. Objects taken from the free list should be
8939 regarded as filled with garbage, except for bits that are
8940 configured to be preserved across free and alloc. */
8955 /* Explicitly specialize the interfaces for freelist<tree_node>: we
8956 want to allocate a TREE_LIST using the usual interface, and ensure
8957 TREE_CHAIN remains functional. Alas, we have to duplicate a bit of
8958 build_tree_list logic in reinit, so this could go out of sync. */
8961 freelist
<tree_node
>::next (tree obj
)
8963 return TREE_CHAIN (obj
);
8967 freelist
<tree_node
>::anew ()
8969 return build_tree_list (NULL
, NULL
);
8973 freelist
<tree_node
>::poison (tree obj ATTRIBUTE_UNUSED
)
8975 int size ATTRIBUTE_UNUSED
= sizeof (tree_list
);
8976 tree p ATTRIBUTE_UNUSED
= obj
;
8977 tree_base
*b ATTRIBUTE_UNUSED
= &obj
->base
;
8978 tree
*q ATTRIBUTE_UNUSED
= &next (obj
);
8980 #ifdef ENABLE_GC_CHECKING
8981 gcc_checking_assert (TREE_CODE (obj
) == TREE_LIST
);
8983 /* Poison the data, to indicate the data is garbage. */
8984 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (p
, size
));
8985 memset (p
, 0xa5, size
);
8987 /* Let valgrind know the object is free. */
8988 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (p
, size
));
8989 /* But we still want to use the TREE_CODE and TREE_CHAIN parts. */
8990 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
8991 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (q
, sizeof (*q
)));
8993 #ifdef ENABLE_GC_CHECKING
8994 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (b
, sizeof (*b
)));
8995 /* Keep TREE_CHAIN functional. */
8996 TREE_SET_CODE (obj
, TREE_LIST
);
8998 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
9003 freelist
<tree_node
>::reinit (tree obj ATTRIBUTE_UNUSED
)
9005 tree_base
*b ATTRIBUTE_UNUSED
= &obj
->base
;
9007 #ifdef ENABLE_GC_CHECKING
9008 gcc_checking_assert (TREE_CODE (obj
) == TREE_LIST
);
9009 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (tree_list
)));
9010 memset (obj
, 0, sizeof (tree_list
));
9013 /* Let valgrind know the entire object is available, but
9015 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (tree_list
)));
9017 #ifdef ENABLE_GC_CHECKING
9018 TREE_SET_CODE (obj
, TREE_LIST
);
9020 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
9024 /* Point to the first object in the TREE_LIST freelist. */
9025 static GTY((deletable
)) tree tree_list_freelist_head
;
9026 /* Return the/an actual TREE_LIST freelist. */
9027 static inline freelist
<tree_node
>
9028 tree_list_freelist ()
9030 return tree_list_freelist_head
;
9033 /* Point to the first object in the tinst_level freelist. */
9034 static GTY((deletable
)) tinst_level
*tinst_level_freelist_head
;
9035 /* Return the/an actual tinst_level freelist. */
9036 static inline freelist
<tinst_level
>
9037 tinst_level_freelist ()
9039 return tinst_level_freelist_head
;
9042 /* Point to the first object in the pending_template freelist. */
9043 static GTY((deletable
)) pending_template
*pending_template_freelist_head
;
9044 /* Return the/an actual pending_template freelist. */
9045 static inline freelist
<pending_template
>
9046 pending_template_freelist ()
9048 return pending_template_freelist_head
;
9051 /* Build the TREE_LIST object out of a split list, store it
9052 permanently, and return it. */
9054 tinst_level::to_list ()
9056 gcc_assert (split_list_p ());
9057 tree ret
= tree_list_freelist ().alloc ();
9058 TREE_PURPOSE (ret
) = tldcl
;
9059 TREE_VALUE (ret
) = targs
;
9062 gcc_assert (tree_list_p ());
9066 const unsigned short tinst_level::refcount_infinity
;
9068 /* Increment OBJ's refcount unless it is already infinite. */
9069 static tinst_level
*
9070 inc_refcount_use (tinst_level
*obj
)
9072 if (obj
&& obj
->refcount
!= tinst_level::refcount_infinity
)
9077 /* Release storage for OBJ and node, if it's a TREE_LIST. */
9079 tinst_level::free (tinst_level
*obj
)
9081 if (obj
->tree_list_p ())
9082 tree_list_freelist ().free (obj
->get_node ());
9083 tinst_level_freelist ().free (obj
);
9086 /* Decrement OBJ's refcount if not infinite. If it reaches zero, release
9087 OBJ's DECL and OBJ, and start over with the tinst_level object that
9088 used to be referenced by OBJ's NEXT. */
9090 dec_refcount_use (tinst_level
*obj
)
9093 && obj
->refcount
!= tinst_level::refcount_infinity
9094 && !--obj
->refcount
)
9096 tinst_level
*next
= obj
->next
;
9097 tinst_level::free (obj
);
9102 /* Modify PTR so that it points to OBJ, adjusting the refcounts of OBJ
9103 and of the former PTR. Omitting the second argument is equivalent
9104 to passing (T*)NULL; this is allowed because passing the
9105 zero-valued integral constant NULL confuses type deduction and/or
9106 overload resolution. */
9107 template <typename T
>
9109 set_refcount_ptr (T
*& ptr
, T
*obj
= NULL
)
9112 ptr
= inc_refcount_use (obj
);
9113 dec_refcount_use (save
);
9117 add_pending_template (tree d
)
9119 tree ti
= (TYPE_P (d
)
9120 ? CLASSTYPE_TEMPLATE_INFO (d
)
9121 : DECL_TEMPLATE_INFO (d
));
9122 struct pending_template
*pt
;
9125 if (TI_PENDING_TEMPLATE_FLAG (ti
))
9128 /* We are called both from instantiate_decl, where we've already had a
9129 tinst_level pushed, and instantiate_template, where we haven't.
9131 gcc_assert (TREE_CODE (d
) != TREE_LIST
);
9132 level
= !current_tinst_level
9133 || current_tinst_level
->maybe_get_node () != d
;
9136 push_tinst_level (d
);
9138 pt
= pending_template_freelist ().alloc ();
9141 set_refcount_ptr (pt
->tinst
, current_tinst_level
);
9142 if (last_pending_template
)
9143 last_pending_template
->next
= pt
;
9145 pending_templates
= pt
;
9147 last_pending_template
= pt
;
9149 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
9156 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
9157 ARGLIST. Valid choices for FNS are given in the cp-tree.def
9158 documentation for TEMPLATE_ID_EXPR. */
9161 lookup_template_function (tree fns
, tree arglist
)
9163 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
9164 return error_mark_node
;
9166 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
9168 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
9170 error ("%q#D is not a function template", fns
);
9171 return error_mark_node
;
9174 if (BASELINK_P (fns
))
9176 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
9178 BASELINK_FUNCTIONS (fns
),
9183 return build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fns
, arglist
);
9186 /* Within the scope of a template class S<T>, the name S gets bound
9187 (in build_self_reference) to a TYPE_DECL for the class, not a
9188 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
9189 or one of its enclosing classes, and that type is a template,
9190 return the associated TEMPLATE_DECL. Otherwise, the original
9193 Also handle the case when DECL is a TREE_LIST of ambiguous
9194 injected-class-names from different bases. */
9197 maybe_get_template_decl_from_type_decl (tree decl
)
9199 if (decl
== NULL_TREE
)
9202 /* DR 176: A lookup that finds an injected-class-name (10.2
9203 [class.member.lookup]) can result in an ambiguity in certain cases
9204 (for example, if it is found in more than one base class). If all of
9205 the injected-class-names that are found refer to specializations of
9206 the same class template, and if the name is followed by a
9207 template-argument-list, the reference refers to the class template
9208 itself and not a specialization thereof, and is not ambiguous. */
9209 if (TREE_CODE (decl
) == TREE_LIST
)
9211 tree t
, tmpl
= NULL_TREE
;
9212 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
9214 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
9217 else if (tmpl
!= elt
)
9220 if (tmpl
&& t
== NULL_TREE
)
9226 return (decl
!= NULL_TREE
9227 && DECL_SELF_REFERENCE_P (decl
)
9228 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
9229 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
9232 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
9233 parameters, find the desired type.
9235 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
9237 IN_DECL, if non-NULL, is the template declaration we are trying to
9240 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
9241 the class we are looking up.
9243 Issue error and warning messages under control of COMPLAIN.
9245 If the template class is really a local class in a template
9246 function, then the FUNCTION_CONTEXT is the function in which it is
9249 ??? Note that this function is currently called *twice* for each
9250 template-id: the first time from the parser, while creating the
9251 incomplete type (finish_template_type), and the second type during the
9252 real instantiation (instantiate_template_class). This is surely something
9253 that we want to avoid. It also causes some problems with argument
9254 coercion (see convert_nontype_argument for more information on this). */
9257 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
9258 int entering_scope
, tsubst_flags_t complain
)
9260 tree templ
= NULL_TREE
, parmlist
;
9267 if (identifier_p (d1
))
9269 tree value
= innermost_non_namespace_value (d1
);
9270 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
9275 push_decl_namespace (context
);
9276 templ
= lookup_name (d1
);
9277 templ
= maybe_get_template_decl_from_type_decl (templ
);
9279 pop_decl_namespace ();
9282 context
= DECL_CONTEXT (templ
);
9284 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
9286 tree type
= TREE_TYPE (d1
);
9288 /* If we are declaring a constructor, say A<T>::A<T>, we will get
9289 an implicit typename for the second A. Deal with it. */
9290 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
9291 type
= TREE_TYPE (type
);
9293 if (CLASSTYPE_TEMPLATE_INFO (type
))
9295 templ
= CLASSTYPE_TI_TEMPLATE (type
);
9296 d1
= DECL_NAME (templ
);
9299 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
9300 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
9302 templ
= TYPE_TI_TEMPLATE (d1
);
9303 d1
= DECL_NAME (templ
);
9305 else if (DECL_TYPE_TEMPLATE_P (d1
))
9308 d1
= DECL_NAME (templ
);
9309 context
= DECL_CONTEXT (templ
);
9311 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
9314 d1
= DECL_NAME (templ
);
9317 /* Issue an error message if we didn't find a template. */
9320 if (complain
& tf_error
)
9321 error ("%qT is not a template", d1
);
9322 return error_mark_node
;
9325 if (TREE_CODE (templ
) != TEMPLATE_DECL
9326 /* Make sure it's a user visible template, if it was named by
9328 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
9329 && !PRIMARY_TEMPLATE_P (templ
)))
9331 if (complain
& tf_error
)
9333 error ("non-template type %qT used as a template", d1
);
9335 error ("for template declaration %q+D", in_decl
);
9337 return error_mark_node
;
9340 complain
&= ~tf_user
;
9342 /* An alias that just changes the name of a template is equivalent to the
9343 other template, so if any of the arguments are pack expansions, strip
9344 the alias to avoid problems with a pack expansion passed to a non-pack
9345 alias template parameter (DR 1430). */
9346 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
9347 templ
= get_underlying_template (templ
);
9349 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
9352 tree arglist2
= coerce_template_args_for_ttp (templ
, arglist
, complain
);
9353 if (arglist2
== error_mark_node
9354 || (!uses_template_parms (arglist2
)
9355 && check_instantiated_args (templ
, arglist2
, complain
)))
9356 return error_mark_node
;
9358 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
9363 tree template_type
= TREE_TYPE (templ
);
9366 tree found
= NULL_TREE
;
9369 int is_dependent_type
;
9370 int use_partial_inst_tmpl
= false;
9372 if (template_type
== error_mark_node
)
9373 /* An error occurred while building the template TEMPL, and a
9374 diagnostic has most certainly been emitted for that
9375 already. Let's propagate that error. */
9376 return error_mark_node
;
9378 gen_tmpl
= most_general_template (templ
);
9379 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
9380 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
9381 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
9383 if (arg_depth
== 1 && parm_depth
> 1)
9385 /* We've been given an incomplete set of template arguments.
9388 template <class T> struct S1 {
9389 template <class U> struct S2 {};
9390 template <class U> struct S2<U*> {};
9393 we will be called with an ARGLIST of `U*', but the
9394 TEMPLATE will be `template <class T> template
9395 <class U> struct S1<T>::S2'. We must fill in the missing
9397 tree ti
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (templ
));
9398 arglist
= add_outermost_template_args (TI_ARGS (ti
), arglist
);
9399 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
9402 /* Now we should have enough arguments. */
9403 gcc_assert (parm_depth
== arg_depth
);
9405 /* From here on, we're only interested in the most general
9408 /* Calculate the BOUND_ARGS. These will be the args that are
9409 actually tsubst'd into the definition to create the
9411 arglist
= coerce_innermost_template_parms (parmlist
, arglist
, gen_tmpl
,
9413 /*require_all_args=*/true,
9414 /*use_default_args=*/true);
9416 if (arglist
== error_mark_node
)
9417 /* We were unable to bind the arguments. */
9418 return error_mark_node
;
9420 /* In the scope of a template class, explicit references to the
9421 template class refer to the type of the template, not any
9422 instantiation of it. For example, in:
9424 template <class T> class C { void f(C<T>); }
9426 the `C<T>' is just the same as `C'. Outside of the
9427 class, however, such a reference is an instantiation. */
9429 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
9430 || currently_open_class (template_type
))
9432 tree tinfo
= TYPE_TEMPLATE_INFO (template_type
);
9434 if (tinfo
&& comp_template_args (TI_ARGS (tinfo
), arglist
))
9435 return template_type
;
9438 /* If we already have this specialization, return it. */
9439 elt
.tmpl
= gen_tmpl
;
9441 elt
.spec
= NULL_TREE
;
9442 hash
= spec_hasher::hash (&elt
);
9443 entry
= type_specializations
->find_with_hash (&elt
, hash
);
9448 /* If the the template's constraints are not satisfied,
9449 then we cannot form a valid type.
9451 Note that the check is deferred until after the hash
9452 lookup. This prevents redundant checks on previously
9453 instantiated specializations. */
9454 if (flag_concepts
&& !constraints_satisfied_p (gen_tmpl
, arglist
))
9456 if (complain
& tf_error
)
9458 auto_diagnostic_group d
;
9459 error ("template constraint failure");
9460 diagnose_constraints (input_location
, gen_tmpl
, arglist
);
9462 return error_mark_node
;
9465 is_dependent_type
= uses_template_parms (arglist
);
9467 /* If the deduced arguments are invalid, then the binding
9469 if (!is_dependent_type
9470 && check_instantiated_args (gen_tmpl
,
9471 INNERMOST_TEMPLATE_ARGS (arglist
),
9473 return error_mark_node
;
9475 if (!is_dependent_type
9476 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
9477 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
9478 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
9480 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
9481 DECL_NAME (gen_tmpl
),
9482 /*tag_scope=*/ts_global
);
9486 context
= DECL_CONTEXT (gen_tmpl
);
9487 if (context
&& TYPE_P (context
))
9489 context
= tsubst_aggr_type (context
, arglist
, complain
, in_decl
, true);
9490 context
= complete_type (context
);
9493 context
= tsubst (context
, arglist
, complain
, in_decl
);
9495 if (context
== error_mark_node
)
9496 return error_mark_node
;
9499 context
= global_namespace
;
9501 /* Create the type. */
9502 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9504 /* The user referred to a specialization of an alias
9505 template represented by GEN_TMPL.
9507 [temp.alias]/2 says:
9509 When a template-id refers to the specialization of an
9510 alias template, it is equivalent to the associated
9511 type obtained by substitution of its
9512 template-arguments for the template-parameters in the
9513 type-id of the alias template. */
9515 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
9516 /* Note that the call above (by indirectly calling
9517 register_specialization in tsubst_decl) registers the
9518 TYPE_DECL representing the specialization of the alias
9519 template. So next time someone substitutes ARGLIST for
9520 the template parms into the alias template (GEN_TMPL),
9521 she'll get that TYPE_DECL back. */
9523 if (t
== error_mark_node
)
9526 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
9528 if (!is_dependent_type
)
9530 set_current_access_from_decl (TYPE_NAME (template_type
));
9531 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
9532 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
9533 arglist
, complain
, in_decl
),
9534 tsubst_attributes (TYPE_ATTRIBUTES (template_type
),
9535 arglist
, complain
, in_decl
),
9536 SCOPED_ENUM_P (template_type
), NULL
);
9538 if (t
== error_mark_node
)
9543 /* We don't want to call start_enum for this type, since
9544 the values for the enumeration constants may involve
9545 template parameters. And, no one should be interested
9546 in the enumeration constants for such a type. */
9547 t
= cxx_make_type (ENUMERAL_TYPE
);
9548 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
9550 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
9551 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
9552 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
9554 else if (CLASS_TYPE_P (template_type
))
9556 /* Lambda closures are regenerated in tsubst_lambda_expr, not
9557 instantiated here. */
9558 gcc_assert (!LAMBDA_TYPE_P (template_type
));
9560 t
= make_class_type (TREE_CODE (template_type
));
9561 CLASSTYPE_DECLARED_CLASS (t
)
9562 = CLASSTYPE_DECLARED_CLASS (template_type
);
9563 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
9565 /* A local class. Make sure the decl gets registered properly. */
9566 if (context
== current_function_decl
)
9567 if (pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
)
9569 return error_mark_node
;
9571 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
9572 /* This instantiation is another name for the primary
9573 template type. Set the TYPE_CANONICAL field
9575 TYPE_CANONICAL (t
) = template_type
;
9576 else if (any_template_arguments_need_structural_equality_p (arglist
))
9577 /* Some of the template arguments require structural
9578 equality testing, so this template class requires
9579 structural equality testing. */
9580 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9585 /* If we called start_enum or pushtag above, this information
9586 will already be set up. */
9589 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
9591 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
9592 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
9593 DECL_SOURCE_LOCATION (type_decl
)
9594 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
9597 type_decl
= TYPE_NAME (t
);
9599 if (CLASS_TYPE_P (template_type
))
9601 TREE_PRIVATE (type_decl
)
9602 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
9603 TREE_PROTECTED (type_decl
)
9604 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
9605 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
9607 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
9608 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
9612 if (OVERLOAD_TYPE_P (t
)
9613 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9615 static const char *tags
[] = {"abi_tag", "may_alias"};
9617 for (unsigned ix
= 0; ix
!= 2; ix
++)
9620 = lookup_attribute (tags
[ix
], TYPE_ATTRIBUTES (template_type
));
9624 = tree_cons (TREE_PURPOSE (attributes
),
9625 TREE_VALUE (attributes
),
9626 TYPE_ATTRIBUTES (t
));
9630 /* Let's consider the explicit specialization of a member
9631 of a class template specialization that is implicitly instantiated,
9636 template<class U> struct M {}; //#0
9641 struct S<int>::M<char> //#1
9645 [temp.expl.spec]/4 says this is valid.
9647 In this case, when we write:
9650 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
9653 When we encounter #1, we want to store the partial instantiation
9654 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
9656 For all cases other than this "explicit specialization of member of a
9657 class template", we just want to store the most general template into
9658 the CLASSTYPE_TI_TEMPLATE of M.
9660 This case of "explicit specialization of member of a class template"
9662 1/ the enclosing class is an instantiation of, and therefore not
9663 the same as, the context of the most general template, and
9664 2/ we aren't looking at the partial instantiation itself, i.e.
9665 the innermost arguments are not the same as the innermost parms of
9666 the most general template.
9668 So it's only when 1/ and 2/ happens that we want to use the partial
9669 instantiation of the member template in lieu of its most general
9672 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
9673 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
9674 /* the enclosing class must be an instantiation... */
9675 && CLASS_TYPE_P (context
)
9676 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
9678 TREE_VEC_LENGTH (arglist
)--;
9679 ++processing_template_decl
;
9680 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (gen_tmpl
));
9681 tree partial_inst_args
=
9682 tsubst (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
)),
9683 arglist
, complain
, NULL_TREE
);
9684 --processing_template_decl
;
9685 TREE_VEC_LENGTH (arglist
)++;
9686 if (partial_inst_args
== error_mark_node
)
9687 return error_mark_node
;
9688 use_partial_inst_tmpl
=
9689 /*...and we must not be looking at the partial instantiation
9691 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
9695 if (!use_partial_inst_tmpl
)
9696 /* This case is easy; there are no member templates involved. */
9700 /* This is a full instantiation of a member template. Find
9701 the partial instantiation of which this is an instance. */
9703 /* Temporarily reduce by one the number of levels in the ARGLIST
9704 so as to avoid comparing the last set of arguments. */
9705 TREE_VEC_LENGTH (arglist
)--;
9706 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
9707 TREE_VEC_LENGTH (arglist
)++;
9708 /* FOUND is either a proper class type, or an alias
9709 template specialization. In the later case, it's a
9710 TYPE_DECL, resulting from the substituting of arguments
9711 for parameters in the TYPE_DECL of the alias template
9712 done earlier. So be careful while getting the template
9714 found
= (TREE_CODE (found
) == TEMPLATE_DECL
9716 : (TREE_CODE (found
) == TYPE_DECL
9717 ? DECL_TI_TEMPLATE (found
)
9718 : CLASSTYPE_TI_TEMPLATE (found
)));
9720 if (DECL_CLASS_TEMPLATE_P (found
)
9721 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (found
)))
9723 /* If this partial instantiation is specialized, we want to
9724 use it for hash table lookup. */
9726 elt
.args
= arglist
= INNERMOST_TEMPLATE_ARGS (arglist
);
9727 hash
= spec_hasher::hash (&elt
);
9731 // Build template info for the new specialization.
9732 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
9735 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
9736 gcc_checking_assert (*slot
== NULL
);
9737 entry
= ggc_alloc
<spec_entry
> ();
9741 /* Note this use of the partial instantiation so we can check it
9742 later in maybe_process_partial_specialization. */
9743 DECL_TEMPLATE_INSTANTIATIONS (found
)
9744 = tree_cons (arglist
, t
,
9745 DECL_TEMPLATE_INSTANTIATIONS (found
));
9747 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
9748 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9749 /* Now that the type has been registered on the instantiations
9750 list, we set up the enumerators. Because the enumeration
9751 constants may involve the enumeration type itself, we make
9752 sure to register the type first, and then create the
9753 constants. That way, doing tsubst_expr for the enumeration
9754 constants won't result in recursive calls here; we'll find
9755 the instantiation and exit above. */
9756 tsubst_enum (template_type
, t
, arglist
);
9758 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
9759 /* If the type makes use of template parameters, the
9760 code that generates debugging information will crash. */
9761 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
9763 /* Possibly limit visibility based on template args. */
9764 TREE_PUBLIC (type_decl
) = 1;
9765 determine_visibility (type_decl
);
9767 inherit_targ_abi_tags (t
);
9773 /* Wrapper for lookup_template_class_1. */
9776 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
9777 int entering_scope
, tsubst_flags_t complain
)
9780 timevar_push (TV_TEMPLATE_INST
);
9781 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
9782 entering_scope
, complain
);
9783 timevar_pop (TV_TEMPLATE_INST
);
9787 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
9790 lookup_template_variable (tree templ
, tree arglist
)
9792 /* The type of the expression is NULL_TREE since the template-id could refer
9793 to an explicit or partial specialization. */
9794 tree type
= NULL_TREE
;
9795 if (flag_concepts
&& variable_concept_p (templ
))
9796 /* Except that concepts are always bool. */
9797 type
= boolean_type_node
;
9798 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
9801 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
9804 finish_template_variable (tree var
, tsubst_flags_t complain
)
9806 tree templ
= TREE_OPERAND (var
, 0);
9807 tree arglist
= TREE_OPERAND (var
, 1);
9809 /* We never want to return a VAR_DECL for a variable concept, since they
9810 aren't instantiated. In a template, leave the TEMPLATE_ID_EXPR alone. */
9811 bool concept_p
= flag_concepts
&& variable_concept_p (templ
);
9812 if (concept_p
&& processing_template_decl
)
9815 tree tmpl_args
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ
));
9816 arglist
= add_outermost_template_args (tmpl_args
, arglist
);
9818 templ
= most_general_template (templ
);
9819 tree parms
= DECL_TEMPLATE_PARMS (templ
);
9820 arglist
= coerce_innermost_template_parms (parms
, arglist
, templ
, complain
,
9822 /*use_default*/true);
9824 if (flag_concepts
&& !constraints_satisfied_p (templ
, arglist
))
9826 if (complain
& tf_error
)
9828 auto_diagnostic_group d
;
9829 error ("use of invalid variable template %qE", var
);
9830 diagnose_constraints (location_of (var
), templ
, arglist
);
9832 return error_mark_node
;
9835 /* If a template-id refers to a specialization of a variable
9836 concept, then the expression is true if and only if the
9837 concept's constraints are satisfied by the given template
9840 NOTE: This is an extension of Concepts Lite TS that
9841 allows constraints to be used in expressions. */
9844 tree decl
= DECL_TEMPLATE_RESULT (templ
);
9845 return evaluate_variable_concept (decl
, arglist
);
9848 return instantiate_template (templ
, arglist
, complain
);
9851 /* Construct a TEMPLATE_ID_EXPR for the given variable template TEMPL having
9852 TARGS template args, and instantiate it if it's not dependent. */
9855 lookup_and_finish_template_variable (tree templ
, tree targs
,
9856 tsubst_flags_t complain
)
9858 templ
= lookup_template_variable (templ
, targs
);
9859 if (!any_dependent_template_arguments_p (targs
))
9861 templ
= finish_template_variable (templ
, complain
);
9865 return convert_from_reference (templ
);
9874 /* True when we should also visit template parameters that occur in
9875 non-deduced contexts. */
9876 bool include_nondeduced_p
;
9877 hash_set
<tree
> *visited
;
9880 /* Called from for_each_template_parm via walk_tree. */
9883 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
9886 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
9887 tree_fn_t fn
= pfd
->fn
;
9888 void *data
= pfd
->data
;
9889 tree result
= NULL_TREE
;
9891 #define WALK_SUBTREE(NODE) \
9894 result = for_each_template_parm (NODE, fn, data, pfd->visited, \
9895 pfd->include_nondeduced_p, \
9897 if (result) goto out; \
9901 if (pfd
->any_fn
&& (*pfd
->any_fn
)(t
, data
))
9905 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
))
9906 WALK_SUBTREE (TYPE_CONTEXT (t
));
9908 switch (TREE_CODE (t
))
9911 if (TYPE_PTRMEMFUNC_P (t
))
9917 if (!TYPE_TEMPLATE_INFO (t
))
9920 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9924 WALK_SUBTREE (TYPE_MIN_VALUE (t
));
9925 WALK_SUBTREE (TYPE_MAX_VALUE (t
));
9929 /* Since we're not going to walk subtrees, we have to do this
9931 WALK_SUBTREE (TYPE_METHOD_BASETYPE (t
));
9935 /* Check the return type. */
9936 WALK_SUBTREE (TREE_TYPE (t
));
9938 /* Check the parameter types. Since default arguments are not
9939 instantiated until they are needed, the TYPE_ARG_TYPES may
9940 contain expressions that involve template parameters. But,
9941 no-one should be looking at them yet. And, once they're
9942 instantiated, they don't contain template parameters, so
9943 there's no point in looking at them then, either. */
9947 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
9948 WALK_SUBTREE (TREE_VALUE (parm
));
9950 /* Since we've already handled the TYPE_ARG_TYPES, we don't
9951 want walk_tree walking into them itself. */
9955 if (flag_noexcept_type
)
9957 tree spec
= TYPE_RAISES_EXCEPTIONS (t
);
9959 WALK_SUBTREE (TREE_PURPOSE (spec
));
9965 case UNDERLYING_TYPE
:
9966 if (pfd
->include_nondeduced_p
9967 && for_each_template_parm (TYPE_VALUES_RAW (t
), fn
, data
,
9969 pfd
->include_nondeduced_p
,
9971 return error_mark_node
;
9972 *walk_subtrees
= false;
9977 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
9978 WALK_SUBTREE (DECL_TI_ARGS (t
));
9983 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
))
9984 WALK_SUBTREE (DECL_INITIAL (t
));
9985 if (DECL_CONTEXT (t
)
9986 && pfd
->include_nondeduced_p
)
9987 WALK_SUBTREE (DECL_CONTEXT (t
));
9990 case BOUND_TEMPLATE_TEMPLATE_PARM
:
9991 /* Record template parameters such as `T' inside `TT<T>'. */
9992 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9995 case TEMPLATE_TEMPLATE_PARM
:
9996 case TEMPLATE_TYPE_PARM
:
9997 case TEMPLATE_PARM_INDEX
:
9998 if (fn
&& (*fn
)(t
, data
))
10004 case TEMPLATE_DECL
:
10005 /* A template template parameter is encountered. */
10006 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10007 WALK_SUBTREE (TREE_TYPE (t
));
10009 /* Already substituted template template parameter */
10010 *walk_subtrees
= 0;
10013 case TYPENAME_TYPE
:
10014 /* A template-id in a TYPENAME_TYPE might be a deduced context after
10015 partial instantiation. */
10016 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t
));
10020 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
10021 && pfd
->include_nondeduced_p
)
10022 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
10026 case COMPONENT_REF
:
10027 /* If there's no type, then this thing must be some expression
10028 involving template parameters. */
10029 if (!fn
&& !TREE_TYPE (t
))
10030 return error_mark_node
;
10035 case IMPLICIT_CONV_EXPR
:
10036 case REINTERPRET_CAST_EXPR
:
10037 case CONST_CAST_EXPR
:
10038 case STATIC_CAST_EXPR
:
10039 case DYNAMIC_CAST_EXPR
:
10043 case PSEUDO_DTOR_EXPR
:
10045 return error_mark_node
;
10052 #undef WALK_SUBTREE
10054 /* We didn't find any template parameters we liked. */
10059 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
10060 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
10061 call FN with the parameter and the DATA.
10062 If FN returns nonzero, the iteration is terminated, and
10063 for_each_template_parm returns 1. Otherwise, the iteration
10064 continues. If FN never returns a nonzero value, the value
10065 returned by for_each_template_parm is 0. If FN is NULL, it is
10066 considered to be the function which always returns 1.
10068 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
10069 parameters that occur in non-deduced contexts. When false, only
10070 visits those template parameters that can be deduced. */
10073 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
10074 hash_set
<tree
> *visited
,
10075 bool include_nondeduced_p
,
10078 struct pair_fn_data pfd
;
10083 pfd
.any_fn
= any_fn
;
10085 pfd
.include_nondeduced_p
= include_nondeduced_p
;
10087 /* Walk the tree. (Conceptually, we would like to walk without
10088 duplicates, but for_each_template_parm_r recursively calls
10089 for_each_template_parm, so we would need to reorganize a fair
10090 bit to use walk_tree_without_duplicates, so we keep our own
10093 pfd
.visited
= visited
;
10095 pfd
.visited
= new hash_set
<tree
>;
10096 result
= cp_walk_tree (&t
,
10097 for_each_template_parm_r
,
10104 delete pfd
.visited
;
10111 /* Returns true if T depends on any template parameter. */
10114 uses_template_parms (tree t
)
10116 if (t
== NULL_TREE
)
10120 int saved_processing_template_decl
;
10122 saved_processing_template_decl
= processing_template_decl
;
10123 if (!saved_processing_template_decl
)
10124 processing_template_decl
= 1;
10126 dependent_p
= dependent_type_p (t
);
10127 else if (TREE_CODE (t
) == TREE_VEC
)
10128 dependent_p
= any_dependent_template_arguments_p (t
);
10129 else if (TREE_CODE (t
) == TREE_LIST
)
10130 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
10131 || uses_template_parms (TREE_CHAIN (t
)));
10132 else if (TREE_CODE (t
) == TYPE_DECL
)
10133 dependent_p
= dependent_type_p (TREE_TYPE (t
));
10134 else if (DECL_P (t
)
10136 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
10137 || TREE_CODE (t
) == OVERLOAD
10139 || identifier_p (t
)
10140 || TREE_CODE (t
) == TRAIT_EXPR
10141 || TREE_CODE (t
) == CONSTRUCTOR
10142 || CONSTANT_CLASS_P (t
))
10143 dependent_p
= (type_dependent_expression_p (t
)
10144 || value_dependent_expression_p (t
));
10147 gcc_assert (t
== error_mark_node
);
10148 dependent_p
= false;
10151 processing_template_decl
= saved_processing_template_decl
;
10153 return dependent_p
;
10156 /* Returns true iff current_function_decl is an incompletely instantiated
10157 template. Useful instead of processing_template_decl because the latter
10158 is set to 0 during instantiate_non_dependent_expr. */
10161 in_template_function (void)
10163 tree fn
= current_function_decl
;
10165 ++processing_template_decl
;
10166 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
10167 && DECL_TEMPLATE_INFO (fn
)
10168 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
10169 --processing_template_decl
;
10173 /* Returns true if T depends on any template parameter with level LEVEL. */
10176 uses_template_parms_level (tree t
, int level
)
10178 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
10179 /*include_nondeduced_p=*/true);
10182 /* Returns true if the signature of DECL depends on any template parameter from
10183 its enclosing class. */
10186 uses_outer_template_parms (tree decl
)
10188 int depth
= template_class_depth (CP_DECL_CONTEXT (decl
));
10191 if (for_each_template_parm (TREE_TYPE (decl
), template_parm_outer_level
,
10192 &depth
, NULL
, /*include_nondeduced_p=*/true))
10194 if (PRIMARY_TEMPLATE_P (decl
)
10195 && for_each_template_parm (INNERMOST_TEMPLATE_PARMS
10196 (DECL_TEMPLATE_PARMS (decl
)),
10197 template_parm_outer_level
,
10198 &depth
, NULL
, /*include_nondeduced_p=*/true))
10200 tree ci
= get_constraints (decl
);
10202 ci
= CI_ASSOCIATED_CONSTRAINTS (ci
);
10203 if (ci
&& for_each_template_parm (ci
, template_parm_outer_level
,
10204 &depth
, NULL
, /*nondeduced*/true))
10209 /* Returns TRUE iff INST is an instantiation we don't need to do in an
10210 ill-formed translation unit, i.e. a variable or function that isn't
10211 usable in a constant expression. */
10214 neglectable_inst_p (tree d
)
10216 return (d
&& DECL_P (d
)
10217 && !undeduced_auto_decl (d
)
10218 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
10219 : decl_maybe_constant_var_p (d
)));
10222 /* Returns TRUE iff we should refuse to instantiate DECL because it's
10223 neglectable and instantiated from within an erroneous instantiation. */
10226 limit_bad_template_recursion (tree decl
)
10228 struct tinst_level
*lev
= current_tinst_level
;
10229 int errs
= errorcount
+ sorrycount
;
10230 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
10233 for (; lev
; lev
= lev
->next
)
10234 if (neglectable_inst_p (lev
->maybe_get_node ()))
10237 return (lev
&& errs
> lev
->errors
);
10240 static int tinst_depth
;
10241 extern int max_tinst_depth
;
10244 static GTY(()) struct tinst_level
*last_error_tinst_level
;
10246 /* We're starting to instantiate D; record the template instantiation context
10247 at LOC for diagnostics and to restore it later. */
10250 push_tinst_level_loc (tree tldcl
, tree targs
, location_t loc
)
10252 struct tinst_level
*new_level
;
10254 if (tinst_depth
>= max_tinst_depth
)
10256 /* Tell error.c not to try to instantiate any templates. */
10258 fatal_error (input_location
,
10259 "template instantiation depth exceeds maximum of %d"
10260 " (use %<-ftemplate-depth=%> to increase the maximum)",
10265 /* If the current instantiation caused problems, don't let it instantiate
10266 anything else. Do allow deduction substitution and decls usable in
10267 constant expressions. */
10268 if (!targs
&& limit_bad_template_recursion (tldcl
))
10271 /* When not -quiet, dump template instantiations other than functions, since
10272 announce_function will take care of those. */
10273 if (!quiet_flag
&& !targs
10274 && TREE_CODE (tldcl
) != TREE_LIST
10275 && TREE_CODE (tldcl
) != FUNCTION_DECL
)
10276 fprintf (stderr
, " %s", decl_as_string (tldcl
, TFF_DECL_SPECIFIERS
));
10278 new_level
= tinst_level_freelist ().alloc ();
10279 new_level
->tldcl
= tldcl
;
10280 new_level
->targs
= targs
;
10281 new_level
->locus
= loc
;
10282 new_level
->errors
= errorcount
+ sorrycount
;
10283 new_level
->next
= NULL
;
10284 new_level
->refcount
= 0;
10285 set_refcount_ptr (new_level
->next
, current_tinst_level
);
10286 set_refcount_ptr (current_tinst_level
, new_level
);
10289 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
10290 depth_reached
= tinst_depth
;
10295 /* We're starting substitution of TMPL<ARGS>; record the template
10296 substitution context for diagnostics and to restore it later. */
10299 push_tinst_level (tree tmpl
, tree args
)
10301 return push_tinst_level_loc (tmpl
, args
, input_location
);
10304 /* We're starting to instantiate D; record INPUT_LOCATION and the
10305 template instantiation context for diagnostics and to restore it
10309 push_tinst_level (tree d
)
10311 return push_tinst_level_loc (d
, input_location
);
10314 /* Likewise, but record LOC as the program location. */
10317 push_tinst_level_loc (tree d
, location_t loc
)
10319 gcc_assert (TREE_CODE (d
) != TREE_LIST
);
10320 return push_tinst_level_loc (d
, NULL
, loc
);
10323 /* We're done instantiating this template; return to the instantiation
10327 pop_tinst_level (void)
10329 /* Restore the filename and line number stashed away when we started
10330 this instantiation. */
10331 input_location
= current_tinst_level
->locus
;
10332 set_refcount_ptr (current_tinst_level
, current_tinst_level
->next
);
10336 /* We're instantiating a deferred template; restore the template
10337 instantiation context in which the instantiation was requested, which
10338 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
10341 reopen_tinst_level (struct tinst_level
*level
)
10343 struct tinst_level
*t
;
10346 for (t
= level
; t
; t
= t
->next
)
10349 set_refcount_ptr (current_tinst_level
, level
);
10350 pop_tinst_level ();
10351 if (current_tinst_level
)
10352 current_tinst_level
->errors
= errorcount
+sorrycount
;
10353 return level
->maybe_get_node ();
10356 /* Returns the TINST_LEVEL which gives the original instantiation
10359 struct tinst_level
*
10360 outermost_tinst_level (void)
10362 struct tinst_level
*level
= current_tinst_level
;
10364 while (level
->next
)
10365 level
= level
->next
;
10369 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
10370 vector of template arguments, as for tsubst.
10372 Returns an appropriate tsubst'd friend declaration. */
10375 tsubst_friend_function (tree decl
, tree args
)
10379 if (TREE_CODE (decl
) == FUNCTION_DECL
10380 && DECL_TEMPLATE_INSTANTIATION (decl
)
10381 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
10382 /* This was a friend declared with an explicit template
10383 argument list, e.g.:
10385 friend void f<>(T);
10387 to indicate that f was a template instantiation, not a new
10388 function declaration. Now, we have to figure out what
10389 instantiation of what template. */
10391 tree template_id
, arglist
, fns
;
10394 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
10396 /* Friend functions are looked up in the containing namespace scope.
10397 We must enter that scope, to avoid finding member functions of the
10398 current class with same name. */
10399 push_nested_namespace (ns
);
10400 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
10401 tf_warning_or_error
, NULL_TREE
,
10402 /*integral_constant_expression_p=*/false);
10403 pop_nested_namespace (ns
);
10404 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
10405 tf_warning_or_error
, NULL_TREE
);
10406 template_id
= lookup_template_function (fns
, arglist
);
10408 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
10409 tmpl
= determine_specialization (template_id
, new_friend
,
10411 /*need_member_template=*/0,
10412 TREE_VEC_LENGTH (args
),
10414 return instantiate_template (tmpl
, new_args
, tf_error
);
10417 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
10419 /* The NEW_FRIEND will look like an instantiation, to the
10420 compiler, but is not an instantiation from the point of view of
10421 the language. For example, we might have had:
10423 template <class T> struct S {
10424 template <class U> friend void f(T, U);
10427 Then, in S<int>, template <class U> void f(int, U) is not an
10428 instantiation of anything. */
10429 if (new_friend
== error_mark_node
)
10430 return error_mark_node
;
10432 DECL_USE_TEMPLATE (new_friend
) = 0;
10433 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
10435 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
10436 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
10437 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
10440 /* The mangled name for the NEW_FRIEND is incorrect. The function
10441 is not a template instantiation and should not be mangled like
10442 one. Therefore, we forget the mangling here; we'll recompute it
10443 later if we need it. */
10444 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
10446 SET_DECL_RTL (new_friend
, NULL
);
10447 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
10450 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
10453 tree new_friend_template_info
;
10454 tree new_friend_result_template_info
;
10456 int new_friend_is_defn
;
10458 /* We must save some information from NEW_FRIEND before calling
10459 duplicate decls since that function will free NEW_FRIEND if
10461 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
10462 new_friend_is_defn
=
10463 (DECL_INITIAL (DECL_TEMPLATE_RESULT
10464 (template_for_substitution (new_friend
)))
10466 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
10468 /* This declaration is a `primary' template. */
10469 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
10471 new_friend_result_template_info
10472 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
10475 new_friend_result_template_info
= NULL_TREE
;
10477 /* Inside pushdecl_namespace_level, we will push into the
10478 current namespace. However, the friend function should go
10479 into the namespace of the template. */
10480 ns
= decl_namespace_context (new_friend
);
10481 push_nested_namespace (ns
);
10482 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
10483 pop_nested_namespace (ns
);
10485 if (old_decl
== error_mark_node
)
10486 return error_mark_node
;
10488 if (old_decl
!= new_friend
)
10490 /* This new friend declaration matched an existing
10491 declaration. For example, given:
10493 template <class T> void f(T);
10494 template <class U> class C {
10495 template <class T> friend void f(T) {}
10498 the friend declaration actually provides the definition
10499 of `f', once C has been instantiated for some type. So,
10500 old_decl will be the out-of-class template declaration,
10501 while new_friend is the in-class definition.
10503 But, if `f' was called before this point, the
10504 instantiation of `f' will have DECL_TI_ARGS corresponding
10505 to `T' but not to `U', references to which might appear
10506 in the definition of `f'. Previously, the most general
10507 template for an instantiation of `f' was the out-of-class
10508 version; now it is the in-class version. Therefore, we
10509 run through all specialization of `f', adding to their
10510 DECL_TI_ARGS appropriately. In particular, they need a
10511 new set of outer arguments, corresponding to the
10512 arguments for this class instantiation.
10514 The same situation can arise with something like this:
10516 friend void f(int);
10517 template <class T> class C {
10518 friend void f(T) {}
10521 when `C<int>' is instantiated. Now, `f(int)' is defined
10524 if (!new_friend_is_defn
)
10525 /* On the other hand, if the in-class declaration does
10526 *not* provide a definition, then we don't want to alter
10527 existing definitions. We can just leave everything
10532 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
10533 tree new_args
= TI_ARGS (new_friend_template_info
);
10535 /* Overwrite whatever template info was there before, if
10536 any, with the new template information pertaining to
10537 the declaration. */
10538 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
10540 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
10542 /* We should have called reregister_specialization in
10543 duplicate_decls. */
10544 gcc_assert (retrieve_specialization (new_template
,
10548 /* Instantiate it if the global has already been used. */
10549 if (DECL_ODR_USED (old_decl
))
10550 instantiate_decl (old_decl
, /*defer_ok=*/true,
10551 /*expl_inst_class_mem_p=*/false);
10557 /* Indicate that the old function template is a partial
10559 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
10560 = new_friend_result_template_info
;
10562 gcc_assert (new_template
10563 == most_general_template (new_template
));
10564 gcc_assert (new_template
!= old_decl
);
10566 /* Reassign any specializations already in the hash table
10567 to the new more general template, and add the
10568 additional template args. */
10569 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
10571 t
= TREE_CHAIN (t
))
10573 tree spec
= TREE_VALUE (t
);
10576 elt
.tmpl
= old_decl
;
10577 elt
.args
= DECL_TI_ARGS (spec
);
10578 elt
.spec
= NULL_TREE
;
10580 decl_specializations
->remove_elt (&elt
);
10582 DECL_TI_ARGS (spec
)
10583 = add_outermost_template_args (new_args
,
10584 DECL_TI_ARGS (spec
));
10586 register_specialization
10587 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
10590 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
10594 /* The information from NEW_FRIEND has been merged into OLD_DECL
10595 by duplicate_decls. */
10596 new_friend
= old_decl
;
10601 tree context
= DECL_CONTEXT (new_friend
);
10605 template <class T> class C {
10606 template <class U> friend void C1<U>::f (); // case 1
10607 friend void C2<T>::f (); // case 2
10609 we only need to make sure CONTEXT is a complete type for
10610 case 2. To distinguish between the two cases, we note that
10611 CONTEXT of case 1 remains dependent type after tsubst while
10612 this isn't true for case 2. */
10613 ++processing_template_decl
;
10614 dependent_p
= dependent_type_p (context
);
10615 --processing_template_decl
;
10618 && !complete_type_or_else (context
, NULL_TREE
))
10619 return error_mark_node
;
10621 if (COMPLETE_TYPE_P (context
))
10623 tree fn
= new_friend
;
10624 /* do_friend adds the TEMPLATE_DECL for any member friend
10625 template even if it isn't a member template, i.e.
10626 template <class T> friend A<T>::f();
10627 Look through it in that case. */
10628 if (TREE_CODE (fn
) == TEMPLATE_DECL
10629 && !PRIMARY_TEMPLATE_P (fn
))
10630 fn
= DECL_TEMPLATE_RESULT (fn
);
10631 /* Check to see that the declaration is really present, and,
10632 possibly obtain an improved declaration. */
10633 fn
= check_classfn (context
, fn
, NULL_TREE
);
10643 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
10644 template arguments, as for tsubst.
10646 Returns an appropriate tsubst'd friend type or error_mark_node on
10650 tsubst_friend_class (tree friend_tmpl
, tree args
)
10654 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
10656 tmpl
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
10657 return TREE_TYPE (tmpl
);
10660 tree context
= CP_DECL_CONTEXT (friend_tmpl
);
10661 if (TREE_CODE (context
) == NAMESPACE_DECL
)
10662 push_nested_namespace (context
);
10665 context
= tsubst (context
, args
, tf_error
, NULL_TREE
);
10666 push_nested_class (context
);
10669 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), /*prefer_type=*/false,
10670 /*non_class=*/false, /*block_p=*/false,
10671 /*namespaces_only=*/false, LOOKUP_HIDDEN
);
10673 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
10675 /* The friend template has already been declared. Just
10676 check to see that the declarations match, and install any new
10677 default parameters. We must tsubst the default parameters,
10678 of course. We only need the innermost template parameters
10679 because that is all that redeclare_class_template will look
10681 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
10682 > TMPL_ARGS_DEPTH (args
))
10684 tree parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
10685 args
, tf_warning_or_error
);
10686 location_t saved_input_location
= input_location
;
10687 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
10688 tree cons
= get_constraints (tmpl
);
10689 redeclare_class_template (TREE_TYPE (tmpl
), parms
, cons
);
10690 input_location
= saved_input_location
;
10695 /* The friend template has not already been declared. In this
10696 case, the instantiation of the template class will cause the
10697 injection of this template into the namespace scope. */
10698 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
10700 if (tmpl
!= error_mark_node
)
10702 /* The new TMPL is not an instantiation of anything, so we
10703 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE
10704 for the new type because that is supposed to be the
10705 corresponding template decl, i.e., TMPL. */
10706 DECL_USE_TEMPLATE (tmpl
) = 0;
10707 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
10708 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
10709 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
10710 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
10712 /* It is hidden. */
10713 retrofit_lang_decl (DECL_TEMPLATE_RESULT (tmpl
));
10714 DECL_ANTICIPATED (tmpl
)
10715 = DECL_ANTICIPATED (DECL_TEMPLATE_RESULT (tmpl
)) = true;
10717 /* Inject this template into the enclosing namspace scope. */
10718 tmpl
= pushdecl_namespace_level (tmpl
, true);
10722 if (TREE_CODE (context
) == NAMESPACE_DECL
)
10723 pop_nested_namespace (context
);
10725 pop_nested_class ();
10727 return TREE_TYPE (tmpl
);
10730 /* Returns zero if TYPE cannot be completed later due to circularity.
10731 Otherwise returns one. */
10734 can_complete_type_without_circularity (tree type
)
10736 if (type
== NULL_TREE
|| type
== error_mark_node
)
10738 else if (COMPLETE_TYPE_P (type
))
10740 else if (TREE_CODE (type
) == ARRAY_TYPE
)
10741 return can_complete_type_without_circularity (TREE_TYPE (type
));
10742 else if (CLASS_TYPE_P (type
)
10743 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
10749 static tree
tsubst_omp_clauses (tree
, enum c_omp_region_type
, tree
,
10750 tsubst_flags_t
, tree
);
10752 /* Instantiate a single dependent attribute T (a TREE_LIST), and return either
10753 T or a new TREE_LIST, possibly a chain in the case of a pack expansion. */
10756 tsubst_attribute (tree t
, tree
*decl_p
, tree args
,
10757 tsubst_flags_t complain
, tree in_decl
)
10759 gcc_assert (ATTR_IS_DEPENDENT (t
));
10761 tree val
= TREE_VALUE (t
);
10762 if (val
== NULL_TREE
)
10763 /* Nothing to do. */;
10764 else if ((flag_openmp
|| flag_openmp_simd
)
10765 && is_attribute_p ("omp declare simd",
10766 get_attribute_name (t
)))
10768 tree clauses
= TREE_VALUE (val
);
10769 clauses
= tsubst_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
, args
,
10770 complain
, in_decl
);
10771 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
10772 clauses
= finish_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
);
10773 tree parms
= DECL_ARGUMENTS (*decl_p
);
10775 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
10777 val
= build_tree_list (NULL_TREE
, clauses
);
10781 /* If the first attribute argument is an identifier, don't
10782 pass it through tsubst. Attributes like mode, format,
10783 cleanup and several target specific attributes expect it
10785 else if (attribute_takes_identifier_p (get_attribute_name (t
)))
10788 = tsubst_expr (TREE_CHAIN (val
), args
, complain
, in_decl
,
10789 /*integral_constant_expression_p=*/false);
10790 if (chain
!= TREE_CHAIN (val
))
10791 val
= tree_cons (NULL_TREE
, TREE_VALUE (val
), chain
);
10793 else if (PACK_EXPANSION_P (val
))
10795 /* An attribute pack expansion. */
10796 tree purp
= TREE_PURPOSE (t
);
10797 tree pack
= tsubst_pack_expansion (val
, args
, complain
, in_decl
);
10798 if (pack
== error_mark_node
)
10799 return error_mark_node
;
10800 int len
= TREE_VEC_LENGTH (pack
);
10801 tree list
= NULL_TREE
;
10803 for (int i
= 0; i
< len
; ++i
)
10805 tree elt
= TREE_VEC_ELT (pack
, i
);
10806 *q
= build_tree_list (purp
, elt
);
10807 q
= &TREE_CHAIN (*q
);
10812 val
= tsubst_expr (val
, args
, complain
, in_decl
,
10813 /*integral_constant_expression_p=*/false);
10815 if (val
!= TREE_VALUE (t
))
10816 return build_tree_list (TREE_PURPOSE (t
), val
);
10820 /* Instantiate any dependent attributes in ATTRIBUTES, returning either it
10821 unchanged or a new TREE_LIST chain. */
10824 tsubst_attributes (tree attributes
, tree args
,
10825 tsubst_flags_t complain
, tree in_decl
)
10827 tree last_dep
= NULL_TREE
;
10829 for (tree t
= attributes
; t
; t
= TREE_CHAIN (t
))
10830 if (ATTR_IS_DEPENDENT (t
))
10833 attributes
= copy_list (attributes
);
10838 for (tree
*p
= &attributes
; *p
; )
10841 if (ATTR_IS_DEPENDENT (t
))
10843 tree subst
= tsubst_attribute (t
, NULL
, args
, complain
, in_decl
);
10848 p
= &TREE_CHAIN (*p
);
10849 *p
= TREE_CHAIN (t
);
10853 p
= &TREE_CHAIN (*p
);
10859 /* Apply any attributes which had to be deferred until instantiation
10860 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
10861 ARGS, COMPLAIN, IN_DECL are as tsubst. */
10864 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
10865 tree args
, tsubst_flags_t complain
, tree in_decl
)
10867 tree last_dep
= NULL_TREE
;
10871 if (attributes
== NULL_TREE
)
10874 if (DECL_P (*decl_p
))
10876 if (TREE_TYPE (*decl_p
) == error_mark_node
)
10878 p
= &DECL_ATTRIBUTES (*decl_p
);
10879 /* DECL_ATTRIBUTES comes from copy_node in tsubst_decl, and is identical
10880 to our attributes parameter. */
10881 gcc_assert (*p
== attributes
);
10885 p
= &TYPE_ATTRIBUTES (*decl_p
);
10886 /* TYPE_ATTRIBUTES was set up (with abi_tag and may_alias) in
10887 lookup_template_class_1, and should be preserved. */
10888 gcc_assert (*p
!= attributes
);
10890 p
= &TREE_CHAIN (*p
);
10893 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
10894 if (ATTR_IS_DEPENDENT (t
))
10897 attributes
= copy_list (attributes
);
10904 tree late_attrs
= NULL_TREE
;
10905 tree
*q
= &late_attrs
;
10910 if (ATTR_IS_DEPENDENT (t
))
10912 *p
= TREE_CHAIN (t
);
10913 TREE_CHAIN (t
) = NULL_TREE
;
10914 *q
= tsubst_attribute (t
, decl_p
, args
, complain
, in_decl
);
10916 q
= &TREE_CHAIN (*q
);
10919 p
= &TREE_CHAIN (t
);
10922 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
10926 /* Perform (or defer) access check for typedefs that were referenced
10927 from within the template TMPL code.
10928 This is a subroutine of instantiate_decl and instantiate_class_template.
10929 TMPL is the template to consider and TARGS is the list of arguments of
10933 perform_typedefs_access_check (tree tmpl
, tree targs
)
10935 location_t saved_location
;
10937 qualified_typedef_usage_t
*iter
;
10940 || (!CLASS_TYPE_P (tmpl
)
10941 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
10944 saved_location
= input_location
;
10945 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
10947 tree type_decl
= iter
->typedef_decl
;
10948 tree type_scope
= iter
->context
;
10950 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
10953 if (uses_template_parms (type_decl
))
10954 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
10955 if (uses_template_parms (type_scope
))
10956 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
10958 /* Make access check error messages point to the location
10959 of the use of the typedef. */
10960 input_location
= iter
->locus
;
10961 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
10962 type_decl
, type_decl
,
10963 tf_warning_or_error
);
10965 input_location
= saved_location
;
10969 instantiate_class_template_1 (tree type
)
10971 tree templ
, args
, pattern
, t
, member
;
10975 unsigned int saved_maximum_field_alignment
;
10978 if (type
== error_mark_node
)
10979 return error_mark_node
;
10981 if (COMPLETE_OR_OPEN_TYPE_P (type
)
10982 || uses_template_parms (type
))
10985 /* Figure out which template is being instantiated. */
10986 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
10987 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
10989 /* Mark the type as in the process of being defined. */
10990 TYPE_BEING_DEFINED (type
) = 1;
10992 /* We may be in the middle of deferred access check. Disable
10994 deferring_access_check_sentinel
acs (dk_no_deferred
);
10996 /* Determine what specialization of the original template to
10998 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
10999 if (t
== error_mark_node
)
11000 return error_mark_node
;
11003 /* This TYPE is actually an instantiation of a partial
11004 specialization. We replace the innermost set of ARGS with
11005 the arguments appropriate for substitution. For example,
11008 template <class T> struct S {};
11009 template <class T> struct S<T*> {};
11011 and supposing that we are instantiating S<int*>, ARGS will
11012 presently be {int*} -- but we need {int}. */
11013 pattern
= TREE_TYPE (t
);
11014 args
= TREE_PURPOSE (t
);
11018 pattern
= TREE_TYPE (templ
);
11019 args
= CLASSTYPE_TI_ARGS (type
);
11022 /* If the template we're instantiating is incomplete, then clearly
11023 there's nothing we can do. */
11024 if (!COMPLETE_TYPE_P (pattern
))
11026 /* We can try again later. */
11027 TYPE_BEING_DEFINED (type
) = 0;
11031 /* If we've recursively instantiated too many templates, stop. */
11032 if (! push_tinst_level (type
))
11035 int saved_unevaluated_operand
= cp_unevaluated_operand
;
11036 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
11038 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
11039 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
11040 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
11041 fn_context
= error_mark_node
;
11043 push_to_top_level ();
11046 cp_unevaluated_operand
= 0;
11047 c_inhibit_evaluation_warnings
= 0;
11049 /* Use #pragma pack from the template context. */
11050 saved_maximum_field_alignment
= maximum_field_alignment
;
11051 maximum_field_alignment
= TYPE_PRECISION (pattern
);
11053 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
11055 /* Set the input location to the most specialized template definition.
11056 This is needed if tsubsting causes an error. */
11057 typedecl
= TYPE_MAIN_DECL (pattern
);
11058 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
11059 DECL_SOURCE_LOCATION (typedecl
);
11061 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
11062 SET_TYPE_ALIGN (type
, TYPE_ALIGN (pattern
));
11063 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
11064 CLASSTYPE_NON_AGGREGATE (type
) = CLASSTYPE_NON_AGGREGATE (pattern
);
11065 if (ANON_AGGR_TYPE_P (pattern
))
11066 SET_ANON_AGGR_TYPE_P (type
);
11067 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
11069 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
11070 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
11071 /* Adjust visibility for template arguments. */
11072 determine_visibility (TYPE_MAIN_DECL (type
));
11074 if (CLASS_TYPE_P (type
))
11075 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
11077 pbinfo
= TYPE_BINFO (pattern
);
11079 /* We should never instantiate a nested class before its enclosing
11080 class; we need to look up the nested class by name before we can
11081 instantiate it, and that lookup should instantiate the enclosing
11083 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
11084 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
11086 base_list
= NULL_TREE
;
11087 if (BINFO_N_BASE_BINFOS (pbinfo
))
11093 /* We must enter the scope containing the type, as that is where
11094 the accessibility of types named in dependent bases are
11096 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
11098 /* Substitute into each of the bases to determine the actual
11100 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
11103 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
11104 tree expanded_bases
= NULL_TREE
;
11107 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
11110 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
11111 args
, tf_error
, NULL_TREE
);
11112 if (expanded_bases
== error_mark_node
)
11115 len
= TREE_VEC_LENGTH (expanded_bases
);
11118 for (idx
= 0; idx
< len
; idx
++)
11120 if (expanded_bases
)
11121 /* Extract the already-expanded base class. */
11122 base
= TREE_VEC_ELT (expanded_bases
, idx
);
11124 /* Substitute to figure out the base class. */
11125 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
11128 if (base
== error_mark_node
)
11131 base_list
= tree_cons (access
, base
, base_list
);
11132 if (BINFO_VIRTUAL_P (pbase_binfo
))
11133 TREE_TYPE (base_list
) = integer_type_node
;
11137 /* The list is now in reverse order; correct that. */
11138 base_list
= nreverse (base_list
);
11141 pop_scope (pushed_scope
);
11143 /* Now call xref_basetypes to set up all the base-class
11145 xref_basetypes (type
, base_list
);
11147 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
11148 (int) ATTR_FLAG_TYPE_IN_PLACE
,
11149 args
, tf_error
, NULL_TREE
);
11150 fixup_attribute_variants (type
);
11152 /* Now that our base classes are set up, enter the scope of the
11153 class, so that name lookups into base classes, etc. will work
11154 correctly. This is precisely analogous to what we do in
11155 begin_class_definition when defining an ordinary non-template
11156 class, except we also need to push the enclosing classes. */
11157 push_nested_class (type
);
11159 /* Now members are processed in the order of declaration. */
11160 for (member
= CLASSTYPE_DECL_LIST (pattern
);
11161 member
; member
= TREE_CHAIN (member
))
11163 tree t
= TREE_VALUE (member
);
11165 if (TREE_PURPOSE (member
))
11169 if (LAMBDA_TYPE_P (t
))
11170 /* A closure type for a lambda in an NSDMI or default argument.
11171 Ignore it; it will be regenerated when needed. */
11174 /* Build new CLASSTYPE_NESTED_UTDS. */
11177 bool class_template_p
;
11179 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
11180 && TYPE_LANG_SPECIFIC (t
)
11181 && CLASSTYPE_IS_TEMPLATE (t
));
11182 /* If the member is a class template, then -- even after
11183 substitution -- there may be dependent types in the
11184 template argument list for the class. We increment
11185 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
11186 that function will assume that no types are dependent
11187 when outside of a template. */
11188 if (class_template_p
)
11189 ++processing_template_decl
;
11190 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
11191 if (class_template_p
)
11192 --processing_template_decl
;
11193 if (newtag
== error_mark_node
)
11196 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
11198 tree name
= TYPE_IDENTIFIER (t
);
11200 if (class_template_p
)
11201 /* Unfortunately, lookup_template_class sets
11202 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
11203 instantiation (i.e., for the type of a member
11204 template class nested within a template class.)
11205 This behavior is required for
11206 maybe_process_partial_specialization to work
11207 correctly, but is not accurate in this case;
11208 the TAG is not an instantiation of anything.
11209 (The corresponding TEMPLATE_DECL is an
11210 instantiation, but the TYPE is not.) */
11211 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
11213 /* Now, we call pushtag to put this NEWTAG into the scope of
11214 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
11215 pushtag calling push_template_decl. We don't have to do
11216 this for enums because it will already have been done in
11219 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
11220 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
11223 else if (DECL_DECLARES_FUNCTION_P (t
))
11227 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11228 ++processing_template_decl
;
11229 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
11230 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11231 --processing_template_decl
;
11232 set_current_access_from_decl (r
);
11233 finish_member_declaration (r
);
11234 /* Instantiate members marked with attribute used. */
11235 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
11237 if (TREE_CODE (r
) == FUNCTION_DECL
11238 && DECL_OMP_DECLARE_REDUCTION_P (r
))
11239 cp_check_omp_declare_reduction (r
);
11241 else if ((DECL_CLASS_TEMPLATE_P (t
) || DECL_IMPLICIT_TYPEDEF_P (t
))
11242 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
11243 /* A closure type for a lambda in an NSDMI or default argument.
11244 Ignore it; it will be regenerated when needed. */;
11247 /* Build new TYPE_FIELDS. */
11248 if (TREE_CODE (t
) == STATIC_ASSERT
)
11252 ++c_inhibit_evaluation_warnings
;
11254 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
11255 tf_warning_or_error
, NULL_TREE
,
11256 /*integral_constant_expression_p=*/true);
11257 --c_inhibit_evaluation_warnings
;
11259 finish_static_assert (condition
,
11260 STATIC_ASSERT_MESSAGE (t
),
11261 STATIC_ASSERT_SOURCE_LOCATION (t
),
11262 /*member_p=*/true);
11264 else if (TREE_CODE (t
) != CONST_DECL
)
11267 tree vec
= NULL_TREE
;
11270 /* The file and line for this declaration, to
11271 assist in error message reporting. Since we
11272 called push_tinst_level above, we don't need to
11274 input_location
= DECL_SOURCE_LOCATION (t
);
11276 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11277 ++processing_template_decl
;
11278 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
11279 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11280 --processing_template_decl
;
11282 if (TREE_CODE (r
) == TREE_VEC
)
11284 /* A capture pack became multiple fields. */
11286 len
= TREE_VEC_LENGTH (vec
);
11289 for (int i
= 0; i
< len
; ++i
)
11292 r
= TREE_VEC_ELT (vec
, i
);
11297 [t]he initialization (and any associated
11298 side-effects) of a static data member does
11299 not occur unless the static data member is
11300 itself used in a way that requires the
11301 definition of the static data member to
11304 Therefore, we do not substitute into the
11305 initialized for the static data member here. */
11306 finish_static_data_member_decl
11308 /*init=*/NULL_TREE
,
11309 /*init_const_expr_p=*/false,
11310 /*asmspec_tree=*/NULL_TREE
,
11312 /* Instantiate members marked with attribute used. */
11313 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
11316 else if (TREE_CODE (r
) == FIELD_DECL
)
11318 /* Determine whether R has a valid type and can be
11319 completed later. If R is invalid, then its type
11320 is replaced by error_mark_node. */
11321 tree rtype
= TREE_TYPE (r
);
11322 if (can_complete_type_without_circularity (rtype
))
11323 complete_type (rtype
);
11325 if (!complete_or_array_type_p (rtype
))
11327 /* If R's type couldn't be completed and
11328 it isn't a flexible array member (whose
11329 type is incomplete by definition) give
11331 cxx_incomplete_type_error (r
, rtype
);
11332 TREE_TYPE (r
) = error_mark_node
;
11334 else if (TREE_CODE (rtype
) == ARRAY_TYPE
11335 && TYPE_DOMAIN (rtype
) == NULL_TREE
11336 && (TREE_CODE (type
) == UNION_TYPE
11337 || TREE_CODE (type
) == QUAL_UNION_TYPE
))
11339 error ("flexible array member %qD in union", r
);
11340 TREE_TYPE (r
) = error_mark_node
;
11344 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
11345 such a thing will already have been added to the field
11346 list by tsubst_enum in finish_member_declaration in the
11347 CLASSTYPE_NESTED_UTDS case above. */
11348 if (!(TREE_CODE (r
) == TYPE_DECL
11349 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
11350 && DECL_ARTIFICIAL (r
)))
11352 set_current_access_from_decl (r
);
11353 finish_member_declaration (r
);
11361 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
11362 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
11364 /* Build new CLASSTYPE_FRIEND_CLASSES. */
11366 tree friend_type
= t
;
11367 bool adjust_processing_template_decl
= false;
11369 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
11371 /* template <class T> friend class C; */
11372 friend_type
= tsubst_friend_class (friend_type
, args
);
11373 adjust_processing_template_decl
= true;
11375 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
11377 /* template <class T> friend class C::D; */
11378 friend_type
= tsubst (friend_type
, args
,
11379 tf_warning_or_error
, NULL_TREE
);
11380 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
11381 friend_type
= TREE_TYPE (friend_type
);
11382 adjust_processing_template_decl
= true;
11384 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
11385 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
11387 /* This could be either
11391 when dependent_type_p is false or
11393 template <class U> friend class T::C;
11396 /* Bump processing_template_decl in case this is something like
11397 template <class T> friend struct A<T>::B. */
11398 ++processing_template_decl
;
11399 friend_type
= tsubst (friend_type
, args
,
11400 tf_warning_or_error
, NULL_TREE
);
11401 if (dependent_type_p (friend_type
))
11402 adjust_processing_template_decl
= true;
11403 --processing_template_decl
;
11405 else if (TREE_CODE (friend_type
) != BOUND_TEMPLATE_TEMPLATE_PARM
11406 && !CLASSTYPE_USE_TEMPLATE (friend_type
)
11407 && TYPE_HIDDEN_P (friend_type
))
11411 where C hasn't been declared yet. Let's lookup name
11412 from namespace scope directly, bypassing any name that
11413 come from dependent base class. */
11414 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
11416 /* The call to xref_tag_from_type does injection for friend
11418 push_nested_namespace (ns
);
11420 xref_tag_from_type (friend_type
, NULL_TREE
,
11421 /*tag_scope=*/ts_current
);
11422 pop_nested_namespace (ns
);
11424 else if (uses_template_parms (friend_type
))
11425 /* friend class C<T>; */
11426 friend_type
= tsubst (friend_type
, args
,
11427 tf_warning_or_error
, NULL_TREE
);
11432 where C is already declared or
11434 friend class C<int>;
11436 We don't have to do anything in these cases. */
11438 if (adjust_processing_template_decl
)
11439 /* Trick make_friend_class into realizing that the friend
11440 we're adding is a template, not an ordinary class. It's
11441 important that we use make_friend_class since it will
11442 perform some error-checking and output cross-reference
11444 ++processing_template_decl
;
11446 if (friend_type
!= error_mark_node
)
11447 make_friend_class (type
, friend_type
, /*complain=*/false);
11449 if (adjust_processing_template_decl
)
11450 --processing_template_decl
;
11454 /* Build new DECL_FRIENDLIST. */
11457 /* The file and line for this declaration, to
11458 assist in error message reporting. Since we
11459 called push_tinst_level above, we don't need to
11461 input_location
= DECL_SOURCE_LOCATION (t
);
11463 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11465 ++processing_template_decl
;
11466 push_deferring_access_checks (dk_no_check
);
11469 r
= tsubst_friend_function (t
, args
);
11470 add_friend (type
, r
, /*complain=*/false);
11471 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11473 pop_deferring_access_checks ();
11474 --processing_template_decl
;
11482 /* Restore these before substituting into the lambda capture
11484 cp_unevaluated_operand
= saved_unevaluated_operand
;
11485 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
11488 /* Set the file and line number information to whatever is given for
11489 the class itself. This puts error messages involving generated
11490 implicit functions at a predictable point, and the same point
11491 that would be used for non-template classes. */
11492 input_location
= DECL_SOURCE_LOCATION (typedecl
);
11494 unreverse_member_declarations (type
);
11495 finish_struct_1 (type
);
11496 TYPE_BEING_DEFINED (type
) = 0;
11498 /* We don't instantiate default arguments for member functions. 14.7.1:
11500 The implicit instantiation of a class template specialization causes
11501 the implicit instantiation of the declarations, but not of the
11502 definitions or default arguments, of the class member functions,
11503 member classes, static data members and member templates.... */
11505 /* Some typedefs referenced from within the template code need to be access
11506 checked at template instantiation time, i.e now. These types were
11507 added to the template at parsing time. Let's get those and perform
11508 the access checks then. */
11509 perform_typedefs_access_check (pattern
, args
);
11510 perform_deferred_access_checks (tf_warning_or_error
);
11511 pop_nested_class ();
11512 maximum_field_alignment
= saved_maximum_field_alignment
;
11514 pop_from_top_level ();
11515 pop_tinst_level ();
11517 /* The vtable for a template class can be emitted in any translation
11518 unit in which the class is instantiated. When there is no key
11519 method, however, finish_struct_1 will already have added TYPE to
11520 the keyed_classes. */
11521 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
11522 vec_safe_push (keyed_classes
, type
);
11527 /* Wrapper for instantiate_class_template_1. */
11530 instantiate_class_template (tree type
)
11533 timevar_push (TV_TEMPLATE_INST
);
11534 ret
= instantiate_class_template_1 (type
);
11535 timevar_pop (TV_TEMPLATE_INST
);
11540 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11546 else if (TYPE_P (t
))
11547 r
= tsubst (t
, args
, complain
, in_decl
);
11550 if (!(complain
& tf_warning
))
11551 ++c_inhibit_evaluation_warnings
;
11552 r
= tsubst_expr (t
, args
, complain
, in_decl
,
11553 /*integral_constant_expression_p=*/true);
11554 if (!(complain
& tf_warning
))
11555 --c_inhibit_evaluation_warnings
;
11560 /* Given a function parameter pack TMPL_PARM and some function parameters
11561 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
11562 and set *SPEC_P to point at the next point in the list. */
11565 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
11567 /* Collect all of the extra "packed" parameters into an
11570 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
11571 tree spec_parm
= *spec_p
;
11574 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
11576 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
11579 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
11580 parmvec
= make_tree_vec (len
);
11581 spec_parm
= *spec_p
;
11582 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
11584 tree elt
= spec_parm
;
11585 if (DECL_PACK_P (elt
))
11586 elt
= make_pack_expansion (elt
);
11587 TREE_VEC_ELT (parmvec
, i
) = elt
;
11590 /* Build the argument packs. */
11591 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
11592 *spec_p
= spec_parm
;
11597 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
11598 NONTYPE_ARGUMENT_PACK. */
11601 make_fnparm_pack (tree spec_parm
)
11603 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
11606 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
11607 pack expansion with no extra args, 2 if it has extra args, or 0
11608 if it is not a pack expansion. */
11611 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
11613 if (TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
11614 /* We're being called before this happens in tsubst_pack_expansion. */
11615 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
11616 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
11617 if (i
>= TREE_VEC_LENGTH (vec
))
11619 tree elt
= TREE_VEC_ELT (vec
, i
);
11621 /* A decl pack is itself an expansion. */
11622 elt
= TREE_TYPE (elt
);
11623 if (!PACK_EXPANSION_P (elt
))
11625 if (PACK_EXPANSION_EXTRA_ARGS (elt
))
11631 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
11634 make_argument_pack_select (tree arg_pack
, unsigned index
)
11636 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
11638 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
11639 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
11644 /* This is a subroutine of tsubst_pack_expansion.
11646 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
11647 mechanism to store the (non complete list of) arguments of the
11648 substitution and return a non substituted pack expansion, in order
11649 to wait for when we have enough arguments to really perform the
11653 use_pack_expansion_extra_args_p (tree parm_packs
,
11655 bool has_empty_arg
)
11657 /* If one pack has an expansion and another pack has a normal
11658 argument or if one pack has an empty argument and an another
11659 one hasn't then tsubst_pack_expansion cannot perform the
11660 substitution and need to fall back on the
11661 PACK_EXPANSION_EXTRA mechanism. */
11662 if (parm_packs
== NULL_TREE
)
11664 else if (has_empty_arg
)
11667 bool has_expansion_arg
= false;
11668 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
11670 bool has_non_expansion_arg
= false;
11671 for (tree parm_pack
= parm_packs
;
11673 parm_pack
= TREE_CHAIN (parm_pack
))
11675 tree arg
= TREE_VALUE (parm_pack
);
11677 int exp
= argument_pack_element_is_expansion_p (arg
, i
);
11679 /* We can't substitute a pack expansion with extra args into
11683 has_expansion_arg
= true;
11685 has_non_expansion_arg
= true;
11688 if (has_expansion_arg
&& has_non_expansion_arg
)
11694 /* [temp.variadic]/6 says that:
11696 The instantiation of a pack expansion [...]
11697 produces a list E1,E2, ..., En, where N is the number of elements
11698 in the pack expansion parameters.
11700 This subroutine of tsubst_pack_expansion produces one of these Ei.
11702 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
11703 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
11704 PATTERN, and each TREE_VALUE is its corresponding argument pack.
11705 INDEX is the index 'i' of the element Ei to produce. ARGS,
11706 COMPLAIN, and IN_DECL are the same parameters as for the
11707 tsubst_pack_expansion function.
11709 The function returns the resulting Ei upon successful completion,
11710 or error_mark_node.
11712 Note that this function possibly modifies the ARGS parameter, so
11713 it's the responsibility of the caller to restore it. */
11716 gen_elem_of_pack_expansion_instantiation (tree pattern
,
11719 tree args
/* This parm gets
11721 tsubst_flags_t complain
,
11725 bool ith_elem_is_expansion
= false;
11727 /* For each parameter pack, change the substitution of the parameter
11728 pack to the ith argument in its argument pack, then expand the
11730 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
11732 tree parm
= TREE_PURPOSE (pack
);
11733 tree arg_pack
= TREE_VALUE (pack
);
11734 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
11736 ith_elem_is_expansion
|=
11737 argument_pack_element_is_expansion_p (arg_pack
, index
);
11739 /* Select the Ith argument from the pack. */
11740 if (TREE_CODE (parm
) == PARM_DECL
11742 || TREE_CODE (parm
) == FIELD_DECL
)
11746 aps
= make_argument_pack_select (arg_pack
, index
);
11747 if (!mark_used (parm
, complain
) && !(complain
& tf_error
))
11748 return error_mark_node
;
11749 register_local_specialization (aps
, parm
);
11752 aps
= retrieve_local_specialization (parm
);
11757 template_parm_level_and_index (parm
, &level
, &idx
);
11761 aps
= make_argument_pack_select (arg_pack
, index
);
11762 /* Update the corresponding argument. */
11763 TMPL_ARG (args
, level
, idx
) = aps
;
11766 /* Re-use the ARGUMENT_PACK_SELECT. */
11767 aps
= TMPL_ARG (args
, level
, idx
);
11769 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
11772 // Any local specialization bindings arising from this substitution
11773 // cannot be reused for a different INDEX.
11774 local_specialization_stack
lss (lss_copy
);
11776 /* Substitute into the PATTERN with the (possibly altered)
11778 if (pattern
== in_decl
)
11779 /* Expanding a fixed parameter pack from
11780 coerce_template_parameter_pack. */
11781 t
= tsubst_decl (pattern
, args
, complain
);
11782 else if (pattern
== error_mark_node
)
11783 t
= error_mark_node
;
11784 else if (constraint_p (pattern
))
11786 if (processing_template_decl
)
11787 t
= tsubst_constraint (pattern
, args
, complain
, in_decl
);
11789 t
= (constraints_satisfied_p (pattern
, args
)
11790 ? boolean_true_node
: boolean_false_node
);
11792 else if (!TYPE_P (pattern
))
11793 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
11794 /*integral_constant_expression_p=*/false);
11796 t
= tsubst (pattern
, args
, complain
, in_decl
);
11798 /* If the Ith argument pack element is a pack expansion, then
11799 the Ith element resulting from the substituting is going to
11800 be a pack expansion as well. */
11801 if (ith_elem_is_expansion
)
11802 t
= make_pack_expansion (t
, complain
);
11807 /* When the unexpanded parameter pack in a fold expression expands to an empty
11808 sequence, the value of the expression is as follows; the program is
11809 ill-formed if the operator is not listed in this table.
11816 expand_empty_fold (tree t
, tsubst_flags_t complain
)
11818 tree_code code
= (tree_code
)TREE_INT_CST_LOW (TREE_OPERAND (t
, 0));
11819 if (!FOLD_EXPR_MODIFY_P (t
))
11822 case TRUTH_ANDIF_EXPR
:
11823 return boolean_true_node
;
11824 case TRUTH_ORIF_EXPR
:
11825 return boolean_false_node
;
11826 case COMPOUND_EXPR
:
11832 if (complain
& tf_error
)
11833 error_at (location_of (t
),
11834 "fold of empty expansion over %O", code
);
11835 return error_mark_node
;
11838 /* Given a fold-expression T and a current LEFT and RIGHT operand,
11839 form an expression that combines the two terms using the
11843 fold_expression (tree t
, tree left
, tree right
, tsubst_flags_t complain
)
11845 tree op
= FOLD_EXPR_OP (t
);
11846 tree_code code
= (tree_code
)TREE_INT_CST_LOW (op
);
11848 // Handle compound assignment operators.
11849 if (FOLD_EXPR_MODIFY_P (t
))
11850 return build_x_modify_expr (input_location
, left
, code
, right
, complain
);
11854 case COMPOUND_EXPR
:
11855 return build_x_compound_expr (input_location
, left
, right
, complain
);
11857 return build_x_binary_op (input_location
, code
,
11858 left
, TREE_CODE (left
),
11859 right
, TREE_CODE (right
),
11865 /* Substitute ARGS into the pack of a fold expression T. */
11868 tsubst_fold_expr_pack (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11870 return tsubst_pack_expansion (FOLD_EXPR_PACK (t
), args
, complain
, in_decl
);
11873 /* Substitute ARGS into the pack of a fold expression T. */
11876 tsubst_fold_expr_init (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11878 return tsubst_expr (FOLD_EXPR_INIT (t
), args
, complain
, in_decl
, false);
11881 /* Expand a PACK of arguments into a grouped as left fold.
11882 Given a pack containing elements A0, A1, ..., An and an
11883 operator @, this builds the expression:
11885 ((A0 @ A1) @ A2) ... @ An
11887 Note that PACK must not be empty.
11889 The operator is defined by the original fold expression T. */
11892 expand_left_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11894 tree left
= TREE_VEC_ELT (pack
, 0);
11895 for (int i
= 1; i
< TREE_VEC_LENGTH (pack
); ++i
)
11897 tree right
= TREE_VEC_ELT (pack
, i
);
11898 left
= fold_expression (t
, left
, right
, complain
);
11903 /* Substitute into a unary left fold expression. */
11906 tsubst_unary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11909 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11910 if (pack
== error_mark_node
)
11911 return error_mark_node
;
11912 if (PACK_EXPANSION_P (pack
))
11914 tree r
= copy_node (t
);
11915 FOLD_EXPR_PACK (r
) = pack
;
11918 if (TREE_VEC_LENGTH (pack
) == 0)
11919 return expand_empty_fold (t
, complain
);
11921 return expand_left_fold (t
, pack
, complain
);
11924 /* Substitute into a binary left fold expression.
11926 Do ths by building a single (non-empty) vector of argumnts and
11927 building the expression from those elements. */
11930 tsubst_binary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11933 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11934 if (pack
== error_mark_node
)
11935 return error_mark_node
;
11936 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
11937 if (init
== error_mark_node
)
11938 return error_mark_node
;
11940 if (PACK_EXPANSION_P (pack
))
11942 tree r
= copy_node (t
);
11943 FOLD_EXPR_PACK (r
) = pack
;
11944 FOLD_EXPR_INIT (r
) = init
;
11948 tree vec
= make_tree_vec (TREE_VEC_LENGTH (pack
) + 1);
11949 TREE_VEC_ELT (vec
, 0) = init
;
11950 for (int i
= 0; i
< TREE_VEC_LENGTH (pack
); ++i
)
11951 TREE_VEC_ELT (vec
, i
+ 1) = TREE_VEC_ELT (pack
, i
);
11953 return expand_left_fold (t
, vec
, complain
);
11956 /* Expand a PACK of arguments into a grouped as right fold.
11957 Given a pack containing elementns A0, A1, ..., and an
11958 operator @, this builds the expression:
11960 A0@ ... (An-2 @ (An-1 @ An))
11962 Note that PACK must not be empty.
11964 The operator is defined by the original fold expression T. */
11967 expand_right_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11969 // Build the expression.
11970 int n
= TREE_VEC_LENGTH (pack
);
11971 tree right
= TREE_VEC_ELT (pack
, n
- 1);
11972 for (--n
; n
!= 0; --n
)
11974 tree left
= TREE_VEC_ELT (pack
, n
- 1);
11975 right
= fold_expression (t
, left
, right
, complain
);
11980 /* Substitute into a unary right fold expression. */
11983 tsubst_unary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
11986 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11987 if (pack
== error_mark_node
)
11988 return error_mark_node
;
11989 if (PACK_EXPANSION_P (pack
))
11991 tree r
= copy_node (t
);
11992 FOLD_EXPR_PACK (r
) = pack
;
11995 if (TREE_VEC_LENGTH (pack
) == 0)
11996 return expand_empty_fold (t
, complain
);
11998 return expand_right_fold (t
, pack
, complain
);
12001 /* Substitute into a binary right fold expression.
12003 Do ths by building a single (non-empty) vector of arguments and
12004 building the expression from those elements. */
12007 tsubst_binary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
12010 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
12011 if (pack
== error_mark_node
)
12012 return error_mark_node
;
12013 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
12014 if (init
== error_mark_node
)
12015 return error_mark_node
;
12017 if (PACK_EXPANSION_P (pack
))
12019 tree r
= copy_node (t
);
12020 FOLD_EXPR_PACK (r
) = pack
;
12021 FOLD_EXPR_INIT (r
) = init
;
12025 int n
= TREE_VEC_LENGTH (pack
);
12026 tree vec
= make_tree_vec (n
+ 1);
12027 for (int i
= 0; i
< n
; ++i
)
12028 TREE_VEC_ELT (vec
, i
) = TREE_VEC_ELT (pack
, i
);
12029 TREE_VEC_ELT (vec
, n
) = init
;
12031 return expand_right_fold (t
, vec
, complain
);
12034 /* Walk through the pattern of a pack expansion, adding everything in
12035 local_specializations to a list. */
12039 hash_set
<tree
> internal
;
12041 tsubst_flags_t complain
;
12043 el_data (tsubst_flags_t c
)
12044 : extra (NULL_TREE
), complain (c
) {}
12047 extract_locals_r (tree
*tp
, int */
*walk_subtrees*/
, void *data_
)
12049 el_data
&data
= *reinterpret_cast<el_data
*>(data_
);
12050 tree
*extra
= &data
.extra
;
12051 tsubst_flags_t complain
= data
.complain
;
12053 if (TYPE_P (*tp
) && typedef_variant_p (*tp
))
12054 /* Remember local typedefs (85214). */
12055 tp
= &TYPE_NAME (*tp
);
12057 if (TREE_CODE (*tp
) == DECL_EXPR
)
12058 data
.internal
.add (DECL_EXPR_DECL (*tp
));
12059 else if (tree spec
= retrieve_local_specialization (*tp
))
12061 if (data
.internal
.contains (*tp
))
12062 /* Don't mess with variables declared within the pattern. */
12064 if (TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
)
12066 /* Maybe pull out the PARM_DECL for a partial instantiation. */
12067 tree args
= ARGUMENT_PACK_ARGS (spec
);
12068 if (TREE_VEC_LENGTH (args
) == 1)
12070 tree elt
= TREE_VEC_ELT (args
, 0);
12071 if (PACK_EXPANSION_P (elt
))
12072 elt
= PACK_EXPANSION_PATTERN (elt
);
12073 if (DECL_PACK_P (elt
))
12076 if (TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
)
12078 /* Handle lambda capture here, since we aren't doing any
12079 substitution now, and so tsubst_copy won't call
12080 process_outer_var_ref. */
12081 tree args
= ARGUMENT_PACK_ARGS (spec
);
12082 int len
= TREE_VEC_LENGTH (args
);
12083 for (int i
= 0; i
< len
; ++i
)
12085 tree arg
= TREE_VEC_ELT (args
, i
);
12087 if (outer_automatic_var_p (arg
))
12088 carg
= process_outer_var_ref (arg
, complain
);
12091 /* Make a new NONTYPE_ARGUMENT_PACK of the capture
12095 spec
= copy_node (spec
);
12096 args
= copy_node (args
);
12097 SET_ARGUMENT_PACK_ARGS (spec
, args
);
12098 register_local_specialization (spec
, *tp
);
12100 TREE_VEC_ELT (args
, i
) = carg
;
12105 if (outer_automatic_var_p (spec
))
12106 spec
= process_outer_var_ref (spec
, complain
);
12107 *extra
= tree_cons (*tp
, spec
, *extra
);
12112 extract_local_specs (tree pattern
, tsubst_flags_t complain
)
12114 el_data
data (complain
);
12115 cp_walk_tree_without_duplicates (&pattern
, extract_locals_r
, &data
);
12119 /* Extract any uses of local_specializations from PATTERN and add them to ARGS
12120 for use in PACK_EXPANSION_EXTRA_ARGS. */
12123 build_extra_args (tree pattern
, tree args
, tsubst_flags_t complain
)
12126 if (local_specializations
)
12127 if (tree locals
= extract_local_specs (pattern
, complain
))
12128 extra
= tree_cons (NULL_TREE
, extra
, locals
);
12132 /* Apply any local specializations from PACK_EXPANSION_EXTRA_ARGS and add the
12133 normal template args to ARGS. */
12136 add_extra_args (tree extra
, tree args
)
12138 if (extra
&& TREE_CODE (extra
) == TREE_LIST
)
12140 for (tree elt
= TREE_CHAIN (extra
); elt
; elt
= TREE_CHAIN (elt
))
12142 /* The partial instantiation involved local declarations collected in
12143 extract_local_specs; map from the general template to our local
12145 tree gen
= TREE_PURPOSE (elt
);
12146 tree inst
= TREE_VALUE (elt
);
12148 if (tree local
= retrieve_local_specialization (inst
))
12150 /* else inst is already a full instantiation of the pack. */
12151 register_local_specialization (inst
, gen
);
12153 gcc_assert (!TREE_PURPOSE (extra
));
12154 extra
= TREE_VALUE (extra
);
12156 return add_to_template_args (extra
, args
);
12159 /* Substitute ARGS into T, which is an pack expansion
12160 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
12161 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
12162 (if only a partial substitution could be performed) or
12163 ERROR_MARK_NODE if there was an error. */
12165 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
12169 tree pack
, packs
= NULL_TREE
;
12170 bool unsubstituted_packs
= false;
12171 bool unsubstituted_fn_pack
= false;
12174 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
12175 bool need_local_specializations
= false;
12178 gcc_assert (PACK_EXPANSION_P (t
));
12179 pattern
= PACK_EXPANSION_PATTERN (t
);
12181 /* Add in any args remembered from an earlier partial instantiation. */
12182 args
= add_extra_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
12184 levels
= TMPL_ARGS_DEPTH (args
);
12186 /* Determine the argument packs that will instantiate the parameter
12187 packs used in the expansion expression. While we're at it,
12188 compute the number of arguments to be expanded and make sure it
12190 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
12191 pack
= TREE_CHAIN (pack
))
12193 tree parm_pack
= TREE_VALUE (pack
);
12194 tree arg_pack
= NULL_TREE
;
12195 tree orig_arg
= NULL_TREE
;
12198 if (TREE_CODE (parm_pack
) == BASES
)
12200 gcc_assert (parm_pack
== pattern
);
12201 if (BASES_DIRECT (parm_pack
))
12202 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
12207 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
12208 args
, complain
, in_decl
,
12211 else if (builtin_pack_call_p (parm_pack
))
12213 if (parm_pack
!= pattern
)
12215 if (complain
& tf_error
)
12216 sorry ("%qE is not the entire pattern of the pack expansion",
12218 return error_mark_node
;
12220 return expand_builtin_pack_call (parm_pack
, args
,
12221 complain
, in_decl
);
12223 else if (TREE_CODE (parm_pack
) == PARM_DECL
)
12225 /* We know we have correct local_specializations if this
12226 expansion is at function scope, or if we're dealing with a
12227 local parameter in a requires expression; for the latter,
12228 tsubst_requires_expr set it up appropriately. */
12229 if (PACK_EXPANSION_LOCAL_P (t
) || CONSTRAINT_VAR_P (parm_pack
))
12230 arg_pack
= retrieve_local_specialization (parm_pack
);
12232 /* We can't rely on local_specializations for a parameter
12233 name used later in a function declaration (such as in a
12234 late-specified return type). Even if it exists, it might
12235 have the wrong value for a recursive call. */
12236 need_local_specializations
= true;
12240 /* This parameter pack was used in an unevaluated context. Just
12241 make a dummy decl, since it's only used for its type. */
12242 ++cp_unevaluated_operand
;
12243 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
12244 --cp_unevaluated_operand
;
12245 if (arg_pack
&& DECL_PACK_P (arg_pack
))
12246 /* Partial instantiation of the parm_pack, we can't build
12247 up an argument pack yet. */
12248 arg_pack
= NULL_TREE
;
12250 arg_pack
= make_fnparm_pack (arg_pack
);
12252 else if (argument_pack_element_is_expansion_p (arg_pack
, 0))
12253 /* This argument pack isn't fully instantiated yet. We set this
12254 flag rather than clear arg_pack because we do want to do the
12255 optimization below, and we don't want to substitute directly
12256 into the pattern (as that would expose a NONTYPE_ARGUMENT_PACK
12257 where it isn't expected). */
12258 unsubstituted_fn_pack
= true;
12260 else if (is_capture_proxy (parm_pack
))
12262 arg_pack
= retrieve_local_specialization (parm_pack
);
12263 if (argument_pack_element_is_expansion_p (arg_pack
, 0))
12264 unsubstituted_fn_pack
= true;
12269 template_parm_level_and_index (parm_pack
, &level
, &idx
);
12271 if (level
<= levels
)
12272 arg_pack
= TMPL_ARG (args
, level
, idx
);
12275 orig_arg
= arg_pack
;
12276 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
12277 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
12279 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
12280 /* This can only happen if we forget to expand an argument
12281 pack somewhere else. Just return an error, silently. */
12283 result
= make_tree_vec (1);
12284 TREE_VEC_ELT (result
, 0) = error_mark_node
;
12291 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
12293 /* Don't bother trying to do a partial substitution with
12294 incomplete packs; we'll try again after deduction. */
12295 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
12300 else if (len
!= my_len
12301 && !unsubstituted_fn_pack
)
12303 if (!(complain
& tf_error
))
12304 /* Fail quietly. */;
12305 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
12306 error ("mismatched argument pack lengths while expanding %qT",
12309 error ("mismatched argument pack lengths while expanding %qE",
12311 return error_mark_node
;
12314 /* Keep track of the parameter packs and their corresponding
12316 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
12317 TREE_TYPE (packs
) = orig_arg
;
12321 /* We can't substitute for this parameter pack. We use a flag as
12322 well as the missing_level counter because function parameter
12323 packs don't have a level. */
12324 gcc_assert (processing_template_decl
|| is_auto (parm_pack
));
12325 unsubstituted_packs
= true;
12329 /* If the expansion is just T..., return the matching argument pack, unless
12330 we need to call convert_from_reference on all the elements. This is an
12331 important optimization; see c++/68422. */
12332 if (!unsubstituted_packs
12333 && TREE_PURPOSE (packs
) == pattern
)
12335 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
12337 /* If the argument pack is a single pack expansion, pull it out. */
12338 if (TREE_VEC_LENGTH (args
) == 1
12339 && pack_expansion_args_count (args
))
12340 return TREE_VEC_ELT (args
, 0);
12342 /* Types need no adjustment, nor does sizeof..., and if we still have
12343 some pack expansion args we won't do anything yet. */
12344 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
12345 || PACK_EXPANSION_SIZEOF_P (t
)
12346 || pack_expansion_args_count (args
))
12348 /* Also optimize expression pack expansions if we can tell that the
12349 elements won't have reference type. */
12350 tree type
= TREE_TYPE (pattern
);
12351 if (type
&& !TYPE_REF_P (type
)
12352 && !PACK_EXPANSION_P (type
)
12353 && !WILDCARD_TYPE_P (type
))
12355 /* Otherwise use the normal path so we get convert_from_reference. */
12358 /* We cannot expand this expansion expression, because we don't have
12359 all of the argument packs we need. */
12360 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
12362 /* We got some full packs, but we can't substitute them in until we
12363 have values for all the packs. So remember these until then. */
12365 t
= make_pack_expansion (pattern
, complain
);
12366 PACK_EXPANSION_EXTRA_ARGS (t
)
12367 = build_extra_args (pattern
, args
, complain
);
12370 else if (unsubstituted_packs
)
12372 /* There were no real arguments, we're just replacing a parameter
12373 pack with another version of itself. Substitute into the
12374 pattern and return a PACK_EXPANSION_*. The caller will need to
12376 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
12377 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
12378 /*integral_constant_expression_p=*/false);
12380 t
= tsubst (pattern
, args
, complain
, in_decl
);
12381 t
= make_pack_expansion (t
, complain
);
12385 gcc_assert (len
>= 0);
12387 if (need_local_specializations
)
12389 /* We're in a late-specified return type, so create our own local
12390 specializations map; the current map is either NULL or (in the
12391 case of recursive unification) might have bindings that we don't
12392 want to use or alter. */
12393 saved_local_specializations
= local_specializations
;
12394 local_specializations
= new hash_map
<tree
, tree
>;
12397 /* For each argument in each argument pack, substitute into the
12399 result
= make_tree_vec (len
);
12400 tree elem_args
= copy_template_args (args
);
12401 for (i
= 0; i
< len
; ++i
)
12403 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
12405 elem_args
, complain
,
12407 TREE_VEC_ELT (result
, i
) = t
;
12408 if (t
== error_mark_node
)
12410 result
= error_mark_node
;
12415 /* Update ARGS to restore the substitution from parameter packs to
12416 their argument packs. */
12417 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12419 tree parm
= TREE_PURPOSE (pack
);
12421 if (TREE_CODE (parm
) == PARM_DECL
12423 || TREE_CODE (parm
) == FIELD_DECL
)
12424 register_local_specialization (TREE_TYPE (pack
), parm
);
12429 if (TREE_VALUE (pack
) == NULL_TREE
)
12432 template_parm_level_and_index (parm
, &level
, &idx
);
12434 /* Update the corresponding argument. */
12435 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
12436 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
12439 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
12443 if (need_local_specializations
)
12445 delete local_specializations
;
12446 local_specializations
= saved_local_specializations
;
12449 /* If the dependent pack arguments were such that we end up with only a
12450 single pack expansion again, there's no need to keep it in a TREE_VEC. */
12451 if (len
== 1 && TREE_CODE (result
) == TREE_VEC
12452 && PACK_EXPANSION_P (TREE_VEC_ELT (result
, 0)))
12453 return TREE_VEC_ELT (result
, 0);
12458 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
12459 TMPL. We do this using DECL_PARM_INDEX, which should work even with
12460 parameter packs; all parms generated from a function parameter pack will
12461 have the same DECL_PARM_INDEX. */
12464 get_pattern_parm (tree parm
, tree tmpl
)
12466 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
12469 if (DECL_ARTIFICIAL (parm
))
12471 for (patparm
= DECL_ARGUMENTS (pattern
);
12472 patparm
; patparm
= DECL_CHAIN (patparm
))
12473 if (DECL_ARTIFICIAL (patparm
)
12474 && DECL_NAME (parm
) == DECL_NAME (patparm
))
12479 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
12480 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
12481 gcc_assert (DECL_PARM_INDEX (patparm
)
12482 == DECL_PARM_INDEX (parm
));
12488 /* Make an argument pack out of the TREE_VEC VEC. */
12491 make_argument_pack (tree vec
)
12494 tree elt
= TREE_VEC_ELT (vec
, 0);
12496 pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
12499 pack
= make_node (NONTYPE_ARGUMENT_PACK
);
12500 TREE_CONSTANT (pack
) = 1;
12502 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
12506 /* Return an exact copy of template args T that can be modified
12510 copy_template_args (tree t
)
12512 if (t
== error_mark_node
)
12515 int len
= TREE_VEC_LENGTH (t
);
12516 tree new_vec
= make_tree_vec (len
);
12518 for (int i
= 0; i
< len
; ++i
)
12520 tree elt
= TREE_VEC_ELT (t
, i
);
12521 if (elt
&& TREE_CODE (elt
) == TREE_VEC
)
12522 elt
= copy_template_args (elt
);
12523 TREE_VEC_ELT (new_vec
, i
) = elt
;
12526 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_vec
)
12527 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
12532 /* Substitute ARGS into the vector or list of template arguments T. */
12535 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12538 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
12541 if (t
== error_mark_node
)
12542 return error_mark_node
;
12544 len
= TREE_VEC_LENGTH (t
);
12545 elts
= XALLOCAVEC (tree
, len
);
12547 for (i
= 0; i
< len
; i
++)
12549 tree orig_arg
= TREE_VEC_ELT (t
, i
);
12552 if (TREE_CODE (orig_arg
) == TREE_VEC
)
12553 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
12554 else if (PACK_EXPANSION_P (orig_arg
))
12556 /* Substitute into an expansion expression. */
12557 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
12559 if (TREE_CODE (new_arg
) == TREE_VEC
)
12560 /* Add to the expanded length adjustment the number of
12561 expanded arguments. We subtract one from this
12562 measurement, because the argument pack expression
12563 itself is already counted as 1 in
12564 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
12565 the argument pack is empty. */
12566 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
12568 else if (ARGUMENT_PACK_P (orig_arg
))
12570 /* Substitute into each of the arguments. */
12571 new_arg
= TYPE_P (orig_arg
)
12572 ? cxx_make_type (TREE_CODE (orig_arg
))
12573 : make_node (TREE_CODE (orig_arg
));
12575 tree pack_args
= tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
12576 args
, complain
, in_decl
);
12577 if (pack_args
== error_mark_node
)
12578 new_arg
= error_mark_node
;
12580 SET_ARGUMENT_PACK_ARGS (new_arg
, pack_args
);
12582 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
)
12583 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
12586 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
12588 if (new_arg
== error_mark_node
)
12589 return error_mark_node
;
12592 if (new_arg
!= orig_arg
)
12599 /* Make space for the expanded arguments coming from template
12601 t
= make_tree_vec (len
+ expanded_len_adjust
);
12602 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
12603 arguments for a member template.
12604 In that case each TREE_VEC in ORIG_T represents a level of template
12605 arguments, and ORIG_T won't carry any non defaulted argument count.
12606 It will rather be the nested TREE_VECs that will carry one.
12607 In other words, ORIG_T carries a non defaulted argument count only
12608 if it doesn't contain any nested TREE_VEC. */
12609 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
12611 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
12612 count
+= expanded_len_adjust
;
12613 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
12615 for (i
= 0, out
= 0; i
< len
; i
++)
12617 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
12618 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
12619 && TREE_CODE (elts
[i
]) == TREE_VEC
)
12623 /* Now expand the template argument pack "in place". */
12624 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
12625 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
12629 TREE_VEC_ELT (t
, out
) = elts
[i
];
12637 /* Substitute ARGS into one level PARMS of template parameters. */
12640 tsubst_template_parms_level (tree parms
, tree args
, tsubst_flags_t complain
)
12642 if (parms
== error_mark_node
)
12643 return error_mark_node
;
12645 tree new_vec
= make_tree_vec (TREE_VEC_LENGTH (parms
));
12647 for (int i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
12649 tree tuple
= TREE_VEC_ELT (parms
, i
);
12651 if (tuple
== error_mark_node
)
12654 TREE_VEC_ELT (new_vec
, i
) =
12655 tsubst_template_parm (tuple
, args
, complain
);
12661 /* Return the result of substituting ARGS into the template parameters
12662 given by PARMS. If there are m levels of ARGS and m + n levels of
12663 PARMS, then the result will contain n levels of PARMS. For
12664 example, if PARMS is `template <class T> template <class U>
12665 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
12666 result will be `template <int*, double, class V>'. */
12669 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
12671 tree r
= NULL_TREE
;
12674 /* When substituting into a template, we must set
12675 PROCESSING_TEMPLATE_DECL as the template parameters may be
12676 dependent if they are based on one-another, and the dependency
12677 predicates are short-circuit outside of templates. */
12678 ++processing_template_decl
;
12680 for (new_parms
= &r
;
12681 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
12682 new_parms
= &(TREE_CHAIN (*new_parms
)),
12683 parms
= TREE_CHAIN (parms
))
12685 tree new_vec
= tsubst_template_parms_level (TREE_VALUE (parms
),
12688 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
12689 - TMPL_ARGS_DEPTH (args
)),
12690 new_vec
, NULL_TREE
);
12693 --processing_template_decl
;
12698 /* Return the result of substituting ARGS into one template parameter
12699 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
12700 parameter and which TREE_PURPOSE is the default argument of the
12701 template parameter. */
12704 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
12706 tree default_value
, parm_decl
;
12708 if (args
== NULL_TREE
12710 || t
== error_mark_node
)
12713 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
12715 default_value
= TREE_PURPOSE (t
);
12716 parm_decl
= TREE_VALUE (t
);
12718 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
12719 if (TREE_CODE (parm_decl
) == PARM_DECL
12720 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
12721 parm_decl
= error_mark_node
;
12722 default_value
= tsubst_template_arg (default_value
, args
,
12723 complain
, NULL_TREE
);
12725 return build_tree_list (default_value
, parm_decl
);
12728 /* Substitute the ARGS into the indicated aggregate (or enumeration)
12729 type T. If T is not an aggregate or enumeration type, it is
12730 handled as if by tsubst. IN_DECL is as for tsubst. If
12731 ENTERING_SCOPE is nonzero, T is the context for a template which
12732 we are presently tsubst'ing. Return the substituted value. */
12735 tsubst_aggr_type (tree t
,
12737 tsubst_flags_t complain
,
12739 int entering_scope
)
12741 if (t
== NULL_TREE
)
12744 switch (TREE_CODE (t
))
12747 if (TYPE_PTRMEMFUNC_P (t
))
12748 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
12750 /* Fall through. */
12751 case ENUMERAL_TYPE
:
12753 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
12759 /* In "sizeof(X<I>)" we need to evaluate "I". */
12762 /* First, determine the context for the type we are looking
12764 context
= TYPE_CONTEXT (t
);
12765 if (context
&& TYPE_P (context
))
12767 context
= tsubst_aggr_type (context
, args
, complain
,
12768 in_decl
, /*entering_scope=*/1);
12769 /* If context is a nested class inside a class template,
12770 it may still need to be instantiated (c++/33959). */
12771 context
= complete_type (context
);
12774 /* Then, figure out what arguments are appropriate for the
12775 type we are trying to find. For example, given:
12777 template <class T> struct S;
12778 template <class T, class U> void f(T, U) { S<U> su; }
12780 and supposing that we are instantiating f<int, double>,
12781 then our ARGS will be {int, double}, but, when looking up
12782 S we only want {double}. */
12783 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
12784 complain
, in_decl
);
12785 if (argvec
== error_mark_node
)
12786 r
= error_mark_node
;
12789 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
12790 entering_scope
, complain
);
12791 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12797 /* This is not a template type, so there's nothing to do. */
12801 return tsubst (t
, args
, complain
, in_decl
);
12805 static GTY((cache
)) tree_cache_map
*defarg_inst
;
12807 /* Substitute into the default argument ARG (a default argument for
12808 FN), which has the indicated TYPE. */
12811 tsubst_default_argument (tree fn
, int parmnum
, tree type
, tree arg
,
12812 tsubst_flags_t complain
)
12814 int errs
= errorcount
+ sorrycount
;
12816 /* This can happen in invalid code. */
12817 if (TREE_CODE (arg
) == DEFERRED_PARSE
)
12820 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
12821 parm
= chain_index (parmnum
, parm
);
12822 tree parmtype
= TREE_TYPE (parm
);
12823 if (DECL_BY_REFERENCE (parm
))
12824 parmtype
= TREE_TYPE (parmtype
);
12825 if (parmtype
== error_mark_node
)
12826 return error_mark_node
;
12828 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, parmtype
));
12831 if (defarg_inst
&& (slot
= defarg_inst
->get (parm
)))
12834 /* This default argument came from a template. Instantiate the
12835 default argument here, not in tsubst. In the case of
12844 we must be careful to do name lookup in the scope of S<T>,
12845 rather than in the current class. */
12846 push_to_top_level ();
12847 push_access_scope (fn
);
12848 push_deferring_access_checks (dk_no_deferred
);
12849 start_lambda_scope (parm
);
12851 /* The default argument expression may cause implicitly defined
12852 member functions to be synthesized, which will result in garbage
12853 collection. We must treat this situation as if we were within
12854 the body of function so as to avoid collecting live data on the
12857 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
12858 complain
, NULL_TREE
,
12859 /*integral_constant_expression_p=*/false);
12862 finish_lambda_scope ();
12864 /* Make sure the default argument is reasonable. */
12865 arg
= check_default_argument (type
, arg
, complain
);
12867 if (errorcount
+sorrycount
> errs
12868 && (complain
& tf_warning_or_error
))
12869 inform (input_location
,
12870 " when instantiating default argument for call to %qD", fn
);
12872 pop_deferring_access_checks ();
12873 pop_access_scope (fn
);
12874 pop_from_top_level ();
12876 if (arg
!= error_mark_node
&& !cp_unevaluated_operand
)
12879 defarg_inst
= tree_cache_map::create_ggc (37);
12880 defarg_inst
->put (parm
, arg
);
12886 /* Substitute into all the default arguments for FN. */
12889 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
12894 tmpl_args
= DECL_TI_ARGS (fn
);
12896 /* If this function is not yet instantiated, we certainly don't need
12897 its default arguments. */
12898 if (uses_template_parms (tmpl_args
))
12900 /* Don't do this again for clones. */
12901 if (DECL_CLONED_FUNCTION_P (fn
))
12905 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
12907 arg
= TREE_CHAIN (arg
), ++i
)
12908 if (TREE_PURPOSE (arg
))
12909 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
, i
,
12911 TREE_PURPOSE (arg
),
12915 /* Hash table mapping a FUNCTION_DECL to its dependent explicit-specifier. */
12916 static GTY((cache
)) tree_cache_map
*explicit_specifier_map
;
12918 /* Store a pair to EXPLICIT_SPECIFIER_MAP. */
12921 store_explicit_specifier (tree v
, tree t
)
12923 if (!explicit_specifier_map
)
12924 explicit_specifier_map
= tree_cache_map::create_ggc (37);
12925 DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (v
) = true;
12926 explicit_specifier_map
->put (v
, t
);
12929 /* Lookup an element in EXPLICIT_SPECIFIER_MAP. */
12932 lookup_explicit_specifier (tree v
)
12934 return *explicit_specifier_map
->get (v
);
12937 /* Subroutine of tsubst_decl for the case when T is a FUNCTION_DECL. */
12940 tsubst_function_decl (tree t
, tree args
, tsubst_flags_t complain
,
12941 tree lambda_fntype
)
12943 tree gen_tmpl
, argvec
;
12944 hashval_t hash
= 0;
12947 /* Nobody should be tsubst'ing into non-template functions. */
12948 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
12950 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
12952 /* If T is not dependent, just return it. */
12953 if (!uses_template_parms (DECL_TI_ARGS (t
))
12954 && !LAMBDA_FUNCTION_P (t
))
12957 /* Calculate the most general template of which R is a
12959 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
12961 /* We're substituting a lambda function under tsubst_lambda_expr but not
12962 directly from it; find the matching function we're already inside.
12963 But don't do this if T is a generic lambda with a single level of
12964 template parms, as in that case we're doing a normal instantiation. */
12965 if (LAMBDA_FUNCTION_P (t
) && !lambda_fntype
12966 && (!generic_lambda_fn_p (t
)
12967 || TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
)) > 1))
12968 return enclosing_instantiation_of (t
);
12970 /* Calculate the complete set of arguments used to
12972 argvec
= tsubst_template_args (DECL_TI_ARGS
12973 (DECL_TEMPLATE_RESULT
12974 (DECL_TI_TEMPLATE (t
))),
12975 args
, complain
, in_decl
);
12976 if (argvec
== error_mark_node
)
12977 return error_mark_node
;
12979 /* Check to see if we already have this specialization. */
12980 if (!lambda_fntype
)
12982 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
12983 if (tree spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
))
12987 /* We can see more levels of arguments than parameters if
12988 there was a specialization of a member template, like
12991 template <class T> struct S { template <class U> void f(); }
12992 template <> template <class U> void S<int>::f(U);
12994 Here, we'll be substituting into the specialization,
12995 because that's where we can find the code we actually
12996 want to generate, but we'll have enough arguments for
12997 the most general template.
12999 We also deal with the peculiar case:
13001 template <class T> struct S {
13002 template <class U> friend void f();
13004 template <class U> void f() {}
13006 template void f<double>();
13008 Here, the ARGS for the instantiation of will be {int,
13009 double}. But, we only need as many ARGS as there are
13010 levels of template parameters in CODE_PATTERN. We are
13011 careful not to get fooled into reducing the ARGS in
13014 template <class T> struct S { template <class U> void f(U); }
13015 template <class T> template <> void S<T>::f(int) {}
13017 which we can spot because the pattern will be a
13018 specialization in this case. */
13019 int args_depth
= TMPL_ARGS_DEPTH (args
);
13021 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
13023 if (args_depth
> parms_depth
&& !DECL_TEMPLATE_SPECIALIZATION (t
))
13024 args
= get_innermost_template_args (args
, parms_depth
);
13028 /* This special case arises when we have something like this:
13030 template <class T> struct S {
13031 friend void f<int>(int, double);
13034 Here, the DECL_TI_TEMPLATE for the friend declaration
13035 will be an IDENTIFIER_NODE. We are being called from
13036 tsubst_friend_function, and we want only to create a
13037 new decl (R) with appropriate types so that we can call
13038 determine_specialization. */
13039 gen_tmpl
= NULL_TREE
;
13040 argvec
= NULL_TREE
;
13043 tree closure
= (lambda_fntype
? TYPE_METHOD_BASETYPE (lambda_fntype
)
13045 tree ctx
= closure
? closure
: DECL_CONTEXT (t
);
13046 bool member
= ctx
&& TYPE_P (ctx
);
13048 if (member
&& !closure
)
13049 ctx
= tsubst_aggr_type (ctx
, args
,
13050 complain
, t
, /*entering_scope=*/1);
13052 tree type
= (lambda_fntype
? lambda_fntype
13053 : tsubst (TREE_TYPE (t
), args
,
13054 complain
| tf_fndecl_type
, in_decl
));
13055 if (type
== error_mark_node
)
13056 return error_mark_node
;
13058 /* If we hit excessive deduction depth, the type is bogus even if
13059 it isn't error_mark_node, so don't build a decl. */
13060 if (excessive_deduction_depth
)
13061 return error_mark_node
;
13063 /* We do NOT check for matching decls pushed separately at this
13064 point, as they may not represent instantiations of this
13065 template, and in any case are considered separate under the
13067 tree r
= copy_decl (t
);
13068 DECL_USE_TEMPLATE (r
) = 0;
13069 TREE_TYPE (r
) = type
;
13070 /* Clear out the mangled name and RTL for the instantiation. */
13071 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
13072 SET_DECL_RTL (r
, NULL
);
13073 /* Leave DECL_INITIAL set on deleted instantiations. */
13074 if (!DECL_DELETED_FN (r
))
13075 DECL_INITIAL (r
) = NULL_TREE
;
13076 DECL_CONTEXT (r
) = ctx
;
13078 /* Handle explicit(dependent-expr). */
13079 if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t
))
13081 tree spec
= lookup_explicit_specifier (t
);
13082 spec
= tsubst_copy_and_build (spec
, args
, complain
, in_decl
,
13083 /*function_p=*/false,
13085 spec
= build_explicit_specifier (spec
, complain
);
13086 DECL_NONCONVERTING_P (r
) = (spec
== boolean_true_node
);
13089 /* OpenMP UDRs have the only argument a reference to the declared
13090 type. We want to diagnose if the declared type is a reference,
13091 which is invalid, but as references to references are usually
13092 quietly merged, diagnose it here. */
13093 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
13096 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
13097 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
13098 if (TYPE_REF_P (argtype
))
13099 error_at (DECL_SOURCE_LOCATION (t
),
13100 "reference type %qT in "
13101 "%<#pragma omp declare reduction%>", argtype
);
13102 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
13103 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
13107 if (member
&& DECL_CONV_FN_P (r
))
13108 /* Type-conversion operator. Reconstruct the name, in
13109 case it's the name of one of the template's parameters. */
13110 DECL_NAME (r
) = make_conv_op_name (TREE_TYPE (type
));
13112 tree parms
= DECL_ARGUMENTS (t
);
13114 parms
= DECL_CHAIN (parms
);
13115 parms
= tsubst (parms
, args
, complain
, t
);
13116 for (tree parm
= parms
; parm
; parm
= DECL_CHAIN (parm
))
13117 DECL_CONTEXT (parm
) = r
;
13120 tree tparm
= build_this_parm (r
, closure
, type_memfn_quals (type
));
13121 DECL_CHAIN (tparm
) = parms
;
13124 DECL_ARGUMENTS (r
) = parms
;
13125 DECL_RESULT (r
) = NULL_TREE
;
13127 TREE_STATIC (r
) = 0;
13128 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
13129 DECL_EXTERNAL (r
) = 1;
13130 /* If this is an instantiation of a function with internal
13131 linkage, we already know what object file linkage will be
13132 assigned to the instantiation. */
13133 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
13134 DECL_DEFER_OUTPUT (r
) = 0;
13135 DECL_CHAIN (r
) = NULL_TREE
;
13136 DECL_PENDING_INLINE_INFO (r
) = 0;
13137 DECL_PENDING_INLINE_P (r
) = 0;
13138 DECL_SAVED_TREE (r
) = NULL_TREE
;
13139 DECL_STRUCT_FUNCTION (r
) = NULL
;
13141 /* We'll re-clone as appropriate in instantiate_template. */
13142 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
13144 /* If we aren't complaining now, return on error before we register
13145 the specialization so that we'll complain eventually. */
13146 if ((complain
& tf_error
) == 0
13147 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
13148 && !grok_op_properties (r
, /*complain=*/false))
13149 return error_mark_node
;
13151 /* When instantiating a constrained member, substitute
13152 into the constraints to create a new constraint. */
13153 if (tree ci
= get_constraints (t
))
13156 ci
= tsubst_constraint_info (ci
, argvec
, complain
, NULL_TREE
);
13157 set_constraints (r
, ci
);
13160 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
13161 SET_DECL_FRIEND_CONTEXT (r
,
13162 tsubst (DECL_FRIEND_CONTEXT (t
),
13163 args
, complain
, in_decl
));
13165 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
13166 this in the special friend case mentioned above where
13167 GEN_TMPL is NULL. */
13168 if (gen_tmpl
&& !closure
)
13170 DECL_TEMPLATE_INFO (r
)
13171 = build_template_info (gen_tmpl
, argvec
);
13172 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13175 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
13177 /* We instantiated this while substituting into
13178 the type earlier (template/friend54.C). */
13181 /* We're not supposed to instantiate default arguments
13182 until they are called, for a template. But, for a
13185 template <class T> void f ()
13186 { extern void g(int i = T()); }
13188 we should do the substitution when the template is
13189 instantiated. We handle the member function case in
13190 instantiate_class_template since the default arguments
13191 might refer to other members of the class. */
13193 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
13194 && !uses_template_parms (argvec
))
13195 tsubst_default_arguments (r
, complain
);
13198 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13200 /* Copy the list of befriending classes. */
13201 for (tree
*friends
= &DECL_BEFRIENDING_CLASSES (r
);
13203 friends
= &TREE_CHAIN (*friends
))
13205 *friends
= copy_node (*friends
);
13206 TREE_VALUE (*friends
)
13207 = tsubst (TREE_VALUE (*friends
), args
, complain
, in_decl
);
13210 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
13212 maybe_retrofit_in_chrg (r
);
13213 if (DECL_CONSTRUCTOR_P (r
) && !grok_ctor_properties (ctx
, r
))
13214 return error_mark_node
;
13215 /* If this is an instantiation of a member template, clone it.
13216 If it isn't, that'll be handled by
13217 clone_constructors_and_destructors. */
13218 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
13219 clone_function_decl (r
, /*update_methods=*/false);
13221 else if ((complain
& tf_error
) != 0
13222 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
13223 && !grok_op_properties (r
, /*complain=*/true))
13224 return error_mark_node
;
13226 /* Possibly limit visibility based on template args. */
13227 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
13228 if (DECL_VISIBILITY_SPECIFIED (t
))
13230 DECL_VISIBILITY_SPECIFIED (r
) = 0;
13231 DECL_ATTRIBUTES (r
)
13232 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
13234 determine_visibility (r
);
13235 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
13236 && !processing_template_decl
)
13237 defaulted_late_check (r
);
13239 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
13240 args
, complain
, in_decl
);
13244 /* Subroutine of tsubst_decl for the case when T is a TEMPLATE_DECL. */
13247 tsubst_template_decl (tree t
, tree args
, tsubst_flags_t complain
,
13248 tree lambda_fntype
)
13250 /* We can get here when processing a member function template,
13251 member class template, or template template parameter. */
13252 tree decl
= DECL_TEMPLATE_RESULT (t
);
13258 hashval_t hash
= 0;
13260 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
13262 /* Template template parameter is treated here. */
13263 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13264 if (new_type
== error_mark_node
)
13265 r
= error_mark_node
;
13266 /* If we get a real template back, return it. This can happen in
13267 the context of most_specialized_partial_spec. */
13268 else if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
13271 /* The new TEMPLATE_DECL was built in
13272 reduce_template_parm_level. */
13273 r
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (new_type
);
13277 if (!lambda_fntype
)
13279 /* We might already have an instance of this template.
13280 The ARGS are for the surrounding class type, so the
13281 full args contain the tsubst'd args for the context,
13282 plus the innermost args from the template decl. */
13283 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
13284 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
13285 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
13286 /* Because this is a template, the arguments will still be
13287 dependent, even after substitution. If
13288 PROCESSING_TEMPLATE_DECL is not set, the dependency
13289 predicates will short-circuit. */
13290 ++processing_template_decl
;
13291 full_args
= tsubst_template_args (tmpl_args
, args
,
13292 complain
, in_decl
);
13293 --processing_template_decl
;
13294 if (full_args
== error_mark_node
)
13295 return error_mark_node
;
13297 /* If this is a default template template argument,
13298 tsubst might not have changed anything. */
13299 if (full_args
== tmpl_args
)
13302 hash
= hash_tmpl_and_args (t
, full_args
);
13303 spec
= retrieve_specialization (t
, full_args
, hash
);
13304 if (spec
!= NULL_TREE
)
13307 /* Type partial instantiations are stored as the type by
13308 lookup_template_class_1, not here as the template. */
13309 spec
= CLASSTYPE_TI_TEMPLATE (spec
);
13314 /* Make a new template decl. It will be similar to the
13315 original, but will record the current template arguments.
13316 We also create a new function declaration, which is just
13317 like the old one, but points to this new template, rather
13318 than the old one. */
13320 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
13321 DECL_CHAIN (r
) = NULL_TREE
;
13323 // Build new template info linking to the original template decl.
13324 if (!lambda_fntype
)
13326 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
13327 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13330 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13332 /* The template parameters for this new template are all the
13333 template parameters for the old template, except the
13334 outermost level of parameters. */
13335 DECL_TEMPLATE_PARMS (r
)
13336 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
13339 if (TREE_CODE (decl
) == TYPE_DECL
13340 && !TYPE_DECL_ALIAS_P (decl
))
13343 ++processing_template_decl
;
13344 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13345 --processing_template_decl
;
13346 if (new_type
== error_mark_node
)
13347 return error_mark_node
;
13349 TREE_TYPE (r
) = new_type
;
13350 /* For a partial specialization, we need to keep pointing to
13351 the primary template. */
13352 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
13353 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
13354 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
13355 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
13356 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
13361 ++processing_template_decl
;
13362 if (TREE_CODE (decl
) == FUNCTION_DECL
)
13363 new_decl
= tsubst_function_decl (decl
, args
, complain
, lambda_fntype
);
13365 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
13366 --processing_template_decl
;
13367 if (new_decl
== error_mark_node
)
13368 return error_mark_node
;
13370 DECL_TEMPLATE_RESULT (r
) = new_decl
;
13371 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
13372 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
13375 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (r
));
13376 DECL_TEMPLATE_INFO (new_decl
) = build_template_info (r
, args
);
13380 DECL_TI_TEMPLATE (new_decl
) = r
;
13381 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
13385 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
13386 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
13388 if (PRIMARY_TEMPLATE_P (t
))
13389 DECL_PRIMARY_TEMPLATE (r
) = r
;
13391 if (TREE_CODE (decl
) != TYPE_DECL
&& !VAR_P (decl
)
13393 /* Record this non-type partial instantiation. */
13394 register_specialization (r
, t
,
13395 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
13401 /* True if FN is the op() for a lambda in an uninstantiated template. */
13404 lambda_fn_in_template_p (tree fn
)
13406 if (!fn
|| !LAMBDA_FUNCTION_P (fn
))
13408 tree closure
= DECL_CONTEXT (fn
);
13409 return CLASSTYPE_TEMPLATE_INFO (closure
) != NULL_TREE
;
13412 /* True if FN is the substitution (via tsubst_lambda_expr) of a function for
13413 which the above is true. */
13416 instantiated_lambda_fn_p (tree fn
)
13418 if (!fn
|| !LAMBDA_FUNCTION_P (fn
))
13420 tree closure
= DECL_CONTEXT (fn
);
13421 tree lam
= CLASSTYPE_LAMBDA_EXPR (closure
);
13422 return LAMBDA_EXPR_INSTANTIATED (lam
);
13425 /* We're instantiating a variable from template function TCTX. Return the
13426 corresponding current enclosing scope. This gets complicated because lambda
13427 functions in templates are regenerated rather than instantiated, but generic
13428 lambda functions are subsequently instantiated. */
13431 enclosing_instantiation_of (tree otctx
)
13434 tree fn
= current_function_decl
;
13435 int lambda_count
= 0;
13437 for (; tctx
&& (lambda_fn_in_template_p (tctx
)
13438 || instantiated_lambda_fn_p (tctx
));
13439 tctx
= decl_function_context (tctx
))
13441 for (; fn
; fn
= decl_function_context (fn
))
13444 int flambda_count
= 0;
13445 for (; fn
&& instantiated_lambda_fn_p (fn
);
13446 fn
= decl_function_context (fn
))
13448 if ((fn
&& DECL_TEMPLATE_INFO (fn
))
13449 ? most_general_template (fn
) != most_general_template (tctx
)
13452 if (flambda_count
!= lambda_count
)
13454 gcc_assert (flambda_count
> lambda_count
);
13455 for (; flambda_count
> lambda_count
; --flambda_count
)
13456 ofn
= decl_function_context (ofn
);
13458 gcc_assert (DECL_NAME (ofn
) == DECL_NAME (otctx
)
13459 || DECL_CONV_FN_P (ofn
));
13462 gcc_unreachable ();
13465 /* Substitute the ARGS into the T, which is a _DECL. Return the
13466 result of the substitution. Issue error and warning messages under
13467 control of COMPLAIN. */
13470 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
13472 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13473 location_t saved_loc
;
13474 tree r
= NULL_TREE
;
13476 hashval_t hash
= 0;
13478 /* Set the filename and linenumber to improve error-reporting. */
13479 saved_loc
= input_location
;
13480 input_location
= DECL_SOURCE_LOCATION (t
);
13482 switch (TREE_CODE (t
))
13484 case TEMPLATE_DECL
:
13485 r
= tsubst_template_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
13488 case FUNCTION_DECL
:
13489 r
= tsubst_function_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
13494 tree type
= NULL_TREE
;
13496 tree expanded_types
= NULL_TREE
;
13497 tree prev_r
= NULL_TREE
;
13498 tree first_r
= NULL_TREE
;
13500 if (DECL_PACK_P (t
))
13502 /* If there is a local specialization that isn't a
13503 parameter pack, it means that we're doing a "simple"
13504 substitution from inside tsubst_pack_expansion. Just
13505 return the local specialization (which will be a single
13507 tree spec
= retrieve_local_specialization (t
);
13509 && TREE_CODE (spec
) == PARM_DECL
13510 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
13513 /* Expand the TYPE_PACK_EXPANSION that provides the types for
13514 the parameters in this function parameter pack. */
13515 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
13516 complain
, in_decl
);
13517 if (TREE_CODE (expanded_types
) == TREE_VEC
)
13519 len
= TREE_VEC_LENGTH (expanded_types
);
13521 /* Zero-length parameter packs are boring. Just substitute
13524 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
13529 /* All we did was update the type. Make a note of that. */
13530 type
= expanded_types
;
13531 expanded_types
= NULL_TREE
;
13535 /* Loop through all of the parameters we'll build. When T is
13536 a function parameter pack, LEN is the number of expanded
13537 types in EXPANDED_TYPES; otherwise, LEN is 1. */
13539 for (i
= 0; i
< len
; ++i
)
13543 if (DECL_TEMPLATE_PARM_P (t
))
13544 SET_DECL_TEMPLATE_PARM_P (r
);
13546 if (expanded_types
)
13547 /* We're on the Ith parameter of the function parameter
13550 /* Get the Ith type. */
13551 type
= TREE_VEC_ELT (expanded_types
, i
);
13553 /* Rename the parameter to include the index. */
13555 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
13558 /* We're dealing with a normal parameter. */
13559 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13561 type
= type_decays_to (type
);
13562 TREE_TYPE (r
) = type
;
13563 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13565 if (DECL_INITIAL (r
))
13567 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
13568 DECL_INITIAL (r
) = TREE_TYPE (r
);
13570 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
13571 complain
, in_decl
);
13574 DECL_CONTEXT (r
) = NULL_TREE
;
13576 if (!DECL_TEMPLATE_PARM_P (r
))
13577 DECL_ARG_TYPE (r
) = type_passed_as (type
);
13579 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
13580 args
, complain
, in_decl
);
13582 /* Keep track of the first new parameter we
13583 generate. That's what will be returned to the
13588 /* Build a proper chain of parameters when substituting
13589 into a function parameter pack. */
13591 DECL_CHAIN (prev_r
) = r
;
13594 /* If cp_unevaluated_operand is set, we're just looking for a
13595 single dummy parameter, so don't keep going. */
13596 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
13597 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
13598 complain
, DECL_CHAIN (t
));
13600 /* FIRST_R contains the start of the chain we've built. */
13607 tree type
= NULL_TREE
;
13608 tree vec
= NULL_TREE
;
13609 tree expanded_types
= NULL_TREE
;
13612 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
13614 /* This field is a lambda capture pack. Return a TREE_VEC of
13615 the expanded fields to instantiate_class_template_1. */
13616 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
13617 complain
, in_decl
);
13618 if (TREE_CODE (expanded_types
) == TREE_VEC
)
13620 len
= TREE_VEC_LENGTH (expanded_types
);
13621 vec
= make_tree_vec (len
);
13625 /* All we did was update the type. Make a note of that. */
13626 type
= expanded_types
;
13627 expanded_types
= NULL_TREE
;
13631 for (int i
= 0; i
< len
; ++i
)
13634 if (expanded_types
)
13636 type
= TREE_VEC_ELT (expanded_types
, i
);
13638 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
13641 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13643 if (type
== error_mark_node
)
13644 RETURN (error_mark_node
);
13645 TREE_TYPE (r
) = type
;
13646 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13648 if (DECL_C_BIT_FIELD (r
))
13649 /* For bit-fields, DECL_BIT_FIELD_REPRESENTATIVE gives the
13651 DECL_BIT_FIELD_REPRESENTATIVE (r
)
13652 = tsubst_expr (DECL_BIT_FIELD_REPRESENTATIVE (t
), args
,
13654 /*integral_constant_expression_p=*/true);
13655 if (DECL_INITIAL (t
))
13657 /* Set up DECL_TEMPLATE_INFO so that we can get at the
13658 NSDMI in perform_member_init. Still set DECL_INITIAL
13659 so that we know there is one. */
13660 DECL_INITIAL (r
) = void_node
;
13661 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
13662 retrofit_lang_decl (r
);
13663 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
13665 /* We don't have to set DECL_CONTEXT here; it is set by
13666 finish_member_declaration. */
13667 DECL_CHAIN (r
) = NULL_TREE
;
13669 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
13670 args
, complain
, in_decl
);
13673 TREE_VEC_ELT (vec
, i
) = r
;
13682 /* We reach here only for member using decls. We also need to check
13683 uses_template_parms because DECL_DEPENDENT_P is not set for a
13684 using-declaration that designates a member of the current
13685 instantiation (c++/53549). */
13686 if (DECL_DEPENDENT_P (t
)
13687 || uses_template_parms (USING_DECL_SCOPE (t
)))
13689 tree scope
= USING_DECL_SCOPE (t
);
13690 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
13691 if (PACK_EXPANSION_P (scope
))
13693 tree vec
= tsubst_pack_expansion (scope
, args
, complain
, in_decl
);
13694 int len
= TREE_VEC_LENGTH (vec
);
13695 r
= make_tree_vec (len
);
13696 for (int i
= 0; i
< len
; ++i
)
13698 tree escope
= TREE_VEC_ELT (vec
, i
);
13699 tree elt
= do_class_using_decl (escope
, name
);
13702 r
= error_mark_node
;
13707 TREE_PROTECTED (elt
) = TREE_PROTECTED (t
);
13708 TREE_PRIVATE (elt
) = TREE_PRIVATE (t
);
13710 TREE_VEC_ELT (r
, i
) = elt
;
13715 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
13716 complain
, in_decl
);
13717 r
= do_class_using_decl (inst_scope
, name
);
13719 r
= error_mark_node
;
13722 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
13723 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
13730 DECL_CHAIN (r
) = NULL_TREE
;
13737 tree argvec
= NULL_TREE
;
13738 tree gen_tmpl
= NULL_TREE
;
13740 tree tmpl
= NULL_TREE
;
13742 tree type
= NULL_TREE
;
13745 if (TREE_TYPE (t
) == error_mark_node
)
13746 RETURN (error_mark_node
);
13748 if (TREE_CODE (t
) == TYPE_DECL
13749 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
13751 /* If this is the canonical decl, we don't have to
13752 mess with instantiations, and often we can't (for
13753 typename, template type parms and such). Note that
13754 TYPE_NAME is not correct for the above test if
13755 we've copied the type for a typedef. */
13756 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13757 if (type
== error_mark_node
)
13758 RETURN (error_mark_node
);
13759 r
= TYPE_NAME (type
);
13763 /* Check to see if we already have the specialization we
13766 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
13768 /* T is a static data member or namespace-scope entity.
13769 We have to substitute into namespace-scope variables
13770 (not just variable templates) because of cases like:
13772 template <class T> void f() { extern T t; }
13774 where the entity referenced is not known until
13775 instantiation time. */
13777 ctx
= DECL_CONTEXT (t
);
13778 if (DECL_CLASS_SCOPE_P (t
))
13780 ctx
= tsubst_aggr_type (ctx
, args
,
13782 in_decl
, /*entering_scope=*/1);
13783 /* If CTX is unchanged, then T is in fact the
13784 specialization we want. That situation occurs when
13785 referencing a static data member within in its own
13786 class. We can use pointer equality, rather than
13787 same_type_p, because DECL_CONTEXT is always
13789 if (ctx
== DECL_CONTEXT (t
)
13790 /* ... unless T is a member template; in which
13791 case our caller can be willing to create a
13792 specialization of that template represented
13794 && !(DECL_TI_TEMPLATE (t
)
13795 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
13801 tmpl
= DECL_TI_TEMPLATE (t
);
13802 gen_tmpl
= most_general_template (tmpl
);
13803 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
13804 if (argvec
!= error_mark_node
)
13805 argvec
= (coerce_innermost_template_parms
13806 (DECL_TEMPLATE_PARMS (gen_tmpl
),
13807 argvec
, t
, complain
,
13808 /*all*/true, /*defarg*/true));
13809 if (argvec
== error_mark_node
)
13810 RETURN (error_mark_node
);
13811 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
13812 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
13817 /* A local variable. */
13819 /* Subsequent calls to pushdecl will fill this in. */
13821 /* Unless this is a reference to a static variable from an
13822 enclosing function, in which case we need to fill it in now. */
13823 if (TREE_STATIC (t
))
13825 tree fn
= enclosing_instantiation_of (DECL_CONTEXT (t
));
13826 if (fn
!= current_function_decl
)
13829 spec
= retrieve_local_specialization (t
);
13831 /* If we already have the specialization we need, there is
13832 nothing more to do. */
13839 /* Create a new node for the specialization we need. */
13840 if (type
== NULL_TREE
)
13842 if (is_typedef_decl (t
))
13843 type
= DECL_ORIGINAL_TYPE (t
);
13845 type
= TREE_TYPE (t
);
13847 && VAR_HAD_UNKNOWN_BOUND (t
)
13848 && type
!= error_mark_node
)
13849 type
= strip_array_domain (type
);
13850 tree sub_args
= args
;
13851 if (tree auto_node
= type_uses_auto (type
))
13853 /* Mask off any template args past the variable's context so we
13854 don't replace the auto with an unrelated argument. */
13855 int nouter
= TEMPLATE_TYPE_LEVEL (auto_node
) - 1;
13856 int extra
= TMPL_ARGS_DEPTH (args
) - nouter
;
13858 /* This should never happen with the new lambda instantiation
13859 model, but keep the handling just in case. */
13860 gcc_assert (!CHECKING_P
),
13861 sub_args
= strip_innermost_template_args (args
, extra
);
13863 type
= tsubst (type
, sub_args
, complain
, in_decl
);
13864 /* Substituting the type might have recursively instantiated this
13865 same alias (c++/86171). */
13866 if (gen_tmpl
&& DECL_ALIAS_TEMPLATE_P (gen_tmpl
)
13867 && (spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
)))
13876 DECL_INITIALIZED_P (r
) = 0;
13877 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
13878 if (type
== error_mark_node
)
13879 RETURN (error_mark_node
);
13880 if (TREE_CODE (type
) == FUNCTION_TYPE
)
13882 /* It may seem that this case cannot occur, since:
13887 declares a function, not a variable. However:
13890 template <typename T> void g() { T t; }
13891 template void g<f>();
13893 is an attempt to declare a variable with function
13895 error ("variable %qD has function type",
13896 /* R is not yet sufficiently initialized, so we
13897 just use its name. */
13899 RETURN (error_mark_node
);
13901 type
= complete_type (type
);
13902 /* Wait until cp_finish_decl to set this again, to handle
13903 circular dependency (template/instantiate6.C). */
13904 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
13905 type
= check_var_type (DECL_NAME (r
), type
);
13907 if (DECL_HAS_VALUE_EXPR_P (t
))
13909 tree ve
= DECL_VALUE_EXPR (t
);
13910 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
13911 /*constant_expression_p=*/false);
13912 if (REFERENCE_REF_P (ve
))
13914 gcc_assert (TYPE_REF_P (type
));
13915 ve
= TREE_OPERAND (ve
, 0);
13917 SET_DECL_VALUE_EXPR (r
, ve
);
13919 if (CP_DECL_THREAD_LOCAL_P (r
)
13920 && !processing_template_decl
)
13921 set_decl_tls_model (r
, decl_default_tls_model (r
));
13923 else if (DECL_SELF_REFERENCE_P (t
))
13924 SET_DECL_SELF_REFERENCE_P (r
);
13925 TREE_TYPE (r
) = type
;
13926 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13927 DECL_CONTEXT (r
) = ctx
;
13928 /* Clear out the mangled name and RTL for the instantiation. */
13929 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
13930 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
13931 SET_DECL_RTL (r
, NULL
);
13932 /* The initializer must not be expanded until it is required;
13933 see [temp.inst]. */
13934 DECL_INITIAL (r
) = NULL_TREE
;
13935 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
13938 if (DECL_LANG_SPECIFIC (r
))
13939 SET_DECL_DEPENDENT_INIT_P (r
, false);
13941 SET_DECL_MODE (r
, VOIDmode
);
13943 /* Possibly limit visibility based on template args. */
13944 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
13945 if (DECL_VISIBILITY_SPECIFIED (t
))
13947 DECL_VISIBILITY_SPECIFIED (r
) = 0;
13948 DECL_ATTRIBUTES (r
)
13949 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
13951 determine_visibility (r
);
13956 /* A static data member declaration is always marked
13957 external when it is declared in-class, even if an
13958 initializer is present. We mimic the non-template
13959 processing here. */
13960 DECL_EXTERNAL (r
) = 1;
13961 if (DECL_NAMESPACE_SCOPE_P (t
))
13962 DECL_NOT_REALLY_EXTERN (r
) = 1;
13964 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
13965 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13966 if (!error_operand_p (r
) || (complain
& tf_error
))
13967 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
13971 if (DECL_LANG_SPECIFIC (r
))
13972 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13973 if (!cp_unevaluated_operand
)
13974 register_local_specialization (r
, t
);
13977 DECL_CHAIN (r
) = NULL_TREE
;
13979 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
13981 args
, complain
, in_decl
);
13983 /* Preserve a typedef that names a type. */
13984 if (is_typedef_decl (r
) && type
!= error_mark_node
)
13986 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
13987 set_underlying_type (r
);
13988 if (TYPE_DECL_ALIAS_P (r
))
13989 /* An alias template specialization can be dependent
13990 even if its underlying type is not. */
13991 TYPE_DEPENDENT_P_VALID (TREE_TYPE (r
)) = false;
13994 layout_decl (r
, 0);
13999 gcc_unreachable ();
14004 /* Restore the file and line information. */
14005 input_location
= saved_loc
;
14010 /* Substitute into the ARG_TYPES of a function type.
14011 If END is a TREE_CHAIN, leave it and any following types
14015 tsubst_arg_types (tree arg_types
,
14018 tsubst_flags_t complain
,
14021 tree remaining_arg_types
;
14022 tree type
= NULL_TREE
;
14024 tree expanded_args
= NULL_TREE
;
14027 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
14030 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
14031 args
, end
, complain
, in_decl
);
14032 if (remaining_arg_types
== error_mark_node
)
14033 return error_mark_node
;
14035 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
14037 /* For a pack expansion, perform substitution on the
14038 entire expression. Later on, we'll handle the arguments
14040 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
14041 args
, complain
, in_decl
);
14043 if (TREE_CODE (expanded_args
) == TREE_VEC
)
14044 /* So that we'll spin through the parameters, one by one. */
14045 i
= TREE_VEC_LENGTH (expanded_args
);
14048 /* We only partially substituted into the parameter
14049 pack. Our type is TYPE_PACK_EXPANSION. */
14050 type
= expanded_args
;
14051 expanded_args
= NULL_TREE
;
14059 type
= TREE_VEC_ELT (expanded_args
, i
);
14061 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
14063 if (type
== error_mark_node
)
14064 return error_mark_node
;
14065 if (VOID_TYPE_P (type
))
14067 if (complain
& tf_error
)
14069 error ("invalid parameter type %qT", type
);
14071 error ("in declaration %q+D", in_decl
);
14073 return error_mark_node
;
14076 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
14077 return error_mark_node
;
14079 /* Do array-to-pointer, function-to-pointer conversion, and ignore
14080 top-level qualifiers as required. */
14081 type
= cv_unqualified (type_decays_to (type
));
14083 /* We do not substitute into default arguments here. The standard
14084 mandates that they be instantiated only when needed, which is
14085 done in build_over_call. */
14086 default_arg
= TREE_PURPOSE (arg_types
);
14088 /* Except that we do substitute default arguments under tsubst_lambda_expr,
14089 since the new op() won't have any associated template arguments for us
14090 to refer to later. */
14091 if (lambda_fn_in_template_p (in_decl
))
14092 default_arg
= tsubst_copy_and_build (default_arg
, args
, complain
, in_decl
,
14093 false/*fn*/, false/*constexpr*/);
14095 if (default_arg
&& TREE_CODE (default_arg
) == DEFERRED_PARSE
)
14097 /* We've instantiated a template before its default arguments
14098 have been parsed. This can happen for a nested template
14099 class, and is not an error unless we require the default
14100 argument in a call of this function. */
14101 remaining_arg_types
=
14102 tree_cons (default_arg
, type
, remaining_arg_types
);
14103 vec_safe_push (DEFPARSE_INSTANTIATIONS (default_arg
),
14104 remaining_arg_types
);
14107 remaining_arg_types
=
14108 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
14111 return remaining_arg_types
;
14114 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
14115 *not* handle the exception-specification for FNTYPE, because the
14116 initial substitution of explicitly provided template parameters
14117 during argument deduction forbids substitution into the
14118 exception-specification:
14122 All references in the function type of the function template to the
14123 corresponding template parameters are replaced by the specified tem-
14124 plate argument values. If a substitution in a template parameter or
14125 in the function type of the function template results in an invalid
14126 type, type deduction fails. [Note: The equivalent substitution in
14127 exception specifications is done only when the function is instanti-
14128 ated, at which point a program is ill-formed if the substitution
14129 results in an invalid type.] */
14132 tsubst_function_type (tree t
,
14134 tsubst_flags_t complain
,
14138 tree arg_types
= NULL_TREE
;
14141 /* The TYPE_CONTEXT is not used for function/method types. */
14142 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
14144 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
14146 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
14148 if (late_return_type_p
)
14150 /* Substitute the argument types. */
14151 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
14152 complain
, in_decl
);
14153 if (arg_types
== error_mark_node
)
14154 return error_mark_node
;
14156 tree save_ccp
= current_class_ptr
;
14157 tree save_ccr
= current_class_ref
;
14158 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
14159 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
14160 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
14163 /* DR 1207: 'this' is in scope in the trailing return type. */
14164 inject_this_parameter (this_type
, cp_type_quals (this_type
));
14167 /* Substitute the return type. */
14168 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14172 current_class_ptr
= save_ccp
;
14173 current_class_ref
= save_ccr
;
14177 /* Substitute the return type. */
14178 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14180 if (return_type
== error_mark_node
)
14181 return error_mark_node
;
14182 /* DR 486 clarifies that creation of a function type with an
14183 invalid return type is a deduction failure. */
14184 if (TREE_CODE (return_type
) == ARRAY_TYPE
14185 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
14187 if (complain
& tf_error
)
14189 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
14190 error ("function returning an array");
14192 error ("function returning a function");
14194 return error_mark_node
;
14197 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
14198 return error_mark_node
;
14200 if (!late_return_type_p
)
14202 /* Substitute the argument types. */
14203 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
14204 complain
, in_decl
);
14205 if (arg_types
== error_mark_node
)
14206 return error_mark_node
;
14209 /* Construct a new type node and return it. */
14210 if (TREE_CODE (t
) == FUNCTION_TYPE
)
14212 fntype
= build_function_type (return_type
, arg_types
);
14213 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (t
));
14217 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
14218 /* Don't pick up extra function qualifiers from the basetype. */
14219 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
14220 if (! MAYBE_CLASS_TYPE_P (r
))
14224 Type deduction may fail for any of the following
14227 -- Attempting to create "pointer to member of T" when T
14228 is not a class type. */
14229 if (complain
& tf_error
)
14230 error ("creating pointer to member function of non-class type %qT",
14232 return error_mark_node
;
14235 fntype
= build_method_type_directly (r
, return_type
,
14236 TREE_CHAIN (arg_types
));
14238 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
14240 /* See comment above. */
14241 tree raises
= NULL_TREE
;
14242 cp_ref_qualifier rqual
= type_memfn_rqual (t
);
14243 fntype
= build_cp_fntype_variant (fntype
, rqual
, raises
, late_return_type_p
);
14248 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
14249 ARGS into that specification, and return the substituted
14250 specification. If there is no specification, return NULL_TREE. */
14253 tsubst_exception_specification (tree fntype
,
14255 tsubst_flags_t complain
,
14262 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
14263 new_specs
= NULL_TREE
;
14264 if (specs
&& TREE_PURPOSE (specs
))
14266 /* A noexcept-specifier. */
14267 tree expr
= TREE_PURPOSE (specs
);
14268 if (TREE_CODE (expr
) == INTEGER_CST
)
14272 /* Defer instantiation of noexcept-specifiers to avoid
14273 excessive instantiations (c++/49107). */
14274 new_specs
= make_node (DEFERRED_NOEXCEPT
);
14275 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
14277 /* We already partially instantiated this member template,
14278 so combine the new args with the old. */
14279 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
14280 = DEFERRED_NOEXCEPT_PATTERN (expr
);
14281 DEFERRED_NOEXCEPT_ARGS (new_specs
)
14282 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
14286 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
14287 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
14292 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
14294 args
= add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
),
14296 expr
= DEFERRED_NOEXCEPT_PATTERN (expr
);
14298 new_specs
= tsubst_copy_and_build
14299 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
14300 /*integral_constant_expression_p=*/true);
14302 new_specs
= build_noexcept_spec (new_specs
, complain
);
14306 if (! TREE_VALUE (specs
))
14313 tree expanded_specs
= NULL_TREE
;
14315 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
14317 /* Expand the pack expansion type. */
14318 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
14322 if (expanded_specs
== error_mark_node
)
14323 return error_mark_node
;
14324 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
14325 len
= TREE_VEC_LENGTH (expanded_specs
);
14328 /* We're substituting into a member template, so
14329 we got a TYPE_PACK_EXPANSION back. Add that
14330 expansion and move on. */
14331 gcc_assert (TREE_CODE (expanded_specs
)
14332 == TYPE_PACK_EXPANSION
);
14333 new_specs
= add_exception_specifier (new_specs
,
14336 specs
= TREE_CHAIN (specs
);
14341 for (i
= 0; i
< len
; ++i
)
14343 if (expanded_specs
)
14344 spec
= TREE_VEC_ELT (expanded_specs
, i
);
14346 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
14347 if (spec
== error_mark_node
)
14349 new_specs
= add_exception_specifier (new_specs
, spec
,
14353 specs
= TREE_CHAIN (specs
);
14359 /* Take the tree structure T and replace template parameters used
14360 therein with the argument vector ARGS. IN_DECL is an associated
14361 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
14362 Issue error and warning messages under control of COMPLAIN. Note
14363 that we must be relatively non-tolerant of extensions here, in
14364 order to preserve conformance; if we allow substitutions that
14365 should not be allowed, we may allow argument deductions that should
14366 not succeed, and therefore report ambiguous overload situations
14367 where there are none. In theory, we could allow the substitution,
14368 but indicate that it should have failed, and allow our caller to
14369 make sure that the right thing happens, but we don't try to do this
14372 This function is used for dealing with types, decls and the like;
14373 for expressions, use tsubst_expr or tsubst_copy. */
14376 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14378 enum tree_code code
;
14379 tree type
, r
= NULL_TREE
;
14381 if (t
== NULL_TREE
|| t
== error_mark_node
14382 || t
== integer_type_node
14383 || t
== void_type_node
14384 || t
== char_type_node
14385 || t
== unknown_type_node
14386 || TREE_CODE (t
) == NAMESPACE_DECL
14387 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
14391 return tsubst_decl (t
, args
, complain
);
14393 if (args
== NULL_TREE
)
14396 code
= TREE_CODE (t
);
14398 if (code
== IDENTIFIER_NODE
)
14399 type
= IDENTIFIER_TYPE_VALUE (t
);
14401 type
= TREE_TYPE (t
);
14403 gcc_assert (type
!= unknown_type_node
);
14405 /* Reuse typedefs. We need to do this to handle dependent attributes,
14406 such as attribute aligned. */
14408 && typedef_variant_p (t
))
14410 tree decl
= TYPE_NAME (t
);
14412 if (alias_template_specialization_p (t
))
14414 /* DECL represents an alias template and we want to
14416 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
14417 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
14418 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
14420 else if (DECL_CLASS_SCOPE_P (decl
)
14421 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
14422 && uses_template_parms (DECL_CONTEXT (decl
)))
14424 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
14425 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
14426 r
= retrieve_specialization (tmpl
, gen_args
, 0);
14428 else if (DECL_FUNCTION_SCOPE_P (decl
)
14429 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
14430 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
14431 r
= retrieve_local_specialization (decl
);
14433 /* The typedef is from a non-template context. */
14439 r
= cp_build_qualified_type_real
14440 (r
, cp_type_quals (t
) | cp_type_quals (r
),
14441 complain
| tf_ignore_bad_quals
);
14446 /* We don't have an instantiation yet, so drop the typedef. */
14447 int quals
= cp_type_quals (t
);
14448 t
= DECL_ORIGINAL_TYPE (decl
);
14449 t
= cp_build_qualified_type_real (t
, quals
,
14450 complain
| tf_ignore_bad_quals
);
14454 bool fndecl_type
= (complain
& tf_fndecl_type
);
14455 complain
&= ~tf_fndecl_type
;
14458 && code
!= TYPENAME_TYPE
14459 && code
!= TEMPLATE_TYPE_PARM
14460 && code
!= TEMPLATE_PARM_INDEX
14461 && code
!= IDENTIFIER_NODE
14462 && code
!= FUNCTION_TYPE
14463 && code
!= METHOD_TYPE
)
14464 type
= tsubst (type
, args
, complain
, in_decl
);
14465 if (type
== error_mark_node
)
14466 return error_mark_node
;
14472 case ENUMERAL_TYPE
:
14473 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
14474 /*entering_scope=*/0);
14477 case IDENTIFIER_NODE
:
14488 if (t
== integer_type_node
)
14491 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
14492 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
14496 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
14498 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
14499 /*integral_constant_expression_p=*/false);
14501 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
14503 if (TREE_CODE (max
) == NOP_EXPR
14504 && TREE_SIDE_EFFECTS (omax
)
14505 && !TREE_TYPE (max
))
14506 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
14508 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
14509 with TREE_SIDE_EFFECTS that indicates this is not an integral
14510 constant expression. */
14511 if (processing_template_decl
14512 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
14514 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
14515 TREE_SIDE_EFFECTS (max
) = 1;
14518 return compute_array_index_type (NULL_TREE
, max
, complain
);
14521 case TEMPLATE_TYPE_PARM
:
14522 case TEMPLATE_TEMPLATE_PARM
:
14523 case BOUND_TEMPLATE_TEMPLATE_PARM
:
14524 case TEMPLATE_PARM_INDEX
:
14529 tree arg
= NULL_TREE
;
14531 /* Early in template argument deduction substitution, we don't
14532 want to reduce the level of 'auto', or it will be confused
14533 with a normal template parm in subsequent deduction. */
14534 if (is_auto (t
) && (complain
& tf_partial
))
14539 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
14540 template_parm_level_and_index (t
, &level
, &idx
);
14542 levels
= TMPL_ARGS_DEPTH (args
);
14543 if (level
<= levels
14544 && TREE_VEC_LENGTH (TMPL_ARGS_LEVEL (args
, level
)) > 0)
14546 arg
= TMPL_ARG (args
, level
, idx
);
14548 /* See through ARGUMENT_PACK_SELECT arguments. */
14549 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
14550 arg
= argument_pack_select_arg (arg
);
14553 if (arg
== error_mark_node
)
14554 return error_mark_node
;
14555 else if (arg
!= NULL_TREE
)
14557 if (ARGUMENT_PACK_P (arg
))
14558 /* If ARG is an argument pack, we don't actually want to
14559 perform a substitution here, because substitutions
14560 for argument packs are only done
14561 element-by-element. We can get to this point when
14562 substituting the type of a non-type template
14563 parameter pack, when that type actually contains
14564 template parameter packs from an outer template, e.g.,
14566 template<typename... Types> struct A {
14567 template<Types... Values> struct B { };
14571 if (code
== TEMPLATE_TYPE_PARM
)
14574 gcc_assert (TYPE_P (arg
));
14576 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
14578 return cp_build_qualified_type_real
14579 (arg
, quals
, complain
| tf_ignore_bad_quals
);
14581 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
14583 /* We are processing a type constructed from a
14584 template template parameter. */
14585 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
14586 args
, complain
, in_decl
);
14587 if (argvec
== error_mark_node
)
14588 return error_mark_node
;
14590 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
14591 || TREE_CODE (arg
) == TEMPLATE_DECL
14592 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
14594 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
14595 /* Consider this code:
14597 template <template <class> class Template>
14599 template <class Arg> using Bind = Template<Arg>;
14602 template <template <class> class Template, class Arg>
14603 using Instantiate = Template<Arg>; //#0
14605 template <template <class> class Template,
14608 Instantiate<Internal<Template>::template Bind,
14611 When #1 is parsed, the
14612 BOUND_TEMPLATE_TEMPLATE_PARM representing the
14613 parameter `Template' in #0 matches the
14614 UNBOUND_CLASS_TEMPLATE representing the argument
14615 `Internal<Template>::template Bind'; We then want
14616 to assemble the type `Bind<Argument>' that can't
14617 be fully created right now, because
14618 `Internal<Template>' not being complete, the Bind
14619 template cannot be looked up in that context. So
14620 we need to "store" `Bind<Argument>' for later
14621 when the context of Bind becomes complete. Let's
14622 store that in a TYPENAME_TYPE. */
14623 return make_typename_type (TYPE_CONTEXT (arg
),
14624 build_nt (TEMPLATE_ID_EXPR
,
14625 TYPE_IDENTIFIER (arg
),
14630 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
14631 are resolving nested-types in the signature of a
14632 member function templates. Otherwise ARG is a
14633 TEMPLATE_DECL and is the real template to be
14635 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
14636 arg
= TYPE_NAME (arg
);
14638 r
= lookup_template_class (arg
,
14640 DECL_CONTEXT (arg
),
14641 /*entering_scope=*/0,
14643 return cp_build_qualified_type_real
14644 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
14646 else if (code
== TEMPLATE_TEMPLATE_PARM
)
14649 /* TEMPLATE_PARM_INDEX. */
14650 return convert_from_reference (unshare_expr (arg
));
14654 /* This can happen during the attempted tsubst'ing in
14655 unify. This means that we don't yet have any information
14656 about the template parameter in question. */
14659 /* If we get here, we must have been looking at a parm for a
14660 more deeply nested template. Make a new version of this
14661 template parameter, but with a lower level. */
14664 case TEMPLATE_TYPE_PARM
:
14665 case TEMPLATE_TEMPLATE_PARM
:
14666 case BOUND_TEMPLATE_TEMPLATE_PARM
:
14667 if (cp_type_quals (t
))
14669 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
14670 r
= cp_build_qualified_type_real
14671 (r
, cp_type_quals (t
),
14672 complain
| (code
== TEMPLATE_TYPE_PARM
14673 ? tf_ignore_bad_quals
: 0));
14675 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
14676 && PLACEHOLDER_TYPE_CONSTRAINTS (t
)
14677 && (r
= (TEMPLATE_PARM_DESCENDANTS
14678 (TEMPLATE_TYPE_PARM_INDEX (t
))))
14679 && (r
= TREE_TYPE (r
))
14680 && !PLACEHOLDER_TYPE_CONSTRAINTS (r
))
14681 /* Break infinite recursion when substituting the constraints
14682 of a constrained placeholder. */;
14683 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
14684 && !PLACEHOLDER_TYPE_CONSTRAINTS (t
)
14685 && !CLASS_PLACEHOLDER_TEMPLATE (t
)
14686 && (arg
= TEMPLATE_TYPE_PARM_INDEX (t
),
14687 r
= TEMPLATE_PARM_DESCENDANTS (arg
))
14688 && (TEMPLATE_PARM_LEVEL (r
)
14689 == TEMPLATE_PARM_LEVEL (arg
) - levels
))
14690 /* Cache the simple case of lowering a type parameter. */
14695 TEMPLATE_TYPE_PARM_INDEX (r
)
14696 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
14697 r
, levels
, args
, complain
);
14698 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
14699 TYPE_MAIN_VARIANT (r
) = r
;
14700 TYPE_POINTER_TO (r
) = NULL_TREE
;
14701 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
14703 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
14705 /* Propagate constraints on placeholders. */
14706 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
14707 PLACEHOLDER_TYPE_CONSTRAINTS (r
)
14708 = tsubst_constraint (constr
, args
, complain
, in_decl
);
14709 else if (tree pl
= CLASS_PLACEHOLDER_TEMPLATE (t
))
14711 pl
= tsubst_copy (pl
, args
, complain
, in_decl
);
14712 CLASS_PLACEHOLDER_TEMPLATE (r
) = pl
;
14716 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
14717 /* We have reduced the level of the template
14718 template parameter, but not the levels of its
14719 template parameters, so canonical_type_parameter
14720 will not be able to find the canonical template
14721 template parameter for this level. Thus, we
14722 require structural equality checking to compare
14723 TEMPLATE_TEMPLATE_PARMs. */
14724 SET_TYPE_STRUCTURAL_EQUALITY (r
);
14725 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
14726 SET_TYPE_STRUCTURAL_EQUALITY (r
);
14728 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
14730 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
14732 tree tinfo
= TYPE_TEMPLATE_INFO (t
);
14733 /* We might need to substitute into the types of non-type
14734 template parameters. */
14735 tree tmpl
= tsubst (TI_TEMPLATE (tinfo
), args
,
14736 complain
, in_decl
);
14737 if (tmpl
== error_mark_node
)
14738 return error_mark_node
;
14739 tree argvec
= tsubst (TI_ARGS (tinfo
), args
,
14740 complain
, in_decl
);
14741 if (argvec
== error_mark_node
)
14742 return error_mark_node
;
14744 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
14745 = build_template_info (tmpl
, argvec
);
14750 case TEMPLATE_PARM_INDEX
:
14751 /* OK, now substitute the type of the non-type parameter. We
14752 couldn't do it earlier because it might be an auto parameter,
14753 and we wouldn't need to if we had an argument. */
14754 type
= tsubst (type
, args
, complain
, in_decl
);
14755 if (type
== error_mark_node
)
14756 return error_mark_node
;
14757 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
14761 gcc_unreachable ();
14769 tree purpose
, value
, chain
;
14771 if (t
== void_list_node
)
14774 purpose
= TREE_PURPOSE (t
);
14777 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
14778 if (purpose
== error_mark_node
)
14779 return error_mark_node
;
14781 value
= TREE_VALUE (t
);
14784 value
= tsubst (value
, args
, complain
, in_decl
);
14785 if (value
== error_mark_node
)
14786 return error_mark_node
;
14788 chain
= TREE_CHAIN (t
);
14789 if (chain
&& chain
!= void_type_node
)
14791 chain
= tsubst (chain
, args
, complain
, in_decl
);
14792 if (chain
== error_mark_node
)
14793 return error_mark_node
;
14795 if (purpose
== TREE_PURPOSE (t
)
14796 && value
== TREE_VALUE (t
)
14797 && chain
== TREE_CHAIN (t
))
14799 return hash_tree_cons (purpose
, value
, chain
);
14803 /* We should never be tsubsting a binfo. */
14804 gcc_unreachable ();
14807 /* A vector of template arguments. */
14808 gcc_assert (!type
);
14809 return tsubst_template_args (t
, args
, complain
, in_decl
);
14812 case REFERENCE_TYPE
:
14814 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
14819 Type deduction may fail for any of the following
14822 -- Attempting to create a pointer to reference type.
14823 -- Attempting to create a reference to a reference type or
14824 a reference to void.
14826 Core issue 106 says that creating a reference to a reference
14827 during instantiation is no longer a cause for failure. We
14828 only enforce this check in strict C++98 mode. */
14829 if ((TYPE_REF_P (type
)
14830 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
14831 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
14833 static location_t last_loc
;
14835 /* We keep track of the last time we issued this error
14836 message to avoid spewing a ton of messages during a
14837 single bad template instantiation. */
14838 if (complain
& tf_error
14839 && last_loc
!= input_location
)
14841 if (VOID_TYPE_P (type
))
14842 error ("forming reference to void");
14843 else if (code
== POINTER_TYPE
)
14844 error ("forming pointer to reference type %qT", type
);
14846 error ("forming reference to reference type %qT", type
);
14847 last_loc
= input_location
;
14850 return error_mark_node
;
14852 else if (TREE_CODE (type
) == FUNCTION_TYPE
14853 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
14854 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
14856 if (complain
& tf_error
)
14858 if (code
== POINTER_TYPE
)
14859 error ("forming pointer to qualified function type %qT",
14862 error ("forming reference to qualified function type %qT",
14865 return error_mark_node
;
14867 else if (code
== POINTER_TYPE
)
14869 r
= build_pointer_type (type
);
14870 if (TREE_CODE (type
) == METHOD_TYPE
)
14871 r
= build_ptrmemfunc_type (r
);
14873 else if (TYPE_REF_P (type
))
14874 /* In C++0x, during template argument substitution, when there is an
14875 attempt to create a reference to a reference type, reference
14876 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
14878 "If a template-argument for a template-parameter T names a type
14879 that is a reference to a type A, an attempt to create the type
14880 'lvalue reference to cv T' creates the type 'lvalue reference to
14881 A,' while an attempt to create the type type rvalue reference to
14882 cv T' creates the type T"
14884 r
= cp_build_reference_type
14886 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
14888 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
14889 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
14891 if (r
!= error_mark_node
)
14892 /* Will this ever be needed for TYPE_..._TO values? */
14899 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
14900 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
14904 Type deduction may fail for any of the following
14907 -- Attempting to create "pointer to member of T" when T
14908 is not a class type. */
14909 if (complain
& tf_error
)
14910 error ("creating pointer to member of non-class type %qT", r
);
14911 return error_mark_node
;
14913 if (TYPE_REF_P (type
))
14915 if (complain
& tf_error
)
14916 error ("creating pointer to member reference type %qT", type
);
14917 return error_mark_node
;
14919 if (VOID_TYPE_P (type
))
14921 if (complain
& tf_error
)
14922 error ("creating pointer to member of type void");
14923 return error_mark_node
;
14925 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
14926 if (TREE_CODE (type
) == FUNCTION_TYPE
)
14928 /* The type of the implicit object parameter gets its
14929 cv-qualifiers from the FUNCTION_TYPE. */
14932 = build_memfn_type (type
, r
, type_memfn_quals (type
),
14933 type_memfn_rqual (type
));
14934 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
14935 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
14939 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
14943 case FUNCTION_TYPE
:
14948 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
14949 if (fntype
== error_mark_node
)
14950 return error_mark_node
;
14952 /* Substitute the exception specification. */
14953 specs
= tsubst_exception_specification (t
, args
, complain
, in_decl
,
14954 /*defer_ok*/fndecl_type
);
14955 if (specs
== error_mark_node
)
14956 return error_mark_node
;
14958 fntype
= build_exception_variant (fntype
, specs
);
14963 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
14964 if (domain
== error_mark_node
)
14965 return error_mark_node
;
14967 /* As an optimization, we avoid regenerating the array type if
14968 it will obviously be the same as T. */
14969 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
14972 /* These checks should match the ones in create_array_type_for_decl.
14976 The deduction may fail for any of the following reasons:
14978 -- Attempting to create an array with an element type that
14979 is void, a function type, or a reference type, or [DR337]
14980 an abstract class type. */
14981 if (VOID_TYPE_P (type
)
14982 || TREE_CODE (type
) == FUNCTION_TYPE
14983 || (TREE_CODE (type
) == ARRAY_TYPE
14984 && TYPE_DOMAIN (type
) == NULL_TREE
)
14985 || TYPE_REF_P (type
))
14987 if (complain
& tf_error
)
14988 error ("creating array of %qT", type
);
14989 return error_mark_node
;
14992 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
14993 return error_mark_node
;
14995 r
= build_cplus_array_type (type
, domain
);
14997 if (!valid_array_size_p (input_location
, r
, in_decl
,
14998 (complain
& tf_error
)))
14999 return error_mark_node
;
15001 if (TYPE_USER_ALIGN (t
))
15003 SET_TYPE_ALIGN (r
, TYPE_ALIGN (t
));
15004 TYPE_USER_ALIGN (r
) = 1;
15010 case TYPENAME_TYPE
:
15012 tree ctx
= TYPE_CONTEXT (t
);
15013 if (TREE_CODE (ctx
) == TYPE_PACK_EXPANSION
)
15015 ctx
= tsubst_pack_expansion (ctx
, args
, complain
, in_decl
);
15016 if (ctx
== error_mark_node
15017 || TREE_VEC_LENGTH (ctx
) > 1)
15018 return error_mark_node
;
15019 if (TREE_VEC_LENGTH (ctx
) == 0)
15021 if (complain
& tf_error
)
15022 error ("%qD is instantiated for an empty pack",
15023 TYPENAME_TYPE_FULLNAME (t
));
15024 return error_mark_node
;
15026 ctx
= TREE_VEC_ELT (ctx
, 0);
15029 ctx
= tsubst_aggr_type (ctx
, args
, complain
, in_decl
,
15030 /*entering_scope=*/1);
15031 if (ctx
== error_mark_node
)
15032 return error_mark_node
;
15034 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
15035 complain
, in_decl
);
15036 if (f
== error_mark_node
)
15037 return error_mark_node
;
15039 if (!MAYBE_CLASS_TYPE_P (ctx
))
15041 if (complain
& tf_error
)
15042 error ("%qT is not a class, struct, or union type", ctx
);
15043 return error_mark_node
;
15045 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
15047 /* Normally, make_typename_type does not require that the CTX
15048 have complete type in order to allow things like:
15050 template <class T> struct S { typename S<T>::X Y; };
15052 But, such constructs have already been resolved by this
15053 point, so here CTX really should have complete type, unless
15054 it's a partial instantiation. */
15055 ctx
= complete_type (ctx
);
15056 if (!COMPLETE_TYPE_P (ctx
))
15058 if (complain
& tf_error
)
15059 cxx_incomplete_type_error (NULL_TREE
, ctx
);
15060 return error_mark_node
;
15064 f
= make_typename_type (ctx
, f
, typename_type
,
15065 complain
| tf_keep_type_decl
);
15066 if (f
== error_mark_node
)
15068 if (TREE_CODE (f
) == TYPE_DECL
)
15070 complain
|= tf_ignore_bad_quals
;
15074 if (TREE_CODE (f
) != TYPENAME_TYPE
)
15076 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
15078 if (complain
& tf_error
)
15079 error ("%qT resolves to %qT, which is not an enumeration type",
15082 return error_mark_node
;
15084 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
15086 if (complain
& tf_error
)
15087 error ("%qT resolves to %qT, which is is not a class type",
15090 return error_mark_node
;
15094 return cp_build_qualified_type_real
15095 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
15098 case UNBOUND_CLASS_TEMPLATE
:
15100 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
15101 in_decl
, /*entering_scope=*/1);
15102 tree name
= TYPE_IDENTIFIER (t
);
15103 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
15105 if (ctx
== error_mark_node
|| name
== error_mark_node
)
15106 return error_mark_node
;
15109 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
15110 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
15117 ++cp_unevaluated_operand
;
15118 ++c_inhibit_evaluation_warnings
;
15120 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
15122 /*integral_constant_expression_p=*/false);
15124 --cp_unevaluated_operand
;
15125 --c_inhibit_evaluation_warnings
;
15127 type
= finish_typeof (type
);
15128 return cp_build_qualified_type_real (type
,
15130 | cp_type_quals (type
),
15134 case DECLTYPE_TYPE
:
15138 ++cp_unevaluated_operand
;
15139 ++c_inhibit_evaluation_warnings
;
15141 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
15142 complain
|tf_decltype
, in_decl
,
15143 /*function_p*/false,
15144 /*integral_constant_expression*/false);
15146 if (DECLTYPE_FOR_INIT_CAPTURE (t
))
15148 if (type
== NULL_TREE
)
15150 if (complain
& tf_error
)
15151 error ("empty initializer in lambda init-capture");
15152 type
= error_mark_node
;
15154 else if (TREE_CODE (type
) == TREE_LIST
)
15155 type
= build_x_compound_expr_from_list (type
, ELK_INIT
, complain
);
15158 --cp_unevaluated_operand
;
15159 --c_inhibit_evaluation_warnings
;
15161 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
15162 type
= lambda_capture_field_type (type
,
15163 DECLTYPE_FOR_INIT_CAPTURE (t
),
15164 DECLTYPE_FOR_REF_CAPTURE (t
));
15165 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
15166 type
= lambda_proxy_type (type
);
15169 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
15170 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
15172 /* In a template ~id could be either a complement expression
15173 or an unqualified-id naming a destructor; if instantiating
15174 it produces an expression, it's not an id-expression or
15177 type
= finish_decltype_type (type
, id
, complain
);
15179 return cp_build_qualified_type_real (type
,
15181 | cp_type_quals (type
),
15182 complain
| tf_ignore_bad_quals
);
15185 case UNDERLYING_TYPE
:
15187 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
15188 complain
, in_decl
);
15189 return finish_underlying_type (type
);
15192 case TYPE_ARGUMENT_PACK
:
15193 case NONTYPE_ARGUMENT_PACK
:
15197 if (code
== NONTYPE_ARGUMENT_PACK
)
15198 r
= make_node (code
);
15200 r
= cxx_make_type (code
);
15202 tree pack_args
= ARGUMENT_PACK_ARGS (t
);
15203 pack_args
= tsubst_template_args (pack_args
, args
, complain
, in_decl
);
15204 SET_ARGUMENT_PACK_ARGS (r
, pack_args
);
15222 /* We should use one of the expression tsubsts for these codes. */
15223 gcc_unreachable ();
15226 sorry ("use of %qs in template", get_tree_code_name (code
));
15227 return error_mark_node
;
15231 /* tsubst a BASELINK. OBJECT_TYPE, if non-NULL, is the type of the
15232 expression on the left-hand side of the "." or "->" operator. We
15233 only do the lookup if we had a dependent BASELINK. Otherwise we
15234 adjust it onto the instantiated heirarchy. */
15237 tsubst_baselink (tree baselink
, tree object_type
,
15238 tree args
, tsubst_flags_t complain
, tree in_decl
)
15240 bool qualified_p
= BASELINK_QUALIFIED_P (baselink
);
15241 tree qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
15242 qualifying_scope
= tsubst (qualifying_scope
, args
, complain
, in_decl
);
15244 tree optype
= BASELINK_OPTYPE (baselink
);
15245 optype
= tsubst (optype
, args
, complain
, in_decl
);
15247 tree template_args
= NULL_TREE
;
15248 bool template_id_p
= false;
15249 tree fns
= BASELINK_FUNCTIONS (baselink
);
15250 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
15252 template_id_p
= true;
15253 template_args
= TREE_OPERAND (fns
, 1);
15254 fns
= TREE_OPERAND (fns
, 0);
15256 template_args
= tsubst_template_args (template_args
, args
,
15257 complain
, in_decl
);
15260 tree binfo_type
= BINFO_TYPE (BASELINK_BINFO (baselink
));
15261 binfo_type
= tsubst (binfo_type
, args
, complain
, in_decl
);
15262 bool dependent_p
= binfo_type
!= BINFO_TYPE (BASELINK_BINFO (baselink
));
15266 tree name
= OVL_NAME (fns
);
15267 if (IDENTIFIER_CONV_OP_P (name
))
15268 name
= make_conv_op_name (optype
);
15270 if (name
== complete_dtor_identifier
)
15271 /* Treat as-if non-dependent below. */
15272 dependent_p
= false;
15274 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
15277 if ((complain
& tf_error
)
15278 && constructor_name_p (name
, qualifying_scope
))
15279 error ("cannot call constructor %<%T::%D%> directly",
15280 qualifying_scope
, name
);
15281 return error_mark_node
;
15284 if (BASELINK_P (baselink
))
15285 fns
= BASELINK_FUNCTIONS (baselink
);
15288 /* We're going to overwrite pieces below, make a duplicate. */
15289 baselink
= copy_node (baselink
);
15291 /* If lookup found a single function, mark it as used at this point.
15292 (If lookup found multiple functions the one selected later by
15293 overload resolution will be marked as used at that point.) */
15294 if (!template_id_p
&& !really_overloaded_fn (fns
))
15296 tree fn
= OVL_FIRST (fns
);
15297 bool ok
= mark_used (fn
, complain
);
15298 if (!ok
&& !(complain
& tf_error
))
15299 return error_mark_node
;
15300 if (ok
&& BASELINK_P (baselink
))
15301 /* We might have instantiated an auto function. */
15302 TREE_TYPE (baselink
) = TREE_TYPE (fn
);
15305 if (BASELINK_P (baselink
))
15307 /* Add back the template arguments, if present. */
15309 BASELINK_FUNCTIONS (baselink
)
15310 = build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fns
, template_args
);
15312 /* Update the conversion operator type. */
15313 BASELINK_OPTYPE (baselink
) = optype
;
15317 object_type
= current_class_type
;
15319 if (qualified_p
|| !dependent_p
)
15321 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
15325 /* We need to call adjust_result_of_qualified_name_lookup in case the
15326 destructor names a base class, but we unset BASELINK_QUALIFIED_P
15327 so that we still get virtual function binding. */
15328 BASELINK_QUALIFIED_P (baselink
) = false;
15334 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
15335 true if the qualified-id will be a postfix-expression in-and-of
15336 itself; false if more of the postfix-expression follows the
15337 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
15341 tsubst_qualified_id (tree qualified_id
, tree args
,
15342 tsubst_flags_t complain
, tree in_decl
,
15343 bool done
, bool address_p
)
15349 tree template_args
;
15350 location_t loc
= UNKNOWN_LOCATION
;
15352 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
15354 /* Figure out what name to look up. */
15355 name
= TREE_OPERAND (qualified_id
, 1);
15356 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
15358 is_template
= true;
15359 loc
= EXPR_LOCATION (name
);
15360 template_args
= TREE_OPERAND (name
, 1);
15362 template_args
= tsubst_template_args (template_args
, args
,
15363 complain
, in_decl
);
15364 if (template_args
== error_mark_node
)
15365 return error_mark_node
;
15366 name
= TREE_OPERAND (name
, 0);
15370 is_template
= false;
15371 template_args
= NULL_TREE
;
15374 /* Substitute into the qualifying scope. When there are no ARGS, we
15375 are just trying to simplify a non-dependent expression. In that
15376 case the qualifying scope may be dependent, and, in any case,
15377 substituting will not help. */
15378 scope
= TREE_OPERAND (qualified_id
, 0);
15381 scope
= tsubst (scope
, args
, complain
, in_decl
);
15382 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
15387 if (dependent_scope_p (scope
))
15390 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
15391 tree r
= build_qualified_name (NULL_TREE
, scope
, expr
,
15392 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
15393 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (qualified_id
);
15397 if (!BASELINK_P (name
) && !DECL_P (expr
))
15399 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
15401 /* A BIT_NOT_EXPR is used to represent a destructor. */
15402 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
15404 error ("qualifying type %qT does not match destructor name ~%qT",
15405 scope
, TREE_OPERAND (expr
, 0));
15406 expr
= error_mark_node
;
15409 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
15410 /*is_type_p=*/0, false);
15413 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
15414 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
15415 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
15417 if (complain
& tf_error
)
15419 error ("dependent-name %qE is parsed as a non-type, but "
15420 "instantiation yields a type", qualified_id
);
15421 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
15423 return error_mark_node
;
15429 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
15431 /* Remember that there was a reference to this entity. */
15432 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
15433 return error_mark_node
;
15436 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
15438 if (complain
& tf_error
)
15439 qualified_name_lookup_error (scope
,
15440 TREE_OPERAND (qualified_id
, 1),
15441 expr
, input_location
);
15442 return error_mark_node
;
15447 /* We may be repeating a check already done during parsing, but
15448 if it was well-formed and passed then, it will pass again
15449 now, and if it didn't, we wouldn't have got here. The case
15450 we want to catch is when we couldn't tell then, and can now,
15451 namely when templ prior to substitution was an
15453 if (flag_concepts
&& check_auto_in_tmpl_args (expr
, template_args
))
15454 return error_mark_node
;
15456 if (variable_template_p (expr
))
15457 expr
= lookup_and_finish_template_variable (expr
, template_args
,
15460 expr
= lookup_template_function (expr
, template_args
);
15463 if (expr
== error_mark_node
&& complain
& tf_error
)
15464 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
15465 expr
, input_location
);
15466 else if (TYPE_P (scope
))
15468 expr
= (adjust_result_of_qualified_name_lookup
15469 (expr
, scope
, current_nonlambda_class_type ()));
15470 expr
= (finish_qualified_id_expr
15471 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
15472 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
15473 /*template_arg_p=*/false, complain
));
15476 /* Expressions do not generally have reference type. */
15477 if (TREE_CODE (expr
) != SCOPE_REF
15478 /* However, if we're about to form a pointer-to-member, we just
15479 want the referenced member referenced. */
15480 && TREE_CODE (expr
) != OFFSET_REF
)
15481 expr
= convert_from_reference (expr
);
15483 if (REF_PARENTHESIZED_P (qualified_id
))
15484 expr
= force_paren_expr (expr
);
15489 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
15490 initializer, DECL is the substituted VAR_DECL. Other arguments are as
15494 tsubst_init (tree init
, tree decl
, tree args
,
15495 tsubst_flags_t complain
, tree in_decl
)
15500 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
15502 tree type
= TREE_TYPE (decl
);
15504 if (!init
&& type
!= error_mark_node
)
15506 if (tree auto_node
= type_uses_auto (type
))
15508 if (!CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
15510 if (complain
& tf_error
)
15511 error ("initializer for %q#D expands to an empty list "
15512 "of expressions", decl
);
15513 return error_mark_node
;
15516 else if (!dependent_type_p (type
))
15518 /* If we had an initializer but it
15519 instantiated to nothing,
15520 value-initialize the object. This will
15521 only occur when the initializer was a
15522 pack expansion where the parameter packs
15523 used in that expansion were of length
15525 init
= build_value_init (type
, complain
);
15526 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
15527 init
= get_target_expr_sfinae (init
, complain
);
15528 if (TREE_CODE (init
) == TARGET_EXPR
)
15529 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
15536 /* Like tsubst, but deals with expressions. This function just replaces
15537 template parms; to finish processing the resultant expression, use
15538 tsubst_copy_and_build or tsubst_expr. */
15541 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
15543 enum tree_code code
;
15546 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
15549 code
= TREE_CODE (t
);
15554 r
= retrieve_local_specialization (t
);
15556 if (r
== NULL_TREE
)
15558 /* We get here for a use of 'this' in an NSDMI. */
15559 if (DECL_NAME (t
) == this_identifier
&& current_class_ptr
)
15560 return current_class_ptr
;
15562 /* This can happen for a parameter name used later in a function
15563 declaration (such as in a late-specified return type). Just
15564 make a dummy decl, since it's only used for its type. */
15565 gcc_assert (cp_unevaluated_operand
!= 0);
15566 r
= tsubst_decl (t
, args
, complain
);
15567 /* Give it the template pattern as its context; its true context
15568 hasn't been instantiated yet and this is good enough for
15570 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
15573 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
15574 r
= argument_pack_select_arg (r
);
15575 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
15576 return error_mark_node
;
15584 if (DECL_TEMPLATE_PARM_P (t
))
15585 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
15586 /* There is no need to substitute into namespace-scope
15588 if (DECL_NAMESPACE_SCOPE_P (t
))
15590 /* If ARGS is NULL, then T is known to be non-dependent. */
15591 if (args
== NULL_TREE
)
15592 return scalar_constant_value (t
);
15594 /* Unfortunately, we cannot just call lookup_name here.
15597 template <int I> int f() {
15599 struct S { void g() { E e = a; } };
15602 When we instantiate f<7>::S::g(), say, lookup_name is not
15603 clever enough to find f<7>::a. */
15605 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
15606 /*entering_scope=*/0);
15608 for (v
= TYPE_VALUES (enum_type
);
15610 v
= TREE_CHAIN (v
))
15611 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
15612 return TREE_VALUE (v
);
15614 /* We didn't find the name. That should never happen; if
15615 name-lookup found it during preliminary parsing, we
15616 should find it again here during instantiation. */
15617 gcc_unreachable ();
15622 if (DECL_CONTEXT (t
))
15626 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
15627 /*entering_scope=*/1);
15628 if (ctx
!= DECL_CONTEXT (t
))
15630 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
15633 if (complain
& tf_error
)
15634 error ("using invalid field %qD", t
);
15635 return error_mark_node
;
15644 case FUNCTION_DECL
:
15645 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
15646 r
= tsubst (t
, args
, complain
, in_decl
);
15647 else if (local_variable_p (t
)
15648 && uses_template_parms (DECL_CONTEXT (t
)))
15650 r
= retrieve_local_specialization (t
);
15651 if (r
== NULL_TREE
)
15653 /* First try name lookup to find the instantiation. */
15654 r
= lookup_name (DECL_NAME (t
));
15659 /* During error-recovery we may find a non-variable,
15660 even an OVERLOAD: just bail out and avoid ICEs and
15661 duplicate diagnostics (c++/62207). */
15662 gcc_assert (seen_error ());
15663 return error_mark_node
;
15665 if (!is_capture_proxy (r
))
15667 /* Make sure the one we found is the one we want. */
15668 tree ctx
= enclosing_instantiation_of (DECL_CONTEXT (t
));
15669 if (ctx
!= DECL_CONTEXT (r
))
15678 /* This can happen for a variable used in a
15679 late-specified return type of a local lambda, or for a
15680 local static or constant. Building a new VAR_DECL
15681 should be OK in all those cases. */
15682 r
= tsubst_decl (t
, args
, complain
);
15683 if (local_specializations
)
15684 /* Avoid infinite recursion (79640). */
15685 register_local_specialization (r
, t
);
15686 if (decl_maybe_constant_var_p (r
))
15688 /* We can't call cp_finish_decl, so handle the
15689 initializer by hand. */
15690 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
15691 complain
, in_decl
);
15692 if (!processing_template_decl
)
15693 init
= maybe_constant_init (init
);
15694 if (processing_template_decl
15695 ? potential_constant_expression (init
)
15696 : reduced_constant_expression_p (init
))
15697 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
15698 = TREE_CONSTANT (r
) = true;
15699 DECL_INITIAL (r
) = init
;
15700 if (tree auto_node
= type_uses_auto (TREE_TYPE (r
)))
15702 = do_auto_deduction (TREE_TYPE (r
), init
, auto_node
,
15703 complain
, adc_variable_type
);
15705 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
15706 || decl_constant_var_p (r
)
15708 if (!processing_template_decl
15709 && !TREE_STATIC (r
))
15710 r
= process_outer_var_ref (r
, complain
);
15712 /* Remember this for subsequent uses. */
15713 if (local_specializations
)
15714 register_local_specialization (r
, t
);
15716 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
15717 r
= argument_pack_select_arg (r
);
15721 if (!mark_used (r
, complain
))
15722 return error_mark_node
;
15725 case NAMESPACE_DECL
:
15732 return tsubst_baselink (t
, current_nonlambda_class_type (),
15733 args
, complain
, in_decl
);
15735 case TEMPLATE_DECL
:
15736 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
15737 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
15738 args
, complain
, in_decl
);
15739 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
15740 return tsubst (t
, args
, complain
, in_decl
);
15741 else if (DECL_CLASS_SCOPE_P (t
)
15742 && uses_template_parms (DECL_CONTEXT (t
)))
15744 /* Template template argument like the following example need
15747 template <template <class> class TT> struct C {};
15748 template <class T> struct D {
15749 template <class U> struct E {};
15754 We are processing the template argument `E' in #1 for
15755 the template instantiation #2. Originally, `E' is a
15756 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
15757 have to substitute this with one having context `D<int>'. */
15759 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
15760 if (dependent_scope_p (context
))
15762 /* When rewriting a constructor into a deduction guide, a
15763 non-dependent name can become dependent, so memtmpl<args>
15764 becomes context::template memtmpl<args>. */
15765 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15766 return build_qualified_name (type
, context
, DECL_NAME (t
),
15769 return lookup_field (context
, DECL_NAME(t
), 0, false);
15772 /* Ordinary template template argument. */
15775 case NON_LVALUE_EXPR
:
15776 case VIEW_CONVERT_EXPR
:
15778 /* Handle location wrappers by substituting the wrapped node
15779 first, *then* reusing the resulting type. Doing the type
15780 first ensures that we handle template parameters and
15781 parameter pack expansions. */
15782 if (location_wrapper_p (t
))
15784 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
,
15785 complain
, in_decl
);
15786 return maybe_wrap_with_location (op0
, EXPR_LOCATION (t
));
15788 tree op
= TREE_OPERAND (t
, 0);
15789 if (code
== VIEW_CONVERT_EXPR
15790 && TREE_CODE (op
) == TEMPLATE_PARM_INDEX
)
15792 /* Wrapper to make a C++20 template parameter object const. */
15793 op
= tsubst_copy (op
, args
, complain
, in_decl
);
15794 if (TREE_CODE (op
) == TEMPLATE_PARM_INDEX
)
15796 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15797 return build1 (code
, type
, op
);
15801 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (op
)));
15805 /* We shouldn't see any other uses of these in templates. */
15806 gcc_unreachable ();
15810 case REINTERPRET_CAST_EXPR
:
15811 case CONST_CAST_EXPR
:
15812 case STATIC_CAST_EXPR
:
15813 case DYNAMIC_CAST_EXPR
:
15814 case IMPLICIT_CONV_EXPR
:
15818 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15819 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15820 return build1 (code
, type
, op0
);
15824 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
15825 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
15827 tree expanded
, op
= TREE_OPERAND (t
, 0);
15830 if (SIZEOF_EXPR_TYPE_P (t
))
15831 op
= TREE_TYPE (op
);
15833 ++cp_unevaluated_operand
;
15834 ++c_inhibit_evaluation_warnings
;
15835 /* We only want to compute the number of arguments. */
15836 if (PACK_EXPANSION_P (op
))
15837 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
15839 expanded
= tsubst_template_args (ARGUMENT_PACK_ARGS (op
),
15840 args
, complain
, in_decl
);
15841 --cp_unevaluated_operand
;
15842 --c_inhibit_evaluation_warnings
;
15844 if (TREE_CODE (expanded
) == TREE_VEC
)
15846 len
= TREE_VEC_LENGTH (expanded
);
15847 /* Set TREE_USED for the benefit of -Wunused. */
15848 for (int i
= 0; i
< len
; i
++)
15849 if (DECL_P (TREE_VEC_ELT (expanded
, i
)))
15850 TREE_USED (TREE_VEC_ELT (expanded
, i
)) = true;
15853 if (expanded
== error_mark_node
)
15854 return error_mark_node
;
15855 else if (PACK_EXPANSION_P (expanded
)
15856 || (TREE_CODE (expanded
) == TREE_VEC
15857 && pack_expansion_args_count (expanded
)))
15860 if (PACK_EXPANSION_P (expanded
))
15862 else if (TREE_VEC_LENGTH (expanded
) == 1)
15863 expanded
= TREE_VEC_ELT (expanded
, 0);
15865 expanded
= make_argument_pack (expanded
);
15867 if (TYPE_P (expanded
))
15868 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
15870 complain
& tf_error
);
15872 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
15873 complain
& tf_error
);
15876 return build_int_cst (size_type_node
, len
);
15878 if (SIZEOF_EXPR_TYPE_P (t
))
15880 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
15881 args
, complain
, in_decl
);
15882 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
15883 r
= build1 (SIZEOF_EXPR
,
15884 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
15885 SIZEOF_EXPR_TYPE_P (r
) = 1;
15892 case TRUTH_NOT_EXPR
:
15895 case UNARY_PLUS_EXPR
: /* Unary + */
15897 case AT_ENCODE_EXPR
:
15901 case REALPART_EXPR
:
15902 case IMAGPART_EXPR
:
15905 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15906 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15907 r
= build1 (code
, type
, op0
);
15908 if (code
== ALIGNOF_EXPR
)
15909 ALIGNOF_EXPR_STD_P (r
) = ALIGNOF_EXPR_STD_P (t
);
15913 case COMPONENT_REF
:
15918 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15919 name
= TREE_OPERAND (t
, 1);
15920 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
15922 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15923 complain
, in_decl
);
15924 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
15926 else if (TREE_CODE (name
) == SCOPE_REF
15927 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
15929 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15930 complain
, in_decl
);
15931 name
= TREE_OPERAND (name
, 1);
15932 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15933 complain
, in_decl
);
15934 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
15935 name
= build_qualified_name (/*type=*/NULL_TREE
,
15937 /*template_p=*/false);
15939 else if (BASELINK_P (name
))
15940 name
= tsubst_baselink (name
,
15941 non_reference (TREE_TYPE (object
)),
15945 name
= tsubst_copy (name
, args
, complain
, in_decl
);
15946 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
15952 case TRUNC_DIV_EXPR
:
15953 case CEIL_DIV_EXPR
:
15954 case FLOOR_DIV_EXPR
:
15955 case ROUND_DIV_EXPR
:
15956 case EXACT_DIV_EXPR
:
15960 case TRUNC_MOD_EXPR
:
15961 case FLOOR_MOD_EXPR
:
15962 case TRUTH_ANDIF_EXPR
:
15963 case TRUTH_ORIF_EXPR
:
15964 case TRUTH_AND_EXPR
:
15965 case TRUTH_OR_EXPR
:
15978 case COMPOUND_EXPR
:
15981 case PREDECREMENT_EXPR
:
15982 case PREINCREMENT_EXPR
:
15983 case POSTDECREMENT_EXPR
:
15984 case POSTINCREMENT_EXPR
:
15986 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15987 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15988 return build_nt (code
, op0
, op1
);
15993 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15994 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15995 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
15996 QUALIFIED_NAME_IS_TEMPLATE (t
));
16001 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16002 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16003 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
16008 int n
= VL_EXP_OPERAND_LENGTH (t
);
16009 tree result
= build_vl_exp (CALL_EXPR
, n
);
16011 for (i
= 0; i
< n
; i
++)
16012 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
16013 complain
, in_decl
);
16019 case PSEUDO_DTOR_EXPR
:
16020 case VEC_PERM_EXPR
:
16022 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16023 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16024 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
16025 r
= build_nt (code
, op0
, op1
, op2
);
16026 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
16032 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16033 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16034 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
16035 r
= build_nt (code
, op0
, op1
, op2
);
16036 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
16042 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16043 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16044 r
= build_nt (code
, op0
, op1
);
16045 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
16046 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
16050 case TEMPLATE_ID_EXPR
:
16052 /* Substituted template arguments */
16053 tree fn
= TREE_OPERAND (t
, 0);
16054 tree targs
= TREE_OPERAND (t
, 1);
16056 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
16058 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
16060 return lookup_template_function (fn
, targs
);
16065 tree purpose
, value
, chain
;
16067 if (t
== void_list_node
)
16070 purpose
= TREE_PURPOSE (t
);
16072 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
16073 value
= TREE_VALUE (t
);
16075 value
= tsubst_copy (value
, args
, complain
, in_decl
);
16076 chain
= TREE_CHAIN (t
);
16077 if (chain
&& chain
!= void_type_node
)
16078 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
16079 if (purpose
== TREE_PURPOSE (t
)
16080 && value
== TREE_VALUE (t
)
16081 && chain
== TREE_CHAIN (t
))
16083 return tree_cons (purpose
, value
, chain
);
16088 case ENUMERAL_TYPE
:
16090 case TEMPLATE_TYPE_PARM
:
16091 case TEMPLATE_TEMPLATE_PARM
:
16092 case BOUND_TEMPLATE_TEMPLATE_PARM
:
16093 case TEMPLATE_PARM_INDEX
:
16095 case REFERENCE_TYPE
:
16097 case FUNCTION_TYPE
:
16100 case TYPENAME_TYPE
:
16101 case UNBOUND_CLASS_TEMPLATE
:
16103 case DECLTYPE_TYPE
:
16105 return tsubst (t
, args
, complain
, in_decl
);
16109 /* Fall through. */
16110 case IDENTIFIER_NODE
:
16111 if (IDENTIFIER_CONV_OP_P (t
))
16113 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16114 return make_conv_op_name (new_type
);
16120 /* This is handled by tsubst_copy_and_build. */
16121 gcc_unreachable ();
16125 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16126 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16127 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
16130 case CLEANUP_POINT_EXPR
:
16131 /* We shouldn't have built any of these during initial template
16132 generation. Instead, they should be built during instantiation
16133 in response to the saved STMT_IS_FULL_EXPR_P setting. */
16134 gcc_unreachable ();
16138 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16139 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16140 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16141 r
= build2 (code
, type
, op0
, op1
);
16142 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
16143 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
16144 && !(complain
& tf_error
))
16145 return error_mark_node
;
16149 case EXPR_PACK_EXPANSION
:
16150 error ("invalid use of pack expansion expression");
16151 return error_mark_node
;
16153 case NONTYPE_ARGUMENT_PACK
:
16154 error ("use %<...%> to expand argument pack");
16155 return error_mark_node
;
16158 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
16166 /* Instantiate any typedefs in the type. */
16167 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16168 r
= fold_convert (type
, t
);
16169 gcc_assert (TREE_CODE (r
) == code
);
16174 /* These can sometimes show up in a partial instantiation, but never
16175 involve template parms. */
16176 gcc_assert (!uses_template_parms (t
));
16179 case UNARY_LEFT_FOLD_EXPR
:
16180 return tsubst_unary_left_fold (t
, args
, complain
, in_decl
);
16181 case UNARY_RIGHT_FOLD_EXPR
:
16182 return tsubst_unary_right_fold (t
, args
, complain
, in_decl
);
16183 case BINARY_LEFT_FOLD_EXPR
:
16184 return tsubst_binary_left_fold (t
, args
, complain
, in_decl
);
16185 case BINARY_RIGHT_FOLD_EXPR
:
16186 return tsubst_binary_right_fold (t
, args
, complain
, in_decl
);
16190 case DEBUG_BEGIN_STMT
:
16191 /* ??? There's no point in copying it for now, but maybe some
16192 day it will contain more information, such as a pointer back
16193 to the containing function, inlined copy or so. */
16197 /* We shouldn't get here, but keep going if !flag_checking. */
16199 gcc_unreachable ();
16204 /* Helper function for tsubst_omp_clauses, used for instantiation of
16205 OMP_CLAUSE_DECL of clauses. */
16208 tsubst_omp_clause_decl (tree decl
, tree args
, tsubst_flags_t complain
,
16209 tree in_decl
, tree
*iterator_cache
)
16211 if (decl
== NULL_TREE
)
16214 /* Handle OpenMP iterators. */
16215 if (TREE_CODE (decl
) == TREE_LIST
16216 && TREE_PURPOSE (decl
)
16217 && TREE_CODE (TREE_PURPOSE (decl
)) == TREE_VEC
)
16220 if (iterator_cache
[0] == TREE_PURPOSE (decl
))
16221 ret
= iterator_cache
[1];
16225 begin_scope (sk_omp
, NULL
);
16226 for (tree it
= TREE_PURPOSE (decl
); it
; it
= TREE_CHAIN (it
))
16228 *tp
= copy_node (it
);
16229 TREE_VEC_ELT (*tp
, 0)
16230 = tsubst_decl (TREE_VEC_ELT (it
, 0), args
, complain
);
16231 TREE_VEC_ELT (*tp
, 1)
16232 = tsubst_expr (TREE_VEC_ELT (it
, 1), args
, complain
, in_decl
,
16233 /*integral_constant_expression_p=*/false);
16234 TREE_VEC_ELT (*tp
, 2)
16235 = tsubst_expr (TREE_VEC_ELT (it
, 2), args
, complain
, in_decl
,
16236 /*integral_constant_expression_p=*/false);
16237 TREE_VEC_ELT (*tp
, 3)
16238 = tsubst_expr (TREE_VEC_ELT (it
, 3), args
, complain
, in_decl
,
16239 /*integral_constant_expression_p=*/false);
16240 TREE_CHAIN (*tp
) = NULL_TREE
;
16241 tp
= &TREE_CHAIN (*tp
);
16243 TREE_VEC_ELT (ret
, 5) = poplevel (1, 1, 0);
16244 iterator_cache
[0] = TREE_PURPOSE (decl
);
16245 iterator_cache
[1] = ret
;
16247 return build_tree_list (ret
, tsubst_omp_clause_decl (TREE_VALUE (decl
),
16252 /* Handle an OpenMP array section represented as a TREE_LIST (or
16253 OMP_CLAUSE_DEPEND_KIND). An OMP_CLAUSE_DEPEND (with a depend
16254 kind of OMP_CLAUSE_DEPEND_SINK) can also be represented as a
16255 TREE_LIST. We can handle it exactly the same as an array section
16256 (purpose, value, and a chain), even though the nomenclature
16257 (low_bound, length, etc) is different. */
16258 if (TREE_CODE (decl
) == TREE_LIST
)
16261 = tsubst_expr (TREE_PURPOSE (decl
), args
, complain
, in_decl
,
16262 /*integral_constant_expression_p=*/false);
16263 tree length
= tsubst_expr (TREE_VALUE (decl
), args
, complain
, in_decl
,
16264 /*integral_constant_expression_p=*/false);
16265 tree chain
= tsubst_omp_clause_decl (TREE_CHAIN (decl
), args
, complain
,
16267 if (TREE_PURPOSE (decl
) == low_bound
16268 && TREE_VALUE (decl
) == length
16269 && TREE_CHAIN (decl
) == chain
)
16271 tree ret
= tree_cons (low_bound
, length
, chain
);
16272 OMP_CLAUSE_DEPEND_SINK_NEGATIVE (ret
)
16273 = OMP_CLAUSE_DEPEND_SINK_NEGATIVE (decl
);
16276 tree ret
= tsubst_expr (decl
, args
, complain
, in_decl
,
16277 /*integral_constant_expression_p=*/false);
16278 /* Undo convert_from_reference tsubst_expr could have called. */
16280 && REFERENCE_REF_P (ret
)
16281 && !REFERENCE_REF_P (decl
))
16282 ret
= TREE_OPERAND (ret
, 0);
16286 /* Like tsubst_copy, but specifically for OpenMP clauses. */
16289 tsubst_omp_clauses (tree clauses
, enum c_omp_region_type ort
,
16290 tree args
, tsubst_flags_t complain
, tree in_decl
)
16292 tree new_clauses
= NULL_TREE
, nc
, oc
;
16293 tree linear_no_step
= NULL_TREE
;
16294 tree iterator_cache
[2] = { NULL_TREE
, NULL_TREE
};
16296 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
16298 nc
= copy_node (oc
);
16299 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
16302 switch (OMP_CLAUSE_CODE (nc
))
16304 case OMP_CLAUSE_LASTPRIVATE
:
16305 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
16307 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
16308 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
16309 in_decl
, /*integral_constant_expression_p=*/false);
16310 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
16311 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
16314 case OMP_CLAUSE_PRIVATE
:
16315 case OMP_CLAUSE_SHARED
:
16316 case OMP_CLAUSE_FIRSTPRIVATE
:
16317 case OMP_CLAUSE_COPYIN
:
16318 case OMP_CLAUSE_COPYPRIVATE
:
16319 case OMP_CLAUSE_UNIFORM
:
16320 case OMP_CLAUSE_DEPEND
:
16321 case OMP_CLAUSE_FROM
:
16322 case OMP_CLAUSE_TO
:
16323 case OMP_CLAUSE_MAP
:
16324 case OMP_CLAUSE_NONTEMPORAL
:
16325 case OMP_CLAUSE_USE_DEVICE_PTR
:
16326 case OMP_CLAUSE_IS_DEVICE_PTR
:
16327 case OMP_CLAUSE_INCLUSIVE
:
16328 case OMP_CLAUSE_EXCLUSIVE
:
16329 OMP_CLAUSE_DECL (nc
)
16330 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16331 in_decl
, iterator_cache
);
16333 case OMP_CLAUSE_TILE
:
16334 case OMP_CLAUSE_IF
:
16335 case OMP_CLAUSE_NUM_THREADS
:
16336 case OMP_CLAUSE_SCHEDULE
:
16337 case OMP_CLAUSE_COLLAPSE
:
16338 case OMP_CLAUSE_FINAL
:
16339 case OMP_CLAUSE_DEVICE
:
16340 case OMP_CLAUSE_DIST_SCHEDULE
:
16341 case OMP_CLAUSE_NUM_TEAMS
:
16342 case OMP_CLAUSE_THREAD_LIMIT
:
16343 case OMP_CLAUSE_SAFELEN
:
16344 case OMP_CLAUSE_SIMDLEN
:
16345 case OMP_CLAUSE_NUM_TASKS
:
16346 case OMP_CLAUSE_GRAINSIZE
:
16347 case OMP_CLAUSE_PRIORITY
:
16348 case OMP_CLAUSE_ORDERED
:
16349 case OMP_CLAUSE_HINT
:
16350 case OMP_CLAUSE_NUM_GANGS
:
16351 case OMP_CLAUSE_NUM_WORKERS
:
16352 case OMP_CLAUSE_VECTOR_LENGTH
:
16353 case OMP_CLAUSE_WORKER
:
16354 case OMP_CLAUSE_VECTOR
:
16355 case OMP_CLAUSE_ASYNC
:
16356 case OMP_CLAUSE_WAIT
:
16357 OMP_CLAUSE_OPERAND (nc
, 0)
16358 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
16359 in_decl
, /*integral_constant_expression_p=*/false);
16361 case OMP_CLAUSE_REDUCTION
:
16362 case OMP_CLAUSE_IN_REDUCTION
:
16363 case OMP_CLAUSE_TASK_REDUCTION
:
16364 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
16366 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
16367 if (TREE_CODE (placeholder
) == SCOPE_REF
)
16369 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
16370 complain
, in_decl
);
16371 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
16372 = build_qualified_name (NULL_TREE
, scope
,
16373 TREE_OPERAND (placeholder
, 1),
16377 gcc_assert (identifier_p (placeholder
));
16379 OMP_CLAUSE_DECL (nc
)
16380 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16383 case OMP_CLAUSE_GANG
:
16384 case OMP_CLAUSE_ALIGNED
:
16385 OMP_CLAUSE_DECL (nc
)
16386 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16388 OMP_CLAUSE_OPERAND (nc
, 1)
16389 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
16390 in_decl
, /*integral_constant_expression_p=*/false);
16392 case OMP_CLAUSE_LINEAR
:
16393 OMP_CLAUSE_DECL (nc
)
16394 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16396 if (OMP_CLAUSE_LINEAR_STEP (oc
) == NULL_TREE
)
16398 gcc_assert (!linear_no_step
);
16399 linear_no_step
= nc
;
16401 else if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (oc
))
16402 OMP_CLAUSE_LINEAR_STEP (nc
)
16403 = tsubst_omp_clause_decl (OMP_CLAUSE_LINEAR_STEP (oc
), args
,
16404 complain
, in_decl
, NULL
);
16406 OMP_CLAUSE_LINEAR_STEP (nc
)
16407 = tsubst_expr (OMP_CLAUSE_LINEAR_STEP (oc
), args
, complain
,
16409 /*integral_constant_expression_p=*/false);
16411 case OMP_CLAUSE_NOWAIT
:
16412 case OMP_CLAUSE_DEFAULT
:
16413 case OMP_CLAUSE_UNTIED
:
16414 case OMP_CLAUSE_MERGEABLE
:
16415 case OMP_CLAUSE_INBRANCH
:
16416 case OMP_CLAUSE_NOTINBRANCH
:
16417 case OMP_CLAUSE_PROC_BIND
:
16418 case OMP_CLAUSE_FOR
:
16419 case OMP_CLAUSE_PARALLEL
:
16420 case OMP_CLAUSE_SECTIONS
:
16421 case OMP_CLAUSE_TASKGROUP
:
16422 case OMP_CLAUSE_NOGROUP
:
16423 case OMP_CLAUSE_THREADS
:
16424 case OMP_CLAUSE_SIMD
:
16425 case OMP_CLAUSE_DEFAULTMAP
:
16426 case OMP_CLAUSE_INDEPENDENT
:
16427 case OMP_CLAUSE_AUTO
:
16428 case OMP_CLAUSE_SEQ
:
16429 case OMP_CLAUSE_IF_PRESENT
:
16430 case OMP_CLAUSE_FINALIZE
:
16433 gcc_unreachable ();
16435 if ((ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
)
16436 switch (OMP_CLAUSE_CODE (nc
))
16438 case OMP_CLAUSE_SHARED
:
16439 case OMP_CLAUSE_PRIVATE
:
16440 case OMP_CLAUSE_FIRSTPRIVATE
:
16441 case OMP_CLAUSE_LASTPRIVATE
:
16442 case OMP_CLAUSE_COPYPRIVATE
:
16443 case OMP_CLAUSE_LINEAR
:
16444 case OMP_CLAUSE_REDUCTION
:
16445 case OMP_CLAUSE_IN_REDUCTION
:
16446 case OMP_CLAUSE_TASK_REDUCTION
:
16447 case OMP_CLAUSE_USE_DEVICE_PTR
:
16448 case OMP_CLAUSE_IS_DEVICE_PTR
:
16449 case OMP_CLAUSE_INCLUSIVE
:
16450 case OMP_CLAUSE_EXCLUSIVE
:
16451 /* tsubst_expr on SCOPE_REF results in returning
16452 finish_non_static_data_member result. Undo that here. */
16453 if (TREE_CODE (OMP_CLAUSE_DECL (oc
)) == SCOPE_REF
16454 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (oc
), 1))
16455 == IDENTIFIER_NODE
))
16457 tree t
= OMP_CLAUSE_DECL (nc
);
16460 switch (TREE_CODE (v
))
16462 case COMPONENT_REF
:
16466 case POINTER_PLUS_EXPR
:
16467 v
= TREE_OPERAND (v
, 0);
16470 if (DECL_CONTEXT (v
) == current_function_decl
16471 && DECL_ARTIFICIAL (v
)
16472 && DECL_NAME (v
) == this_identifier
)
16473 OMP_CLAUSE_DECL (nc
) = TREE_OPERAND (t
, 1);
16480 else if (VAR_P (OMP_CLAUSE_DECL (oc
))
16481 && DECL_HAS_VALUE_EXPR_P (OMP_CLAUSE_DECL (oc
))
16482 && DECL_ARTIFICIAL (OMP_CLAUSE_DECL (oc
))
16483 && DECL_LANG_SPECIFIC (OMP_CLAUSE_DECL (oc
))
16484 && DECL_OMP_PRIVATIZED_MEMBER (OMP_CLAUSE_DECL (oc
)))
16486 tree decl
= OMP_CLAUSE_DECL (nc
);
16489 retrofit_lang_decl (decl
);
16490 DECL_OMP_PRIVATIZED_MEMBER (decl
) = 1;
16499 new_clauses
= nreverse (new_clauses
);
16500 if (ort
!= C_ORT_OMP_DECLARE_SIMD
)
16502 new_clauses
= finish_omp_clauses (new_clauses
, ort
);
16503 if (linear_no_step
)
16504 for (nc
= new_clauses
; nc
; nc
= OMP_CLAUSE_CHAIN (nc
))
16505 if (nc
== linear_no_step
)
16507 OMP_CLAUSE_LINEAR_STEP (nc
) = NULL_TREE
;
16511 return new_clauses
;
16514 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
16517 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
16520 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
16522 tree purpose
, value
, chain
;
16527 if (TREE_CODE (t
) != TREE_LIST
)
16528 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
16529 /*function_p=*/false,
16530 /*integral_constant_expression_p=*/false);
16532 if (t
== void_list_node
)
16535 purpose
= TREE_PURPOSE (t
);
16537 purpose
= RECUR (purpose
);
16538 value
= TREE_VALUE (t
);
16541 if (TREE_CODE (value
) != LABEL_DECL
)
16542 value
= RECUR (value
);
16545 value
= lookup_label (DECL_NAME (value
));
16546 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
16547 TREE_USED (value
) = 1;
16550 chain
= TREE_CHAIN (t
);
16551 if (chain
&& chain
!= void_type_node
)
16552 chain
= RECUR (chain
);
16553 return tree_cons (purpose
, value
, chain
);
16557 /* Used to temporarily communicate the list of #pragma omp parallel
16558 clauses to #pragma omp for instantiation if they are combined
16561 static tree
*omp_parallel_combined_clauses
;
16563 static tree
tsubst_decomp_names (tree
, tree
, tree
, tsubst_flags_t
, tree
,
16564 tree
*, unsigned int *);
16566 /* Substitute one OMP_FOR iterator. */
16569 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree
&orig_declv
,
16570 tree initv
, tree condv
, tree incrv
, tree
*clauses
,
16571 tree args
, tsubst_flags_t complain
, tree in_decl
,
16572 bool integral_constant_expression_p
)
16574 #define RECUR(NODE) \
16575 tsubst_expr ((NODE), args, complain, in_decl, \
16576 integral_constant_expression_p)
16577 tree decl
, init
, cond
= NULL_TREE
, incr
= NULL_TREE
;
16580 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
16581 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
16583 decl
= TREE_OPERAND (init
, 0);
16584 init
= TREE_OPERAND (init
, 1);
16585 tree decl_expr
= NULL_TREE
;
16586 bool range_for
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
) == global_namespace
;
16589 bool decomp
= false;
16590 if (decl
!= error_mark_node
&& DECL_HAS_VALUE_EXPR_P (decl
))
16592 tree v
= DECL_VALUE_EXPR (decl
);
16593 if (TREE_CODE (v
) == ARRAY_REF
16594 && VAR_P (TREE_OPERAND (v
, 0))
16595 && DECL_DECOMPOSITION_P (TREE_OPERAND (v
, 0)))
16597 tree decomp_first
= NULL_TREE
;
16598 unsigned decomp_cnt
= 0;
16599 tree d
= tsubst_decl (TREE_OPERAND (v
, 0), args
, complain
);
16600 maybe_push_decl (d
);
16601 d
= tsubst_decomp_names (d
, TREE_OPERAND (v
, 0), args
, complain
,
16602 in_decl
, &decomp_first
, &decomp_cnt
);
16604 if (d
== error_mark_node
)
16605 decl
= error_mark_node
;
16607 for (unsigned int i
= 0; i
< decomp_cnt
; i
++)
16609 if (!DECL_HAS_VALUE_EXPR_P (decomp_first
))
16611 tree v
= build_nt (ARRAY_REF
, d
,
16612 size_int (decomp_cnt
- i
- 1),
16613 NULL_TREE
, NULL_TREE
);
16614 SET_DECL_VALUE_EXPR (decomp_first
, v
);
16615 DECL_HAS_VALUE_EXPR_P (decomp_first
) = 1;
16617 fit_decomposition_lang_decl (decomp_first
, d
);
16618 decomp_first
= DECL_CHAIN (decomp_first
);
16622 decl
= tsubst_decl (decl
, args
, complain
);
16624 maybe_push_decl (decl
);
16626 else if (init
&& TREE_CODE (init
) == DECL_EXPR
)
16628 /* We need to jump through some hoops to handle declarations in the
16629 init-statement, since we might need to handle auto deduction,
16630 but we need to keep control of initialization. */
16632 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
16633 decl
= tsubst_decl (decl
, args
, complain
);
16637 if (TREE_CODE (decl
) == SCOPE_REF
)
16639 decl
= RECUR (decl
);
16640 if (TREE_CODE (decl
) == COMPONENT_REF
)
16644 switch (TREE_CODE (v
))
16646 case COMPONENT_REF
:
16650 case POINTER_PLUS_EXPR
:
16651 v
= TREE_OPERAND (v
, 0);
16654 if (DECL_CONTEXT (v
) == current_function_decl
16655 && DECL_ARTIFICIAL (v
)
16656 && DECL_NAME (v
) == this_identifier
)
16658 decl
= TREE_OPERAND (decl
, 1);
16659 decl
= omp_privatize_field (decl
, false);
16669 decl
= RECUR (decl
);
16671 init
= RECUR (init
);
16673 if (orig_declv
&& OMP_FOR_ORIG_DECLS (t
))
16675 tree o
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t
), i
);
16676 if (TREE_CODE (o
) == TREE_LIST
)
16677 TREE_VEC_ELT (orig_declv
, i
)
16678 = tree_cons (RECUR (TREE_PURPOSE (o
)),
16679 RECUR (TREE_VALUE (o
)),
16682 TREE_VEC_ELT (orig_declv
, i
) = RECUR (o
);
16687 tree this_pre_body
= NULL_TREE
;
16688 tree orig_init
= NULL_TREE
;
16689 tree orig_decl
= NULL_TREE
;
16690 cp_convert_omp_range_for (this_pre_body
, NULL
, decl
, orig_decl
, init
,
16691 orig_init
, cond
, incr
);
16694 if (orig_declv
== NULL_TREE
)
16695 orig_declv
= copy_node (declv
);
16696 TREE_VEC_ELT (orig_declv
, i
) = orig_decl
;
16699 else if (orig_declv
)
16700 TREE_VEC_ELT (orig_declv
, i
) = decl
;
16703 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
16704 if (!range_for
&& auto_node
&& init
)
16706 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
, complain
);
16708 gcc_assert (!type_dependent_expression_p (decl
));
16710 if (!CLASS_TYPE_P (TREE_TYPE (decl
)) || range_for
)
16714 /* Declare the variable, but don't let that initialize it. */
16715 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
16716 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
16718 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
16723 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
16724 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
16725 if (TREE_CODE (incr
) == MODIFY_EXPR
)
16727 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16728 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
16729 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
16730 NOP_EXPR
, rhs
, complain
);
16733 incr
= RECUR (incr
);
16734 if (orig_declv
&& !OMP_FOR_ORIG_DECLS (t
))
16735 TREE_VEC_ELT (orig_declv
, i
) = decl
;
16737 TREE_VEC_ELT (declv
, i
) = decl
;
16738 TREE_VEC_ELT (initv
, i
) = init
;
16739 TREE_VEC_ELT (condv
, i
) = cond
;
16740 TREE_VEC_ELT (incrv
, i
) = incr
;
16746 /* Declare and initialize the variable. */
16754 for (j
= (omp_parallel_combined_clauses
== NULL
? 1 : 0); j
< 2; j
++)
16756 for (pc
= j
? clauses
: omp_parallel_combined_clauses
; *pc
; )
16758 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
16759 && OMP_CLAUSE_DECL (*pc
) == decl
)
16761 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_LASTPRIVATE
16762 && OMP_CLAUSE_DECL (*pc
) == decl
)
16766 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
16768 *pc
= OMP_CLAUSE_CHAIN (c
);
16769 OMP_CLAUSE_CHAIN (c
) = *clauses
;
16772 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_FIRSTPRIVATE
16773 && OMP_CLAUSE_DECL (*pc
) == decl
)
16775 error ("iteration variable %qD should not be firstprivate",
16777 *pc
= OMP_CLAUSE_CHAIN (*pc
);
16779 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_REDUCTION
16780 && OMP_CLAUSE_DECL (*pc
) == decl
)
16782 error ("iteration variable %qD should not be reduction",
16784 *pc
= OMP_CLAUSE_CHAIN (*pc
);
16787 pc
= &OMP_CLAUSE_CHAIN (*pc
);
16792 if (*pc
== NULL_TREE
)
16794 tree c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
16795 OMP_CLAUSE_DECL (c
) = decl
;
16796 c
= finish_omp_clauses (c
, C_ORT_OMP
);
16799 OMP_CLAUSE_CHAIN (c
) = *clauses
;
16804 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
16805 if (COMPARISON_CLASS_P (cond
))
16807 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
16808 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
16809 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
16812 cond
= RECUR (cond
);
16813 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
16814 switch (TREE_CODE (incr
))
16816 case PREINCREMENT_EXPR
:
16817 case PREDECREMENT_EXPR
:
16818 case POSTINCREMENT_EXPR
:
16819 case POSTDECREMENT_EXPR
:
16820 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
16821 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
16824 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
16825 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
16827 tree rhs
= TREE_OPERAND (incr
, 1);
16828 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16829 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
16830 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
16831 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
16832 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
16836 incr
= RECUR (incr
);
16839 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
16840 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
16842 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16843 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
16844 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
16845 TREE_TYPE (decl
), lhs
,
16846 RECUR (TREE_OPERAND (incr
, 2))));
16848 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
16849 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
16850 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
16852 tree rhs
= TREE_OPERAND (incr
, 2);
16853 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16854 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
16855 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
16856 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
16857 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
16861 incr
= RECUR (incr
);
16864 incr
= RECUR (incr
);
16868 if (orig_declv
&& !OMP_FOR_ORIG_DECLS (t
))
16869 TREE_VEC_ELT (orig_declv
, i
) = decl
;
16870 TREE_VEC_ELT (declv
, i
) = decl
;
16871 TREE_VEC_ELT (initv
, i
) = init
;
16872 TREE_VEC_ELT (condv
, i
) = cond
;
16873 TREE_VEC_ELT (incrv
, i
) = incr
;
16878 /* Helper function of tsubst_expr, find OMP_TEAMS inside
16879 of OMP_TARGET's body. */
16882 tsubst_find_omp_teams (tree
*tp
, int *walk_subtrees
, void *)
16884 *walk_subtrees
= 0;
16885 switch (TREE_CODE (*tp
))
16890 case STATEMENT_LIST
:
16891 *walk_subtrees
= 1;
16899 /* Helper function for tsubst_expr. For decomposition declaration
16900 artificial base DECL, which is tsubsted PATTERN_DECL, tsubst
16901 also the corresponding decls representing the identifiers
16902 of the decomposition declaration. Return DECL if successful
16903 or error_mark_node otherwise, set *FIRST to the first decl
16904 in the list chained through DECL_CHAIN and *CNT to the number
16908 tsubst_decomp_names (tree decl
, tree pattern_decl
, tree args
,
16909 tsubst_flags_t complain
, tree in_decl
, tree
*first
,
16912 tree decl2
, decl3
, prev
= decl
;
16914 gcc_assert (DECL_NAME (decl
) == NULL_TREE
);
16915 for (decl2
= DECL_CHAIN (pattern_decl
);
16918 && DECL_DECOMPOSITION_P (decl2
)
16919 && DECL_NAME (decl2
);
16920 decl2
= DECL_CHAIN (decl2
))
16922 if (TREE_TYPE (decl2
) == error_mark_node
&& *cnt
== 0)
16924 gcc_assert (errorcount
);
16925 return error_mark_node
;
16928 gcc_assert (DECL_DECOMP_BASE (decl2
) == pattern_decl
);
16929 gcc_assert (DECL_HAS_VALUE_EXPR_P (decl2
));
16930 tree v
= DECL_VALUE_EXPR (decl2
);
16931 DECL_HAS_VALUE_EXPR_P (decl2
) = 0;
16932 SET_DECL_VALUE_EXPR (decl2
, NULL_TREE
);
16933 decl3
= tsubst (decl2
, args
, complain
, in_decl
);
16934 SET_DECL_VALUE_EXPR (decl2
, v
);
16935 DECL_HAS_VALUE_EXPR_P (decl2
) = 1;
16937 DECL_TEMPLATE_INSTANTIATED (decl3
) = 1;
16940 gcc_assert (errorcount
);
16941 decl
= error_mark_node
;
16944 maybe_push_decl (decl3
);
16945 if (error_operand_p (decl3
))
16946 decl
= error_mark_node
;
16947 else if (decl
!= error_mark_node
16948 && DECL_CHAIN (decl3
) != prev
16951 gcc_assert (errorcount
);
16952 decl
= error_mark_node
;
16961 /* Return the proper local_specialization for init-capture pack DECL. */
16964 lookup_init_capture_pack (tree decl
)
16966 /* We handle normal pack captures by forwarding to the specialization of the
16967 captured parameter. We can't do that for pack init-captures; we need them
16968 to have their own local_specialization. We created the individual
16969 VAR_DECLs (if any) under build_capture_proxy, and we need to collect them
16970 when we process the DECL_EXPR for the pack init-capture in the template.
16971 So, how do we find them? We don't know the capture proxy pack when
16972 building the individual resulting proxies, and we don't know the
16973 individual proxies when instantiating the pack. What we have in common is
16976 So...when we instantiate the FIELD_DECL, we stick the result in
16977 local_specializations. Then at the DECL_EXPR we look up that result, see
16978 how many elements it has, synthesize the names, and look them up. */
16980 tree cname
= DECL_NAME (decl
);
16981 tree val
= DECL_VALUE_EXPR (decl
);
16982 tree field
= TREE_OPERAND (val
, 1);
16983 gcc_assert (TREE_CODE (field
) == FIELD_DECL
);
16984 tree fpack
= retrieve_local_specialization (field
);
16985 if (fpack
== error_mark_node
)
16986 return error_mark_node
;
16989 tree vec
= NULL_TREE
;
16990 tree r
= NULL_TREE
;
16991 if (TREE_CODE (fpack
) == TREE_VEC
)
16993 len
= TREE_VEC_LENGTH (fpack
);
16994 vec
= make_tree_vec (len
);
16995 r
= make_node (NONTYPE_ARGUMENT_PACK
);
16996 SET_ARGUMENT_PACK_ARGS (r
, vec
);
16998 for (int i
= 0; i
< len
; ++i
)
17000 tree ename
= vec
? make_ith_pack_parameter_name (cname
, i
) : cname
;
17001 tree elt
= lookup_name_real (ename
, 0, 0, true, 0, LOOKUP_NORMAL
);
17003 TREE_VEC_ELT (vec
, i
) = elt
;
17010 /* Like tsubst_copy for expressions, etc. but also does semantic
17014 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
17015 bool integral_constant_expression_p
)
17017 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
17018 #define RECUR(NODE) \
17019 tsubst_expr ((NODE), args, complain, in_decl, \
17020 integral_constant_expression_p)
17026 if (t
== NULL_TREE
|| t
== error_mark_node
)
17029 loc
= input_location
;
17030 if (location_t eloc
= cp_expr_location (t
))
17031 input_location
= eloc
;
17032 if (STATEMENT_CODE_P (TREE_CODE (t
)))
17033 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
17035 switch (TREE_CODE (t
))
17037 case STATEMENT_LIST
:
17039 tree_stmt_iterator i
;
17040 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
17041 RECUR (tsi_stmt (i
));
17045 case CTOR_INITIALIZER
:
17046 finish_mem_initializers (tsubst_initializer_list
17047 (TREE_OPERAND (t
, 0), args
));
17051 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
17055 tmp
= RECUR (EXPR_STMT_EXPR (t
));
17056 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
17057 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
17059 finish_expr_stmt (tmp
);
17063 finish_using_directive (USING_STMT_NAMESPACE (t
), /*attribs=*/NULL_TREE
);
17068 tree decl
, pattern_decl
;
17071 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
17072 if (TREE_CODE (decl
) == LABEL_DECL
)
17073 finish_label_decl (DECL_NAME (decl
));
17074 else if (TREE_CODE (decl
) == USING_DECL
)
17076 tree scope
= USING_DECL_SCOPE (decl
);
17077 tree name
= DECL_NAME (decl
);
17079 scope
= tsubst (scope
, args
, complain
, in_decl
);
17080 finish_nonmember_using_decl (scope
, name
);
17082 else if (is_capture_proxy (decl
)
17083 && !DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
17085 /* We're in tsubst_lambda_expr, we've already inserted a new
17086 capture proxy, so look it up and register it. */
17088 if (!DECL_PACK_P (decl
))
17090 inst
= lookup_name_real (DECL_NAME (decl
), /*prefer_type*/0,
17091 /*nonclass*/1, /*block_p=*/true,
17092 /*ns_only*/0, LOOKUP_HIDDEN
);
17093 gcc_assert (inst
!= decl
&& is_capture_proxy (inst
));
17095 else if (is_normal_capture_proxy (decl
))
17097 inst
= (retrieve_local_specialization
17098 (DECL_CAPTURED_VARIABLE (decl
)));
17099 gcc_assert (TREE_CODE (inst
) == NONTYPE_ARGUMENT_PACK
);
17102 inst
= lookup_init_capture_pack (decl
);
17104 register_local_specialization (inst
, decl
);
17107 else if (DECL_PRETTY_FUNCTION_P (decl
))
17108 decl
= make_fname_decl (DECL_SOURCE_LOCATION (decl
),
17110 true/*DECL_PRETTY_FUNCTION_P (decl)*/);
17111 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
17112 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
17113 /* Don't copy the old closure; we'll create a new one in
17114 tsubst_lambda_expr. */
17118 init
= DECL_INITIAL (decl
);
17119 decl
= tsubst (decl
, args
, complain
, in_decl
);
17120 if (decl
!= error_mark_node
)
17122 /* By marking the declaration as instantiated, we avoid
17123 trying to instantiate it. Since instantiate_decl can't
17124 handle local variables, and since we've already done
17125 all that needs to be done, that's the right thing to
17128 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
17129 if (VAR_P (decl
) && !DECL_NAME (decl
)
17130 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
17131 /* Anonymous aggregates are a special case. */
17132 finish_anon_union (decl
);
17133 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
17135 DECL_CONTEXT (decl
) = current_function_decl
;
17136 if (DECL_NAME (decl
) == this_identifier
)
17138 tree lam
= DECL_CONTEXT (current_function_decl
);
17139 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
17140 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
17142 insert_capture_proxy (decl
);
17144 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
17145 /* We already did a pushtag. */;
17146 else if (TREE_CODE (decl
) == FUNCTION_DECL
17147 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
17148 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
17150 DECL_CONTEXT (decl
) = NULL_TREE
;
17152 DECL_CONTEXT (decl
) = current_function_decl
;
17153 cp_check_omp_declare_reduction (decl
);
17157 int const_init
= false;
17158 unsigned int cnt
= 0;
17159 tree first
= NULL_TREE
, ndecl
= error_mark_node
;
17160 maybe_push_decl (decl
);
17163 && DECL_DECOMPOSITION_P (decl
)
17164 && TREE_TYPE (pattern_decl
) != error_mark_node
)
17165 ndecl
= tsubst_decomp_names (decl
, pattern_decl
, args
,
17166 complain
, in_decl
, &first
,
17169 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
17172 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
17175 if (ndecl
!= error_mark_node
)
17176 cp_maybe_mangle_decomp (ndecl
, first
, cnt
);
17178 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
17180 if (ndecl
!= error_mark_node
)
17181 cp_finish_decomp (ndecl
, first
, cnt
);
17190 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
17191 RECUR (FOR_INIT_STMT (t
));
17192 finish_init_stmt (stmt
);
17193 tmp
= RECUR (FOR_COND (t
));
17194 finish_for_cond (tmp
, stmt
, false, 0);
17195 tmp
= RECUR (FOR_EXPR (t
));
17196 finish_for_expr (tmp
, stmt
);
17198 bool prev
= note_iteration_stmt_body_start ();
17199 RECUR (FOR_BODY (t
));
17200 note_iteration_stmt_body_end (prev
);
17202 finish_for_stmt (stmt
);
17205 case RANGE_FOR_STMT
:
17207 /* Construct another range_for, if this is not a final
17208 substitution (for inside inside a generic lambda of a
17209 template). Otherwise convert to a regular for. */
17211 stmt
= (processing_template_decl
17212 ? begin_range_for_stmt (NULL_TREE
, NULL_TREE
)
17213 : begin_for_stmt (NULL_TREE
, NULL_TREE
));
17214 RECUR (RANGE_FOR_INIT_STMT (t
));
17215 decl
= RANGE_FOR_DECL (t
);
17216 decl
= tsubst (decl
, args
, complain
, in_decl
);
17217 maybe_push_decl (decl
);
17218 expr
= RECUR (RANGE_FOR_EXPR (t
));
17220 tree decomp_first
= NULL_TREE
;
17221 unsigned decomp_cnt
= 0;
17222 if (VAR_P (decl
) && DECL_DECOMPOSITION_P (decl
))
17223 decl
= tsubst_decomp_names (decl
, RANGE_FOR_DECL (t
), args
,
17225 &decomp_first
, &decomp_cnt
);
17227 if (processing_template_decl
)
17229 RANGE_FOR_IVDEP (stmt
) = RANGE_FOR_IVDEP (t
);
17230 RANGE_FOR_UNROLL (stmt
) = RANGE_FOR_UNROLL (t
);
17231 finish_range_for_decl (stmt
, decl
, expr
);
17232 if (decomp_first
&& decl
!= error_mark_node
)
17233 cp_finish_decomp (decl
, decomp_first
, decomp_cnt
);
17237 unsigned short unroll
= (RANGE_FOR_UNROLL (t
)
17238 ? tree_to_uhwi (RANGE_FOR_UNROLL (t
)) : 0);
17239 stmt
= cp_convert_range_for (stmt
, decl
, expr
,
17240 decomp_first
, decomp_cnt
,
17241 RANGE_FOR_IVDEP (t
), unroll
);
17244 bool prev
= note_iteration_stmt_body_start ();
17245 RECUR (RANGE_FOR_BODY (t
));
17246 note_iteration_stmt_body_end (prev
);
17247 finish_for_stmt (stmt
);
17252 stmt
= begin_while_stmt ();
17253 tmp
= RECUR (WHILE_COND (t
));
17254 finish_while_stmt_cond (tmp
, stmt
, false, 0);
17256 bool prev
= note_iteration_stmt_body_start ();
17257 RECUR (WHILE_BODY (t
));
17258 note_iteration_stmt_body_end (prev
);
17260 finish_while_stmt (stmt
);
17264 stmt
= begin_do_stmt ();
17266 bool prev
= note_iteration_stmt_body_start ();
17267 RECUR (DO_BODY (t
));
17268 note_iteration_stmt_body_end (prev
);
17270 finish_do_body (stmt
);
17271 tmp
= RECUR (DO_COND (t
));
17272 finish_do_stmt (tmp
, stmt
, false, 0);
17276 stmt
= begin_if_stmt ();
17277 IF_STMT_CONSTEXPR_P (stmt
) = IF_STMT_CONSTEXPR_P (t
);
17278 if (IF_STMT_CONSTEXPR_P (t
))
17279 args
= add_extra_args (IF_STMT_EXTRA_ARGS (t
), args
);
17280 tmp
= RECUR (IF_COND (t
));
17281 tmp
= finish_if_stmt_cond (tmp
, stmt
);
17282 if (IF_STMT_CONSTEXPR_P (t
)
17283 && instantiation_dependent_expression_p (tmp
))
17285 /* We're partially instantiating a generic lambda, but the condition
17286 of the constexpr if is still dependent. Don't substitute into the
17287 branches now, just remember the template arguments. */
17288 do_poplevel (IF_SCOPE (stmt
));
17289 IF_COND (stmt
) = IF_COND (t
);
17290 THEN_CLAUSE (stmt
) = THEN_CLAUSE (t
);
17291 ELSE_CLAUSE (stmt
) = ELSE_CLAUSE (t
);
17292 IF_STMT_EXTRA_ARGS (stmt
) = build_extra_args (t
, args
, complain
);
17296 if (IF_STMT_CONSTEXPR_P (t
) && integer_zerop (tmp
))
17297 /* Don't instantiate the THEN_CLAUSE. */;
17300 tree folded
= fold_non_dependent_expr (tmp
, complain
);
17301 bool inhibit
= integer_zerop (folded
);
17303 ++c_inhibit_evaluation_warnings
;
17304 RECUR (THEN_CLAUSE (t
));
17306 --c_inhibit_evaluation_warnings
;
17308 finish_then_clause (stmt
);
17310 if (IF_STMT_CONSTEXPR_P (t
) && integer_nonzerop (tmp
))
17311 /* Don't instantiate the ELSE_CLAUSE. */;
17312 else if (ELSE_CLAUSE (t
))
17314 tree folded
= fold_non_dependent_expr (tmp
, complain
);
17315 bool inhibit
= integer_nonzerop (folded
);
17316 begin_else_clause (stmt
);
17318 ++c_inhibit_evaluation_warnings
;
17319 RECUR (ELSE_CLAUSE (t
));
17321 --c_inhibit_evaluation_warnings
;
17322 finish_else_clause (stmt
);
17325 finish_if_stmt (stmt
);
17329 if (BIND_EXPR_BODY_BLOCK (t
))
17330 stmt
= begin_function_body ();
17332 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
17333 ? BCS_TRY_BLOCK
: 0);
17335 RECUR (BIND_EXPR_BODY (t
));
17337 if (BIND_EXPR_BODY_BLOCK (t
))
17338 finish_function_body (stmt
);
17340 finish_compound_stmt (stmt
);
17344 finish_break_stmt ();
17347 case CONTINUE_STMT
:
17348 finish_continue_stmt ();
17352 stmt
= begin_switch_stmt ();
17353 tmp
= RECUR (SWITCH_STMT_COND (t
));
17354 finish_switch_cond (tmp
, stmt
);
17355 RECUR (SWITCH_STMT_BODY (t
));
17356 finish_switch_stmt (stmt
);
17359 case CASE_LABEL_EXPR
:
17361 tree decl
= CASE_LABEL (t
);
17362 tree low
= RECUR (CASE_LOW (t
));
17363 tree high
= RECUR (CASE_HIGH (t
));
17364 tree l
= finish_case_label (EXPR_LOCATION (t
), low
, high
);
17365 if (l
&& TREE_CODE (l
) == CASE_LABEL_EXPR
)
17367 tree label
= CASE_LABEL (l
);
17368 FALLTHROUGH_LABEL_P (label
) = FALLTHROUGH_LABEL_P (decl
);
17369 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
17370 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
17377 tree decl
= LABEL_EXPR_LABEL (t
);
17380 label
= finish_label_stmt (DECL_NAME (decl
));
17381 if (TREE_CODE (label
) == LABEL_DECL
)
17382 FALLTHROUGH_LABEL_P (label
) = FALLTHROUGH_LABEL_P (decl
);
17383 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
17384 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
17389 tmp
= GOTO_DESTINATION (t
);
17390 if (TREE_CODE (tmp
) != LABEL_DECL
)
17391 /* Computed goto's must be tsubst'd into. On the other hand,
17392 non-computed gotos must not be; the identifier in question
17393 will have no binding. */
17396 tmp
= DECL_NAME (tmp
);
17397 finish_goto_stmt (tmp
);
17402 tree string
= RECUR (ASM_STRING (t
));
17403 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
17404 complain
, in_decl
);
17405 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
17406 complain
, in_decl
);
17407 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
17408 complain
, in_decl
);
17409 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
17410 complain
, in_decl
);
17411 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
17412 clobbers
, labels
, ASM_INLINE_P (t
));
17413 tree asm_expr
= tmp
;
17414 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
17415 asm_expr
= TREE_OPERAND (asm_expr
, 0);
17416 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
17423 stmt
= begin_try_block ();
17424 RECUR (TRY_STMTS (t
));
17425 finish_cleanup_try_block (stmt
);
17426 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
17430 tree compound_stmt
= NULL_TREE
;
17432 if (FN_TRY_BLOCK_P (t
))
17433 stmt
= begin_function_try_block (&compound_stmt
);
17435 stmt
= begin_try_block ();
17437 RECUR (TRY_STMTS (t
));
17439 if (FN_TRY_BLOCK_P (t
))
17440 finish_function_try_block (stmt
);
17442 finish_try_block (stmt
);
17444 RECUR (TRY_HANDLERS (t
));
17445 if (FN_TRY_BLOCK_P (t
))
17446 finish_function_handler_sequence (stmt
, compound_stmt
);
17448 finish_handler_sequence (stmt
);
17454 tree decl
= HANDLER_PARMS (t
);
17458 decl
= tsubst (decl
, args
, complain
, in_decl
);
17459 /* Prevent instantiate_decl from trying to instantiate
17460 this variable. We've already done all that needs to be
17462 if (decl
!= error_mark_node
)
17463 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
17465 stmt
= begin_handler ();
17466 finish_handler_parms (decl
, stmt
);
17467 RECUR (HANDLER_BODY (t
));
17468 finish_handler (stmt
);
17473 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
17474 if (CLASS_TYPE_P (tmp
))
17476 /* Local classes are not independent templates; they are
17477 instantiated along with their containing function. And this
17478 way we don't have to deal with pushing out of one local class
17479 to instantiate a member of another local class. */
17480 /* Closures are handled by the LAMBDA_EXPR. */
17481 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
17482 complete_type (tmp
);
17483 for (tree fld
= TYPE_FIELDS (tmp
); fld
; fld
= DECL_CHAIN (fld
))
17485 || (TREE_CODE (fld
) == FUNCTION_DECL
17486 && !DECL_ARTIFICIAL (fld
)))
17487 && DECL_TEMPLATE_INSTANTIATION (fld
))
17488 instantiate_decl (fld
, /*defer_ok=*/false,
17489 /*expl_inst_class=*/false);
17493 case STATIC_ASSERT
:
17497 ++c_inhibit_evaluation_warnings
;
17499 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
17502 /*integral_constant_expression_p=*/true);
17503 --c_inhibit_evaluation_warnings
;
17505 finish_static_assert (condition
,
17506 STATIC_ASSERT_MESSAGE (t
),
17507 STATIC_ASSERT_SOURCE_LOCATION (t
),
17508 /*member_p=*/false);
17513 case OACC_PARALLEL
:
17514 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_ACC
, args
, complain
,
17516 stmt
= begin_omp_parallel ();
17517 RECUR (OMP_BODY (t
));
17518 finish_omp_construct (TREE_CODE (t
), stmt
, tmp
);
17522 r
= push_omp_privatization_clauses (OMP_PARALLEL_COMBINED (t
));
17523 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), C_ORT_OMP
, args
,
17524 complain
, in_decl
);
17525 if (OMP_PARALLEL_COMBINED (t
))
17526 omp_parallel_combined_clauses
= &tmp
;
17527 stmt
= begin_omp_parallel ();
17528 RECUR (OMP_PARALLEL_BODY (t
));
17529 gcc_assert (omp_parallel_combined_clauses
== NULL
);
17530 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
17531 = OMP_PARALLEL_COMBINED (t
);
17532 pop_omp_privatization_clauses (r
);
17536 if (OMP_TASK_BODY (t
) == NULL_TREE
)
17538 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), C_ORT_OMP
, args
,
17539 complain
, in_decl
);
17541 OMP_TASK_CLAUSES (t
) = tmp
;
17545 r
= push_omp_privatization_clauses (false);
17546 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), C_ORT_OMP
, args
,
17547 complain
, in_decl
);
17548 stmt
= begin_omp_task ();
17549 RECUR (OMP_TASK_BODY (t
));
17550 finish_omp_task (tmp
, stmt
);
17551 pop_omp_privatization_clauses (r
);
17556 case OMP_DISTRIBUTE
:
17560 tree clauses
, body
, pre_body
;
17561 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
17562 tree orig_declv
= NULL_TREE
;
17563 tree incrv
= NULL_TREE
;
17564 enum c_omp_region_type ort
= C_ORT_OMP
;
17565 bool any_range_for
= false;
17568 if (TREE_CODE (t
) == OACC_LOOP
)
17571 r
= push_omp_privatization_clauses (OMP_FOR_INIT (t
) == NULL_TREE
);
17572 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), ort
, args
, complain
,
17574 if (OMP_FOR_INIT (t
) != NULL_TREE
)
17576 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17577 if (OMP_FOR_ORIG_DECLS (t
))
17578 orig_declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17579 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17580 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17581 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17584 keep_next_level (true);
17585 stmt
= begin_omp_structured_block ();
17587 pre_body
= push_stmt_list ();
17588 RECUR (OMP_FOR_PRE_BODY (t
));
17589 pre_body
= pop_stmt_list (pre_body
);
17591 if (OMP_FOR_INIT (t
) != NULL_TREE
)
17592 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
17594 |= tsubst_omp_for_iterator (t
, i
, declv
, orig_declv
, initv
,
17595 condv
, incrv
, &clauses
, args
,
17597 integral_constant_expression_p
);
17598 omp_parallel_combined_clauses
= NULL
;
17602 gcc_assert (orig_declv
);
17603 body
= begin_omp_structured_block ();
17604 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
17605 if (TREE_VEC_ELT (orig_declv
, i
) != TREE_VEC_ELT (declv
, i
)
17606 && TREE_CODE (TREE_VEC_ELT (orig_declv
, i
)) == TREE_LIST
17607 && TREE_CHAIN (TREE_VEC_ELT (orig_declv
, i
)))
17608 cp_finish_omp_range_for (TREE_VEC_ELT (orig_declv
, i
),
17609 TREE_VEC_ELT (declv
, i
));
17612 body
= push_stmt_list ();
17613 RECUR (OMP_FOR_BODY (t
));
17615 body
= finish_omp_structured_block (body
);
17617 body
= pop_stmt_list (body
);
17619 if (OMP_FOR_INIT (t
) != NULL_TREE
)
17620 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
,
17621 orig_declv
, initv
, condv
, incrv
, body
, pre_body
,
17625 t
= make_node (TREE_CODE (t
));
17626 TREE_TYPE (t
) = void_type_node
;
17627 OMP_FOR_BODY (t
) = body
;
17628 OMP_FOR_PRE_BODY (t
) = pre_body
;
17629 OMP_FOR_CLAUSES (t
) = clauses
;
17630 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
17634 add_stmt (finish_omp_for_block (finish_omp_structured_block (stmt
),
17636 pop_omp_privatization_clauses (r
);
17641 omp_parallel_combined_clauses
= NULL
;
17646 case OMP_TASKGROUP
:
17648 r
= push_omp_privatization_clauses (TREE_CODE (t
) == OMP_TEAMS
17649 && OMP_TEAMS_COMBINED (t
));
17650 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_OMP
, args
, complain
,
17652 if (TREE_CODE (t
) == OMP_TEAMS
)
17654 keep_next_level (true);
17655 stmt
= begin_omp_structured_block ();
17656 RECUR (OMP_BODY (t
));
17657 stmt
= finish_omp_structured_block (stmt
);
17661 stmt
= push_stmt_list ();
17662 RECUR (OMP_BODY (t
));
17663 stmt
= pop_stmt_list (stmt
);
17667 OMP_BODY (t
) = stmt
;
17668 OMP_CLAUSES (t
) = tmp
;
17670 pop_omp_privatization_clauses (r
);
17674 r
= RECUR (OMP_DEPOBJ_DEPOBJ (t
));
17675 if (OMP_DEPOBJ_CLAUSES (t
) && OMP_DEPOBJ_CLAUSES (t
) != error_mark_node
)
17677 enum omp_clause_depend_kind kind
= OMP_CLAUSE_DEPEND_SOURCE
;
17678 if (TREE_CODE (OMP_DEPOBJ_CLAUSES (t
)) == OMP_CLAUSE
)
17680 tmp
= tsubst_omp_clauses (OMP_DEPOBJ_CLAUSES (t
), C_ORT_OMP
,
17681 args
, complain
, in_decl
);
17682 if (tmp
== NULL_TREE
)
17683 tmp
= error_mark_node
;
17687 kind
= (enum omp_clause_depend_kind
)
17688 tree_to_uhwi (OMP_DEPOBJ_CLAUSES (t
));
17691 finish_omp_depobj (EXPR_LOCATION (t
), r
, kind
, tmp
);
17694 finish_omp_depobj (EXPR_LOCATION (t
), r
,
17695 OMP_CLAUSE_DEPEND_SOURCE
,
17696 OMP_DEPOBJ_CLAUSES (t
));
17700 case OMP_TARGET_DATA
:
17702 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), (TREE_CODE (t
) == OACC_DATA
)
17703 ? C_ORT_ACC
: C_ORT_OMP
, args
, complain
,
17705 keep_next_level (true);
17706 stmt
= begin_omp_structured_block ();
17708 RECUR (OMP_BODY (t
));
17709 stmt
= finish_omp_structured_block (stmt
);
17712 OMP_BODY (t
) = stmt
;
17713 OMP_CLAUSES (t
) = tmp
;
17714 if (TREE_CODE (t
) == OMP_TARGET
&& OMP_TARGET_COMBINED (t
))
17716 tree teams
= cp_walk_tree (&stmt
, tsubst_find_omp_teams
, NULL
, NULL
);
17719 /* For combined target teams, ensure the num_teams and
17720 thread_limit clause expressions are evaluated on the host,
17721 before entering the target construct. */
17723 for (c
= OMP_TEAMS_CLAUSES (teams
);
17724 c
; c
= OMP_CLAUSE_CHAIN (c
))
17725 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
17726 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
17727 && TREE_CODE (OMP_CLAUSE_OPERAND (c
, 0)) != INTEGER_CST
)
17729 tree expr
= OMP_CLAUSE_OPERAND (c
, 0);
17730 expr
= force_target_expr (TREE_TYPE (expr
), expr
, tf_none
);
17731 if (expr
== error_mark_node
)
17733 tmp
= TARGET_EXPR_SLOT (expr
);
17735 OMP_CLAUSE_OPERAND (c
, 0) = expr
;
17736 tree tc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
17737 OMP_CLAUSE_FIRSTPRIVATE
);
17738 OMP_CLAUSE_DECL (tc
) = tmp
;
17739 OMP_CLAUSE_CHAIN (tc
) = OMP_TARGET_CLAUSES (t
);
17740 OMP_TARGET_CLAUSES (t
) = tc
;
17749 tmp
= tsubst_omp_clauses (OACC_DECLARE_CLAUSES (t
), C_ORT_ACC
, args
,
17750 complain
, in_decl
);
17751 OACC_DECLARE_CLAUSES (t
) = tmp
;
17755 case OMP_TARGET_UPDATE
:
17756 case OMP_TARGET_ENTER_DATA
:
17757 case OMP_TARGET_EXIT_DATA
:
17758 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_OMP
, args
,
17759 complain
, in_decl
);
17761 OMP_STANDALONE_CLAUSES (t
) = tmp
;
17765 case OACC_ENTER_DATA
:
17766 case OACC_EXIT_DATA
:
17768 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_ACC
, args
,
17769 complain
, in_decl
);
17771 OMP_STANDALONE_CLAUSES (t
) = tmp
;
17776 tmp
= tsubst_omp_clauses (OMP_ORDERED_CLAUSES (t
), C_ORT_OMP
, args
,
17777 complain
, in_decl
);
17778 stmt
= push_stmt_list ();
17779 RECUR (OMP_BODY (t
));
17780 stmt
= pop_stmt_list (stmt
);
17783 OMP_BODY (t
) = stmt
;
17784 OMP_ORDERED_CLAUSES (t
) = tmp
;
17790 stmt
= push_stmt_list ();
17791 RECUR (OMP_BODY (t
));
17792 stmt
= pop_stmt_list (stmt
);
17795 OMP_BODY (t
) = stmt
;
17800 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
17802 if (TREE_CODE (TREE_OPERAND (t
, 0)) == OMP_CLAUSE
)
17803 tmp
= tsubst_omp_clauses (TREE_OPERAND (t
, 0), C_ORT_OMP
, args
,
17804 complain
, in_decl
);
17805 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
17807 tree op1
= TREE_OPERAND (t
, 1);
17808 tree rhs1
= NULL_TREE
;
17810 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
17812 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
17813 op1
= TREE_OPERAND (op1
, 1);
17815 lhs
= RECUR (TREE_OPERAND (op1
, 0));
17816 rhs
= RECUR (TREE_OPERAND (op1
, 1));
17817 finish_omp_atomic (EXPR_LOCATION (t
), OMP_ATOMIC
, TREE_CODE (op1
),
17818 lhs
, rhs
, NULL_TREE
, NULL_TREE
, rhs1
, tmp
,
17819 OMP_ATOMIC_MEMORY_ORDER (t
));
17823 tree op1
= TREE_OPERAND (t
, 1);
17824 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
17825 tree rhs1
= NULL_TREE
;
17826 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
17827 enum tree_code opcode
= NOP_EXPR
;
17828 if (code
== OMP_ATOMIC_READ
)
17830 v
= RECUR (TREE_OPERAND (op1
, 0));
17831 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
17833 else if (code
== OMP_ATOMIC_CAPTURE_OLD
17834 || code
== OMP_ATOMIC_CAPTURE_NEW
)
17836 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
17837 v
= RECUR (TREE_OPERAND (op1
, 0));
17838 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
17839 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
17841 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
17842 op11
= TREE_OPERAND (op11
, 1);
17844 lhs
= RECUR (TREE_OPERAND (op11
, 0));
17845 rhs
= RECUR (TREE_OPERAND (op11
, 1));
17846 opcode
= TREE_CODE (op11
);
17847 if (opcode
== MODIFY_EXPR
)
17853 lhs
= RECUR (TREE_OPERAND (op1
, 0));
17854 rhs
= RECUR (TREE_OPERAND (op1
, 1));
17856 finish_omp_atomic (EXPR_LOCATION (t
), code
, opcode
, lhs
, rhs
, v
,
17857 lhs1
, rhs1
, tmp
, OMP_ATOMIC_MEMORY_ORDER (t
));
17861 case TRANSACTION_EXPR
:
17864 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
17865 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
17867 if (TRANSACTION_EXPR_IS_STMT (t
))
17869 tree body
= TRANSACTION_EXPR_BODY (t
);
17870 tree noex
= NULL_TREE
;
17871 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
17873 noex
= MUST_NOT_THROW_COND (body
);
17874 if (noex
== NULL_TREE
)
17875 noex
= boolean_true_node
;
17876 body
= TREE_OPERAND (body
, 0);
17878 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
17880 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
17884 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
17885 RECUR (TRANSACTION_EXPR_BODY (t
)),
17892 case MUST_NOT_THROW_EXPR
:
17894 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17895 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
17896 RETURN (build_must_not_throw_expr (op0
, cond
));
17899 case EXPR_PACK_EXPANSION
:
17900 error ("invalid use of pack expansion expression");
17901 RETURN (error_mark_node
);
17903 case NONTYPE_ARGUMENT_PACK
:
17904 error ("use %<...%> to expand argument pack");
17905 RETURN (error_mark_node
);
17907 case COMPOUND_EXPR
:
17908 tmp
= RECUR (TREE_OPERAND (t
, 0));
17909 if (tmp
== NULL_TREE
)
17910 /* If the first operand was a statement, we're done with it. */
17911 RETURN (RECUR (TREE_OPERAND (t
, 1)));
17912 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
17913 RECUR (TREE_OPERAND (t
, 1)),
17916 case ANNOTATE_EXPR
:
17917 tmp
= RECUR (TREE_OPERAND (t
, 0));
17918 RETURN (build3_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
17919 TREE_TYPE (tmp
), tmp
,
17920 RECUR (TREE_OPERAND (t
, 1)),
17921 RECUR (TREE_OPERAND (t
, 2))));
17924 RETURN (add_stmt (copy_node (t
)));
17927 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
17929 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
17930 /*function_p=*/false,
17931 integral_constant_expression_p
));
17934 RETURN (NULL_TREE
);
17936 input_location
= loc
;
17942 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
17943 function. For description of the body see comment above
17944 cp_parser_omp_declare_reduction_exprs. */
17947 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
17949 if (t
== NULL_TREE
|| t
== error_mark_node
)
17952 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
17954 tree_stmt_iterator tsi
;
17957 memset (stmts
, 0, sizeof stmts
);
17958 for (i
= 0, tsi
= tsi_start (t
);
17959 i
< 7 && !tsi_end_p (tsi
);
17960 i
++, tsi_next (&tsi
))
17961 stmts
[i
] = tsi_stmt (tsi
);
17962 gcc_assert (tsi_end_p (tsi
));
17966 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
17967 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
17968 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
17969 args
, complain
, in_decl
);
17970 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
17971 args
, complain
, in_decl
);
17972 DECL_CONTEXT (omp_out
) = current_function_decl
;
17973 DECL_CONTEXT (omp_in
) = current_function_decl
;
17974 keep_next_level (true);
17975 tree block
= begin_omp_structured_block ();
17976 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
17977 block
= finish_omp_structured_block (block
);
17978 block
= maybe_cleanup_point_expr_void (block
);
17979 add_decl_expr (omp_out
);
17980 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
17981 TREE_NO_WARNING (omp_out
) = 1;
17982 add_decl_expr (omp_in
);
17983 finish_expr_stmt (block
);
17987 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
17988 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
17989 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
17990 args
, complain
, in_decl
);
17991 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
17992 args
, complain
, in_decl
);
17993 DECL_CONTEXT (omp_priv
) = current_function_decl
;
17994 DECL_CONTEXT (omp_orig
) = current_function_decl
;
17995 keep_next_level (true);
17996 tree block
= begin_omp_structured_block ();
17997 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
17998 block
= finish_omp_structured_block (block
);
17999 block
= maybe_cleanup_point_expr_void (block
);
18000 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
18001 add_decl_expr (omp_priv
);
18002 add_decl_expr (omp_orig
);
18003 finish_expr_stmt (block
);
18005 add_decl_expr (omp_orig
);
18009 /* T is a postfix-expression that is not being used in a function
18010 call. Return the substituted version of T. */
18013 tsubst_non_call_postfix_expression (tree t
, tree args
,
18014 tsubst_flags_t complain
,
18017 if (TREE_CODE (t
) == SCOPE_REF
)
18018 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
18019 /*done=*/false, /*address_p=*/false);
18021 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
18022 /*function_p=*/false,
18023 /*integral_constant_expression_p=*/false);
18028 /* T is a LAMBDA_EXPR. Generate a new LAMBDA_EXPR for the current
18029 instantiation context. Instantiating a pack expansion containing a lambda
18030 might result in multiple lambdas all based on the same lambda in the
18034 tsubst_lambda_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
18036 tree oldfn
= lambda_function (t
);
18039 /* If we have already specialized this lambda expr, reuse it. See
18041 if (local_specializations
)
18042 if (tree r
= retrieve_local_specialization (t
))
18045 tree r
= build_lambda_expr ();
18047 if (local_specializations
)
18048 register_local_specialization (r
, t
);
18050 LAMBDA_EXPR_LOCATION (r
)
18051 = LAMBDA_EXPR_LOCATION (t
);
18052 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
18053 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
18054 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
18055 LAMBDA_EXPR_INSTANTIATED (r
) = true;
18057 if (LAMBDA_EXPR_EXTRA_SCOPE (t
) == NULL_TREE
)
18058 /* A lambda in a default argument outside a class gets no
18059 LAMBDA_EXPR_EXTRA_SCOPE, as specified by the ABI. But
18060 tsubst_default_argument calls start_lambda_scope, so we need to
18061 specifically ignore it here, and use the global scope. */
18062 record_null_lambda_scope (r
);
18064 record_lambda_scope (r
);
18066 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
18067 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
18069 vec
<tree
,va_gc
>* field_packs
= NULL
;
18071 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
); cap
;
18072 cap
= TREE_CHAIN (cap
))
18074 tree ofield
= TREE_PURPOSE (cap
);
18075 if (PACK_EXPANSION_P (ofield
))
18076 ofield
= PACK_EXPANSION_PATTERN (ofield
);
18077 tree field
= tsubst_decl (ofield
, args
, complain
);
18079 if (DECL_PACK_P (ofield
) && !DECL_NORMAL_CAPTURE_P (ofield
))
18081 /* Remember these for when we've pushed local_specializations. */
18082 vec_safe_push (field_packs
, ofield
);
18083 vec_safe_push (field_packs
, field
);
18086 if (field
== error_mark_node
)
18087 return error_mark_node
;
18089 tree init
= TREE_VALUE (cap
);
18090 if (PACK_EXPANSION_P (init
))
18091 init
= tsubst_pack_expansion (init
, args
, complain
, in_decl
);
18093 init
= tsubst_copy_and_build (init
, args
, complain
, in_decl
,
18094 /*fn*/false, /*constexpr*/false);
18096 if (TREE_CODE (field
) == TREE_VEC
)
18098 int len
= TREE_VEC_LENGTH (field
);
18099 gcc_assert (TREE_CODE (init
) == TREE_VEC
18100 && TREE_VEC_LENGTH (init
) == len
);
18101 for (int i
= 0; i
< len
; ++i
)
18102 LAMBDA_EXPR_CAPTURE_LIST (r
)
18103 = tree_cons (TREE_VEC_ELT (field
, i
),
18104 TREE_VEC_ELT (init
, i
),
18105 LAMBDA_EXPR_CAPTURE_LIST (r
));
18109 LAMBDA_EXPR_CAPTURE_LIST (r
)
18110 = tree_cons (field
, init
, LAMBDA_EXPR_CAPTURE_LIST (r
));
18112 if (id_equal (DECL_NAME (field
), "__this"))
18113 LAMBDA_EXPR_THIS_CAPTURE (r
) = field
;
18117 tree type
= begin_lambda_type (r
);
18118 if (type
== error_mark_node
)
18119 return error_mark_node
;
18121 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
18122 determine_visibility (TYPE_NAME (type
));
18124 register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (r
));
18126 tree oldtmpl
= (generic_lambda_fn_p (oldfn
)
18127 ? DECL_TI_TEMPLATE (oldfn
)
18130 tree fntype
= static_fn_type (oldfn
);
18132 ++processing_template_decl
;
18133 fntype
= tsubst (fntype
, args
, complain
, in_decl
);
18135 --processing_template_decl
;
18137 if (fntype
== error_mark_node
)
18138 r
= error_mark_node
;
18141 /* The body of a lambda-expression is not a subexpression of the
18142 enclosing expression. Parms are to have DECL_CHAIN tsubsted,
18143 which would be skipped if cp_unevaluated_operand. */
18146 /* Fix the type of 'this'. */
18147 fntype
= build_memfn_type (fntype
, type
,
18148 type_memfn_quals (fntype
),
18149 type_memfn_rqual (fntype
));
18153 tmpl
= tsubst_template_decl (oldtmpl
, args
, complain
, fntype
);
18154 fn
= DECL_TEMPLATE_RESULT (tmpl
);
18155 finish_member_declaration (tmpl
);
18160 fn
= tsubst_function_decl (oldfn
, args
, complain
, fntype
);
18161 finish_member_declaration (fn
);
18164 /* Let finish_function set this. */
18165 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
18167 bool nested
= cfun
;
18169 push_function_context ();
18171 /* Still increment function_depth so that we don't GC in the
18172 middle of an expression. */
18175 local_specialization_stack
s (lss_copy
);
18177 tree body
= start_lambda_function (fn
, r
);
18179 /* Now record them for lookup_init_capture_pack. */
18180 int fplen
= vec_safe_length (field_packs
);
18181 for (int i
= 0; i
< fplen
; )
18183 tree pack
= (*field_packs
)[i
++];
18184 tree inst
= (*field_packs
)[i
++];
18185 register_local_specialization (inst
, pack
);
18187 release_tree_vector (field_packs
);
18189 register_parameter_specializations (oldfn
, fn
);
18193 /* We might not partially instantiate some parts of the function, so
18194 copy these flags from the original template. */
18195 language_function
*ol
= DECL_STRUCT_FUNCTION (oldfn
)->language
;
18196 current_function_returns_value
= ol
->returns_value
;
18197 current_function_returns_null
= ol
->returns_null
;
18198 current_function_returns_abnormally
= ol
->returns_abnormally
;
18199 current_function_infinite_loop
= ol
->infinite_loop
;
18202 /* [temp.deduct] A lambda-expression appearing in a function type or a
18203 template parameter is not considered part of the immediate context for
18204 the purposes of template argument deduction. */
18205 complain
= tf_warning_or_error
;
18207 tsubst_expr (DECL_SAVED_TREE (oldfn
), args
, complain
, r
,
18208 /*constexpr*/false);
18210 finish_lambda_function (body
);
18213 pop_function_context ();
18217 /* The capture list was built up in reverse order; fix that now. */
18218 LAMBDA_EXPR_CAPTURE_LIST (r
)
18219 = nreverse (LAMBDA_EXPR_CAPTURE_LIST (r
));
18221 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
18223 maybe_add_lambda_conv_op (type
);
18226 finish_struct (type
, /*attr*/NULL_TREE
);
18228 insert_pending_capture_proxies ();
18233 /* Like tsubst but deals with expressions and performs semantic
18234 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
18237 tsubst_copy_and_build (tree t
,
18239 tsubst_flags_t complain
,
18242 bool integral_constant_expression_p
)
18244 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
18245 #define RECUR(NODE) \
18246 tsubst_copy_and_build (NODE, args, complain, in_decl, \
18247 /*function_p=*/false, \
18248 integral_constant_expression_p)
18253 if (t
== NULL_TREE
|| t
== error_mark_node
)
18256 loc
= input_location
;
18257 if (location_t eloc
= cp_expr_location (t
))
18258 input_location
= eloc
;
18260 /* N3276 decltype magic only applies to calls at the top level or on the
18261 right side of a comma. */
18262 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
18263 complain
&= ~tf_decltype
;
18265 switch (TREE_CODE (t
))
18269 /* Fall through. */
18270 case IDENTIFIER_NODE
:
18274 bool non_integral_constant_expression_p
;
18275 const char *error_msg
;
18277 if (IDENTIFIER_CONV_OP_P (t
))
18279 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18280 t
= make_conv_op_name (new_type
);
18283 /* Look up the name. */
18284 decl
= lookup_name (t
);
18286 /* By convention, expressions use ERROR_MARK_NODE to indicate
18287 failure, not NULL_TREE. */
18288 if (decl
== NULL_TREE
)
18289 decl
= error_mark_node
;
18291 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
18293 integral_constant_expression_p
,
18294 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
18295 &non_integral_constant_expression_p
,
18296 /*template_p=*/false,
18298 /*address_p=*/false,
18299 /*template_arg_p=*/false,
18304 if (!function_p
&& identifier_p (decl
))
18306 if (complain
& tf_error
)
18307 unqualified_name_lookup_error (decl
);
18308 decl
= error_mark_node
;
18313 case TEMPLATE_ID_EXPR
:
18316 tree templ
= RECUR (TREE_OPERAND (t
, 0));
18317 tree targs
= TREE_OPERAND (t
, 1);
18320 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
18321 if (targs
== error_mark_node
)
18322 RETURN (error_mark_node
);
18324 if (TREE_CODE (templ
) == SCOPE_REF
)
18326 tree name
= TREE_OPERAND (templ
, 1);
18327 tree tid
= lookup_template_function (name
, targs
);
18328 TREE_OPERAND (templ
, 1) = tid
;
18332 if (variable_template_p (templ
))
18333 RETURN (lookup_and_finish_template_variable (templ
, targs
, complain
));
18335 if (TREE_CODE (templ
) == COMPONENT_REF
)
18337 object
= TREE_OPERAND (templ
, 0);
18338 templ
= TREE_OPERAND (templ
, 1);
18341 object
= NULL_TREE
;
18342 templ
= lookup_template_function (templ
, targs
);
18345 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
18346 object
, templ
, NULL_TREE
));
18348 RETURN (baselink_for_fns (templ
));
18353 tree r
= RECUR (TREE_OPERAND (t
, 0));
18355 if (REFERENCE_REF_P (t
))
18357 /* A type conversion to reference type will be enclosed in
18358 such an indirect ref, but the substitution of the cast
18359 will have also added such an indirect ref. */
18360 r
= convert_from_reference (r
);
18363 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
18364 complain
|decltype_flag
);
18366 if (REF_PARENTHESIZED_P (t
))
18367 r
= force_paren_expr (r
);
18374 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18375 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18376 RETURN (build_nop (type
, op0
));
18379 case IMPLICIT_CONV_EXPR
:
18381 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18382 tree expr
= RECUR (TREE_OPERAND (t
, 0));
18383 if (dependent_type_p (type
) || type_dependent_expression_p (expr
))
18385 retval
= copy_node (t
);
18386 TREE_TYPE (retval
) = type
;
18387 TREE_OPERAND (retval
, 0) = expr
;
18390 if (IMPLICIT_CONV_EXPR_NONTYPE_ARG (t
))
18391 /* We'll pass this to convert_nontype_argument again, we don't need
18392 to actually perform any conversion here. */
18394 int flags
= LOOKUP_IMPLICIT
;
18395 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
18396 flags
= LOOKUP_NORMAL
;
18397 if (IMPLICIT_CONV_EXPR_BRACED_INIT (t
))
18398 flags
|= LOOKUP_NO_NARROWING
;
18399 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
18405 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18406 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18407 if (op0
== error_mark_node
)
18408 RETURN (error_mark_node
);
18409 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
18413 case REINTERPRET_CAST_EXPR
:
18414 case CONST_CAST_EXPR
:
18415 case DYNAMIC_CAST_EXPR
:
18416 case STATIC_CAST_EXPR
:
18419 tree op
, r
= NULL_TREE
;
18421 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18422 if (integral_constant_expression_p
18423 && !cast_valid_in_integral_constant_expression_p (type
))
18425 if (complain
& tf_error
)
18426 error ("a cast to a type other than an integral or "
18427 "enumeration type cannot appear in a constant-expression");
18428 RETURN (error_mark_node
);
18431 op
= RECUR (TREE_OPERAND (t
, 0));
18433 warning_sentinel
s(warn_useless_cast
);
18434 warning_sentinel
s2(warn_ignored_qualifiers
);
18435 switch (TREE_CODE (t
))
18438 r
= build_functional_cast (type
, op
, complain
);
18440 case REINTERPRET_CAST_EXPR
:
18441 r
= build_reinterpret_cast (type
, op
, complain
);
18443 case CONST_CAST_EXPR
:
18444 r
= build_const_cast (type
, op
, complain
);
18446 case DYNAMIC_CAST_EXPR
:
18447 r
= build_dynamic_cast (type
, op
, complain
);
18449 case STATIC_CAST_EXPR
:
18450 r
= build_static_cast (type
, op
, complain
);
18453 gcc_unreachable ();
18459 case POSTDECREMENT_EXPR
:
18460 case POSTINCREMENT_EXPR
:
18461 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
18462 args
, complain
, in_decl
);
18463 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
18464 complain
|decltype_flag
));
18466 case PREDECREMENT_EXPR
:
18467 case PREINCREMENT_EXPR
:
18471 case TRUTH_NOT_EXPR
:
18472 case UNARY_PLUS_EXPR
: /* Unary + */
18473 case REALPART_EXPR
:
18474 case IMAGPART_EXPR
:
18475 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
18476 RECUR (TREE_OPERAND (t
, 0)),
18477 complain
|decltype_flag
));
18479 case FIX_TRUNC_EXPR
:
18480 gcc_unreachable ();
18483 op1
= TREE_OPERAND (t
, 0);
18484 if (TREE_CODE (op1
) == LABEL_DECL
)
18485 RETURN (finish_label_address_expr (DECL_NAME (op1
),
18486 EXPR_LOCATION (op1
)));
18487 if (TREE_CODE (op1
) == SCOPE_REF
)
18488 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
18489 /*done=*/true, /*address_p=*/true);
18491 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
18493 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
18494 complain
|decltype_flag
));
18499 case TRUNC_DIV_EXPR
:
18500 case CEIL_DIV_EXPR
:
18501 case FLOOR_DIV_EXPR
:
18502 case ROUND_DIV_EXPR
:
18503 case EXACT_DIV_EXPR
:
18507 case TRUNC_MOD_EXPR
:
18508 case FLOOR_MOD_EXPR
:
18509 case TRUTH_ANDIF_EXPR
:
18510 case TRUTH_ORIF_EXPR
:
18511 case TRUTH_AND_EXPR
:
18512 case TRUTH_OR_EXPR
:
18528 warning_sentinel
s1(warn_type_limits
);
18529 warning_sentinel
s2(warn_div_by_zero
);
18530 warning_sentinel
s3(warn_logical_op
);
18531 warning_sentinel
s4(warn_tautological_compare
);
18532 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18533 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18534 tree r
= build_x_binary_op
18535 (input_location
, TREE_CODE (t
),
18537 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
18539 : TREE_CODE (TREE_OPERAND (t
, 0))),
18541 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
18543 : TREE_CODE (TREE_OPERAND (t
, 1))),
18545 complain
|decltype_flag
);
18546 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
18547 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
18552 case POINTER_PLUS_EXPR
:
18554 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18555 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18556 RETURN (fold_build_pointer_plus (op0
, op1
));
18560 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
18561 /*address_p=*/false));
18563 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
18564 args
, complain
, in_decl
);
18565 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
18566 RECUR (TREE_OPERAND (t
, 1)),
18567 complain
|decltype_flag
));
18570 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
18571 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
18572 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
18579 op1
= TREE_OPERAND (t
, 0);
18580 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
18581 op1
= TREE_TYPE (op1
);
18582 bool std_alignof
= (TREE_CODE (t
) == ALIGNOF_EXPR
18583 && ALIGNOF_EXPR_STD_P (t
));
18586 /* When there are no ARGS, we are trying to evaluate a
18587 non-dependent expression from the parser. Trying to do
18588 the substitutions may not work. */
18590 op1
= TREE_TYPE (op1
);
18594 ++cp_unevaluated_operand
;
18595 ++c_inhibit_evaluation_warnings
;
18597 op1
= tsubst (op1
, args
, complain
, in_decl
);
18599 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
18600 /*function_p=*/false,
18601 /*integral_constant_expression_p=*/
18603 --cp_unevaluated_operand
;
18604 --c_inhibit_evaluation_warnings
;
18607 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
), std_alignof
,
18608 complain
& tf_error
);
18610 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
18611 complain
& tf_error
);
18612 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
18614 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
18616 if (!processing_template_decl
&& TYPE_P (op1
))
18618 r
= build_min (SIZEOF_EXPR
, size_type_node
,
18619 build1 (NOP_EXPR
, op1
, error_mark_node
));
18620 SIZEOF_EXPR_TYPE_P (r
) = 1;
18623 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
18624 TREE_SIDE_EFFECTS (r
) = 0;
18625 TREE_READONLY (r
) = 1;
18627 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
18632 case AT_ENCODE_EXPR
:
18634 op1
= TREE_OPERAND (t
, 0);
18635 ++cp_unevaluated_operand
;
18636 ++c_inhibit_evaluation_warnings
;
18637 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
18638 /*function_p=*/false,
18639 /*integral_constant_expression_p=*/false);
18640 --cp_unevaluated_operand
;
18641 --c_inhibit_evaluation_warnings
;
18642 RETURN (objc_build_encode_expr (op1
));
18645 case NOEXCEPT_EXPR
:
18646 op1
= TREE_OPERAND (t
, 0);
18647 ++cp_unevaluated_operand
;
18648 ++c_inhibit_evaluation_warnings
;
18649 ++cp_noexcept_operand
;
18650 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
18651 /*function_p=*/false,
18652 /*integral_constant_expression_p=*/false);
18653 --cp_unevaluated_operand
;
18654 --c_inhibit_evaluation_warnings
;
18655 --cp_noexcept_operand
;
18656 RETURN (finish_noexcept_expr (op1
, complain
));
18660 warning_sentinel
s(warn_div_by_zero
);
18661 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
18662 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
18663 tree r
= build_x_modify_expr
18664 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
18665 complain
|decltype_flag
);
18666 /* TREE_NO_WARNING must be set if either the expression was
18667 parenthesized or it uses an operator such as >>= rather
18668 than plain assignment. In the former case, it was already
18669 set and must be copied. In the latter case,
18670 build_x_modify_expr sets it and it must not be reset
18672 if (TREE_NO_WARNING (t
))
18673 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
18679 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
18680 args
, complain
, in_decl
);
18681 /* Remember that there was a reference to this entity. */
18683 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
18684 RETURN (error_mark_node
);
18685 RETURN (build_x_arrow (input_location
, op1
, complain
));
18689 tree placement
= RECUR (TREE_OPERAND (t
, 0));
18690 tree init
= RECUR (TREE_OPERAND (t
, 3));
18691 vec
<tree
, va_gc
> *placement_vec
;
18692 vec
<tree
, va_gc
> *init_vec
;
18695 if (placement
== NULL_TREE
)
18696 placement_vec
= NULL
;
18699 placement_vec
= make_tree_vector ();
18700 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
18701 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
18704 /* If there was an initializer in the original tree, but it
18705 instantiated to an empty list, then we should pass a
18706 non-NULL empty vector to tell build_new that it was an
18707 empty initializer() rather than no initializer. This can
18708 only happen when the initializer is a pack expansion whose
18709 parameter packs are of length zero. */
18710 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
18714 init_vec
= make_tree_vector ();
18715 if (init
== void_node
)
18716 gcc_assert (init_vec
!= NULL
);
18719 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
18720 vec_safe_push (init_vec
, TREE_VALUE (init
));
18724 /* Avoid passing an enclosing decl to valid_array_size_p. */
18725 in_decl
= NULL_TREE
;
18727 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
18728 tree op2
= RECUR (TREE_OPERAND (t
, 2));
18729 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
18730 NEW_EXPR_USE_GLOBAL (t
),
18733 if (placement_vec
!= NULL
)
18734 release_tree_vector (placement_vec
);
18735 if (init_vec
!= NULL
)
18736 release_tree_vector (init_vec
);
18743 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18744 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18745 RETURN (delete_sanity (op0
, op1
,
18746 DELETE_EXPR_USE_VEC (t
),
18747 DELETE_EXPR_USE_GLOBAL (t
),
18751 case COMPOUND_EXPR
:
18753 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
18754 complain
& ~tf_decltype
, in_decl
,
18755 /*function_p=*/false,
18756 integral_constant_expression_p
);
18757 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
18759 RECUR (TREE_OPERAND (t
, 1)),
18760 complain
|decltype_flag
));
18766 unsigned int nargs
, i
;
18771 function
= CALL_EXPR_FN (t
);
18772 /* Internal function with no arguments. */
18773 if (function
== NULL_TREE
&& call_expr_nargs (t
) == 0)
18776 /* When we parsed the expression, we determined whether or
18777 not Koenig lookup should be performed. */
18778 koenig_p
= KOENIG_LOOKUP_P (t
);
18779 if (function
== NULL_TREE
)
18782 qualified_p
= false;
18784 else if (TREE_CODE (function
) == SCOPE_REF
)
18786 qualified_p
= true;
18787 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
18789 /*address_p=*/false);
18791 else if (koenig_p
&& identifier_p (function
))
18793 /* Do nothing; calling tsubst_copy_and_build on an identifier
18794 would incorrectly perform unqualified lookup again.
18796 Note that we can also have an IDENTIFIER_NODE if the earlier
18797 unqualified lookup found a member function; in that case
18798 koenig_p will be false and we do want to do the lookup
18799 again to find the instantiated member function.
18801 FIXME but doing that causes c++/15272, so we need to stop
18802 using IDENTIFIER_NODE in that situation. */
18803 qualified_p
= false;
18807 if (TREE_CODE (function
) == COMPONENT_REF
)
18809 tree op
= TREE_OPERAND (function
, 1);
18811 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
18812 || (BASELINK_P (op
)
18813 && BASELINK_QUALIFIED_P (op
)));
18816 qualified_p
= false;
18818 if (TREE_CODE (function
) == ADDR_EXPR
18819 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
18820 /* Avoid error about taking the address of a constructor. */
18821 function
= TREE_OPERAND (function
, 0);
18823 function
= tsubst_copy_and_build (function
, args
, complain
,
18826 integral_constant_expression_p
);
18828 if (BASELINK_P (function
))
18829 qualified_p
= true;
18832 nargs
= call_expr_nargs (t
);
18833 releasing_vec call_args
;
18834 for (i
= 0; i
< nargs
; ++i
)
18836 tree arg
= CALL_EXPR_ARG (t
, i
);
18838 if (!PACK_EXPANSION_P (arg
))
18839 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
18842 /* Expand the pack expansion and push each entry onto
18844 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
18845 if (TREE_CODE (arg
) == TREE_VEC
)
18847 unsigned int len
, j
;
18849 len
= TREE_VEC_LENGTH (arg
);
18850 for (j
= 0; j
< len
; ++j
)
18852 tree value
= TREE_VEC_ELT (arg
, j
);
18853 if (value
!= NULL_TREE
)
18854 value
= convert_from_reference (value
);
18855 vec_safe_push (call_args
, value
);
18860 /* A partial substitution. Add one entry. */
18861 vec_safe_push (call_args
, arg
);
18866 /* Stripped-down processing for a call in a thunk. Specifically, in
18867 the thunk template for a generic lambda. */
18868 if (CALL_FROM_THUNK_P (t
))
18870 /* Now that we've expanded any packs, the number of call args
18871 might be different. */
18872 unsigned int cargs
= call_args
->length ();
18873 tree thisarg
= NULL_TREE
;
18874 if (TREE_CODE (function
) == COMPONENT_REF
)
18876 thisarg
= TREE_OPERAND (function
, 0);
18877 if (TREE_CODE (thisarg
) == INDIRECT_REF
)
18878 thisarg
= TREE_OPERAND (thisarg
, 0);
18879 function
= TREE_OPERAND (function
, 1);
18880 if (TREE_CODE (function
) == BASELINK
)
18881 function
= BASELINK_FUNCTIONS (function
);
18883 /* We aren't going to do normal overload resolution, so force the
18884 template-id to resolve. */
18885 function
= resolve_nondeduced_context (function
, complain
);
18886 for (unsigned i
= 0; i
< cargs
; ++i
)
18888 /* In a thunk, pass through args directly, without any
18890 tree arg
= (*call_args
)[i
];
18891 while (TREE_CODE (arg
) != PARM_DECL
)
18892 arg
= TREE_OPERAND (arg
, 0);
18893 (*call_args
)[i
] = arg
;
18897 /* If there are no other args, just push 'this'. */
18899 vec_safe_push (call_args
, thisarg
);
18902 /* Otherwise, shift the other args over to make room. */
18903 tree last
= (*call_args
)[cargs
- 1];
18904 vec_safe_push (call_args
, last
);
18905 for (int i
= cargs
- 1; i
> 0; --i
)
18906 (*call_args
)[i
] = (*call_args
)[i
- 1];
18907 (*call_args
)[0] = thisarg
;
18910 ret
= build_call_a (function
, call_args
->length (),
18911 call_args
->address ());
18912 /* The thunk location is not interesting. */
18913 SET_EXPR_LOCATION (ret
, UNKNOWN_LOCATION
);
18914 CALL_FROM_THUNK_P (ret
) = true;
18915 if (CLASS_TYPE_P (TREE_TYPE (ret
)))
18916 CALL_EXPR_RETURN_SLOT_OPT (ret
) = true;
18921 /* We do not perform argument-dependent lookup if normal
18922 lookup finds a non-function, in accordance with the
18923 expected resolution of DR 218. */
18925 && ((is_overloaded_fn (function
)
18926 /* If lookup found a member function, the Koenig lookup is
18927 not appropriate, even if an unqualified-name was used
18928 to denote the function. */
18929 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
18930 || identifier_p (function
))
18931 /* Only do this when substitution turns a dependent call
18932 into a non-dependent call. */
18933 && type_dependent_expression_p_push (t
)
18934 && !any_type_dependent_arguments_p (call_args
))
18935 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
18937 if (function
!= NULL_TREE
18938 && identifier_p (function
)
18939 && !any_type_dependent_arguments_p (call_args
))
18941 if (koenig_p
&& (complain
& tf_warning_or_error
))
18943 /* For backwards compatibility and good diagnostics, try
18944 the unqualified lookup again if we aren't in SFINAE
18946 tree unq
= (tsubst_copy_and_build
18947 (function
, args
, complain
, in_decl
, true,
18948 integral_constant_expression_p
));
18949 if (unq
== error_mark_node
)
18950 RETURN (error_mark_node
);
18952 if (unq
!= function
)
18954 /* In a lambda fn, we have to be careful to not
18955 introduce new this captures. Legacy code can't
18956 be using lambdas anyway, so it's ok to be
18958 bool in_lambda
= (current_class_type
18959 && LAMBDA_TYPE_P (current_class_type
));
18960 char const *const msg
18961 = G_("%qD was not declared in this scope, "
18962 "and no declarations were found by "
18963 "argument-dependent lookup at the point "
18964 "of instantiation");
18968 error_at (cp_expr_loc_or_loc (t
, input_location
),
18971 diag
= permerror (cp_expr_loc_or_loc (t
, input_location
),
18977 if (INDIRECT_REF_P (fn
))
18978 fn
= TREE_OPERAND (fn
, 0);
18979 if (is_overloaded_fn (fn
))
18980 fn
= get_first_fn (fn
);
18983 /* Can't say anything more. */;
18984 else if (DECL_CLASS_SCOPE_P (fn
))
18986 location_t loc
= cp_expr_loc_or_loc (t
,
18989 "declarations in dependent base %qT are "
18990 "not found by unqualified lookup",
18991 DECL_CLASS_CONTEXT (fn
));
18992 if (current_class_ptr
)
18994 "use %<this->%D%> instead", function
);
18997 "use %<%T::%D%> instead",
18998 current_class_name
, function
);
19001 inform (DECL_SOURCE_LOCATION (fn
),
19002 "%qD declared here, later in the "
19003 "translation unit", fn
);
19005 RETURN (error_mark_node
);
19011 if (identifier_p (function
))
19013 if (complain
& tf_error
)
19014 unqualified_name_lookup_error (function
);
19015 RETURN (error_mark_node
);
19019 /* Remember that there was a reference to this entity. */
19020 if (function
!= NULL_TREE
19021 && DECL_P (function
)
19022 && !mark_used (function
, complain
) && !(complain
& tf_error
))
19023 RETURN (error_mark_node
);
19025 /* Put back tf_decltype for the actual call. */
19026 complain
|= decltype_flag
;
19028 if (function
== NULL_TREE
)
19029 switch (CALL_EXPR_IFN (t
))
19032 gcc_assert (nargs
== 1);
19033 if (vec_safe_length (call_args
) != 1)
19035 error_at (cp_expr_loc_or_loc (t
, input_location
),
19036 "wrong number of arguments to "
19037 "%<__builtin_launder%>");
19038 ret
= error_mark_node
;
19041 ret
= finish_builtin_launder (cp_expr_loc_or_loc (t
,
19043 (*call_args
)[0], complain
);
19046 case IFN_VEC_CONVERT
:
19047 gcc_assert (nargs
== 1);
19048 if (vec_safe_length (call_args
) != 1)
19050 error_at (cp_expr_loc_or_loc (t
, input_location
),
19051 "wrong number of arguments to "
19052 "%<__builtin_convertvector%>");
19053 ret
= error_mark_node
;
19056 ret
= cp_build_vec_convert ((*call_args
)[0], input_location
,
19057 tsubst (TREE_TYPE (t
), args
,
19058 complain
, in_decl
),
19060 if (TREE_CODE (ret
) == VIEW_CONVERT_EXPR
)
19065 /* Unsupported internal function with arguments. */
19066 gcc_unreachable ();
19068 else if (TREE_CODE (function
) == OFFSET_REF
19069 || TREE_CODE (function
) == DOTSTAR_EXPR
19070 || TREE_CODE (function
) == MEMBER_REF
)
19071 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
19073 else if (TREE_CODE (function
) == COMPONENT_REF
)
19075 tree instance
= TREE_OPERAND (function
, 0);
19076 tree fn
= TREE_OPERAND (function
, 1);
19078 if (processing_template_decl
19079 && (type_dependent_expression_p (instance
)
19080 || (!BASELINK_P (fn
)
19081 && TREE_CODE (fn
) != FIELD_DECL
)
19082 || type_dependent_expression_p (fn
)
19083 || any_type_dependent_arguments_p (call_args
)))
19084 ret
= build_min_nt_call_vec (function
, call_args
);
19085 else if (!BASELINK_P (fn
))
19086 ret
= finish_call_expr (function
, &call_args
,
19087 /*disallow_virtual=*/false,
19088 /*koenig_p=*/false,
19091 ret
= (build_new_method_call
19093 &call_args
, NULL_TREE
,
19094 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
19099 ret
= finish_call_expr (function
, &call_args
,
19100 /*disallow_virtual=*/qualified_p
,
19104 if (ret
!= error_mark_node
)
19106 bool op
= CALL_EXPR_OPERATOR_SYNTAX (t
);
19107 bool ord
= CALL_EXPR_ORDERED_ARGS (t
);
19108 bool rev
= CALL_EXPR_REVERSE_ARGS (t
);
19109 if (op
|| ord
|| rev
)
19111 function
= extract_call_expr (ret
);
19112 CALL_EXPR_OPERATOR_SYNTAX (function
) = op
;
19113 CALL_EXPR_ORDERED_ARGS (function
) = ord
;
19114 CALL_EXPR_REVERSE_ARGS (function
) = rev
;
19123 tree cond
= RECUR (TREE_OPERAND (t
, 0));
19124 cond
= mark_rvalue_use (cond
);
19125 tree folded_cond
= fold_non_dependent_expr (cond
, complain
);
19128 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
19130 if (integer_zerop (folded_cond
))
19132 ++c_inhibit_evaluation_warnings
;
19133 exp1
= RECUR (TREE_OPERAND (t
, 1));
19134 --c_inhibit_evaluation_warnings
;
19135 exp2
= RECUR (TREE_OPERAND (t
, 2));
19139 exp1
= RECUR (TREE_OPERAND (t
, 1));
19140 ++c_inhibit_evaluation_warnings
;
19141 exp2
= RECUR (TREE_OPERAND (t
, 2));
19142 --c_inhibit_evaluation_warnings
;
19144 cond
= folded_cond
;
19148 exp1
= RECUR (TREE_OPERAND (t
, 1));
19149 exp2
= RECUR (TREE_OPERAND (t
, 2));
19152 warning_sentinel
s(warn_duplicated_branches
);
19153 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
19154 cond
, exp1
, exp2
, complain
));
19157 case PSEUDO_DTOR_EXPR
:
19159 tree op0
= RECUR (TREE_OPERAND (t
, 0));
19160 tree op1
= RECUR (TREE_OPERAND (t
, 1));
19161 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
19162 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
19168 tree purpose
, value
, chain
;
19170 if (t
== void_list_node
)
19173 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
19174 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
19176 /* We have pack expansions, so expand those and
19177 create a new list out of it. */
19178 tree purposevec
= NULL_TREE
;
19179 tree valuevec
= NULL_TREE
;
19183 /* Expand the argument expressions. */
19184 if (TREE_PURPOSE (t
))
19185 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
19186 complain
, in_decl
);
19187 if (TREE_VALUE (t
))
19188 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
19189 complain
, in_decl
);
19191 /* Build the rest of the list. */
19192 chain
= TREE_CHAIN (t
);
19193 if (chain
&& chain
!= void_type_node
)
19194 chain
= RECUR (chain
);
19196 /* Determine the number of arguments. */
19197 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
19199 len
= TREE_VEC_LENGTH (purposevec
);
19200 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
19202 else if (TREE_CODE (valuevec
) == TREE_VEC
)
19203 len
= TREE_VEC_LENGTH (valuevec
);
19206 /* Since we only performed a partial substitution into
19207 the argument pack, we only RETURN (a single list
19209 if (purposevec
== TREE_PURPOSE (t
)
19210 && valuevec
== TREE_VALUE (t
)
19211 && chain
== TREE_CHAIN (t
))
19214 RETURN (tree_cons (purposevec
, valuevec
, chain
));
19217 /* Convert the argument vectors into a TREE_LIST */
19221 /* Grab the Ith values. */
19223 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
19226 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
19229 /* Build the list (backwards). */
19230 chain
= tree_cons (purpose
, value
, chain
);
19236 purpose
= TREE_PURPOSE (t
);
19238 purpose
= RECUR (purpose
);
19239 value
= TREE_VALUE (t
);
19241 value
= RECUR (value
);
19242 chain
= TREE_CHAIN (t
);
19243 if (chain
&& chain
!= void_type_node
)
19244 chain
= RECUR (chain
);
19245 if (purpose
== TREE_PURPOSE (t
)
19246 && value
== TREE_VALUE (t
)
19247 && chain
== TREE_CHAIN (t
))
19249 RETURN (tree_cons (purpose
, value
, chain
));
19252 case COMPONENT_REF
:
19259 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
19260 args
, complain
, in_decl
);
19261 /* Remember that there was a reference to this entity. */
19262 if (DECL_P (object
)
19263 && !mark_used (object
, complain
) && !(complain
& tf_error
))
19264 RETURN (error_mark_node
);
19265 object_type
= TREE_TYPE (object
);
19267 member
= TREE_OPERAND (t
, 1);
19268 if (BASELINK_P (member
))
19269 member
= tsubst_baselink (member
,
19270 non_reference (TREE_TYPE (object
)),
19271 args
, complain
, in_decl
);
19273 member
= tsubst_copy (member
, args
, complain
, in_decl
);
19274 if (member
== error_mark_node
)
19275 RETURN (error_mark_node
);
19277 if (TREE_CODE (member
) == FIELD_DECL
)
19279 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
19280 if (TREE_CODE (r
) == COMPONENT_REF
)
19281 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
19284 else if (type_dependent_expression_p (object
))
19285 /* We can't do much here. */;
19286 else if (!CLASS_TYPE_P (object_type
))
19288 if (scalarish_type_p (object_type
))
19290 tree s
= NULL_TREE
;
19291 tree dtor
= member
;
19293 if (TREE_CODE (dtor
) == SCOPE_REF
)
19295 s
= TREE_OPERAND (dtor
, 0);
19296 dtor
= TREE_OPERAND (dtor
, 1);
19298 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
19300 dtor
= TREE_OPERAND (dtor
, 0);
19302 RETURN (finish_pseudo_destructor_expr
19303 (object
, s
, dtor
, input_location
));
19307 else if (TREE_CODE (member
) == SCOPE_REF
19308 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
19310 /* Lookup the template functions now that we know what the
19312 tree scope
= TREE_OPERAND (member
, 0);
19313 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
19314 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
19315 member
= lookup_qualified_name (scope
, tmpl
,
19316 /*is_type_p=*/false,
19317 /*complain=*/false);
19318 if (BASELINK_P (member
))
19320 BASELINK_FUNCTIONS (member
)
19321 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
19323 member
= (adjust_result_of_qualified_name_lookup
19324 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
19329 qualified_name_lookup_error (scope
, tmpl
, member
,
19331 RETURN (error_mark_node
);
19334 else if (TREE_CODE (member
) == SCOPE_REF
19335 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
19336 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
19338 if (complain
& tf_error
)
19340 if (TYPE_P (TREE_OPERAND (member
, 0)))
19341 error ("%qT is not a class or namespace",
19342 TREE_OPERAND (member
, 0));
19344 error ("%qD is not a class or namespace",
19345 TREE_OPERAND (member
, 0));
19347 RETURN (error_mark_node
);
19350 r
= finish_class_member_access_expr (object
, member
,
19351 /*template_p=*/false,
19353 if (TREE_CODE (r
) == COMPONENT_REF
)
19354 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
19359 RETURN (build_throw
19360 (RECUR (TREE_OPERAND (t
, 0))));
19364 vec
<constructor_elt
, va_gc
> *n
;
19365 constructor_elt
*ce
;
19366 unsigned HOST_WIDE_INT idx
;
19367 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
19368 bool process_index_p
;
19370 bool need_copy_p
= false;
19373 if (type
== error_mark_node
)
19374 RETURN (error_mark_node
);
19376 /* We do not want to process the index of aggregate
19377 initializers as they are identifier nodes which will be
19378 looked up by digest_init. */
19379 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
19381 if (null_member_pointer_value_p (t
))
19383 gcc_assert (same_type_p (type
, TREE_TYPE (t
)));
19387 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
19388 newlen
= vec_safe_length (n
);
19389 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
19391 if (ce
->index
&& process_index_p
19392 /* An identifier index is looked up in the type
19393 being initialized, not the current scope. */
19394 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
19395 ce
->index
= RECUR (ce
->index
);
19397 if (PACK_EXPANSION_P (ce
->value
))
19399 /* Substitute into the pack expansion. */
19400 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
19403 if (ce
->value
== error_mark_node
19404 || PACK_EXPANSION_P (ce
->value
))
19406 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
19407 /* Just move the argument into place. */
19408 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
19411 /* Update the length of the final CONSTRUCTOR
19412 arguments vector, and note that we will need to
19414 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
19415 need_copy_p
= true;
19419 ce
->value
= RECUR (ce
->value
);
19424 vec
<constructor_elt
, va_gc
> *old_n
= n
;
19426 vec_alloc (n
, newlen
);
19427 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
19429 if (TREE_CODE (ce
->value
) == TREE_VEC
)
19431 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
19432 for (i
= 0; i
< len
; ++i
)
19433 CONSTRUCTOR_APPEND_ELT (n
, 0,
19434 TREE_VEC_ELT (ce
->value
, i
));
19437 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
19441 r
= build_constructor (init_list_type_node
, n
);
19442 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
19443 CONSTRUCTOR_IS_DESIGNATED_INIT (r
)
19444 = CONSTRUCTOR_IS_DESIGNATED_INIT (t
);
19446 if (TREE_HAS_CONSTRUCTOR (t
))
19448 fcl_t cl
= fcl_functional
;
19449 if (CONSTRUCTOR_C99_COMPOUND_LITERAL (t
))
19451 RETURN (finish_compound_literal (type
, r
, complain
, cl
));
19454 TREE_TYPE (r
) = type
;
19460 tree operand_0
= TREE_OPERAND (t
, 0);
19461 if (TYPE_P (operand_0
))
19463 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
19464 RETURN (get_typeid (operand_0
, complain
));
19468 operand_0
= RECUR (operand_0
);
19469 RETURN (build_typeid (operand_0
, complain
));
19480 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
19481 /* ??? We're doing a subset of finish_id_expression here. */
19482 if (tree wrap
= maybe_get_tls_wrapper_call (r
))
19483 /* Replace an evaluated use of the thread_local variable with
19484 a call to its wrapper. */
19486 else if (outer_automatic_var_p (r
))
19487 r
= process_outer_var_ref (r
, complain
);
19489 if (!TYPE_REF_P (TREE_TYPE (t
)))
19490 /* If the original type was a reference, we'll be wrapped in
19491 the appropriate INDIRECT_REF. */
19492 r
= convert_from_reference (r
);
19498 tree op0
= RECUR (TREE_OPERAND (t
, 0));
19499 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
19500 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
19503 case OFFSETOF_EXPR
:
19506 = tsubst_copy_and_build (TREE_OPERAND (t
, 1), args
, complain
,
19507 in_decl
, /*function_p=*/false,
19508 /*integral_constant_expression_p=*/false);
19509 RETURN (finish_offsetof (object_ptr
,
19510 RECUR (TREE_OPERAND (t
, 0)),
19511 EXPR_LOCATION (t
)));
19514 case ADDRESSOF_EXPR
:
19515 RETURN (cp_build_addressof (EXPR_LOCATION (t
),
19516 RECUR (TREE_OPERAND (t
, 0)), complain
));
19520 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
19521 complain
, in_decl
);
19523 tree type2
= TRAIT_EXPR_TYPE2 (t
);
19524 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
19525 type2
= RECUR (type2
);
19527 type2
= tsubst (type2
, args
, complain
, in_decl
);
19529 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
19534 tree old_stmt_expr
= cur_stmt_expr
;
19535 tree stmt_expr
= begin_stmt_expr ();
19537 cur_stmt_expr
= stmt_expr
;
19538 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
19539 integral_constant_expression_p
);
19540 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
19541 cur_stmt_expr
= old_stmt_expr
;
19543 /* If the resulting list of expression statement is empty,
19544 fold it further into void_node. */
19545 if (empty_expr_stmt_p (stmt_expr
))
19546 stmt_expr
= void_node
;
19548 RETURN (stmt_expr
);
19553 if (complain
& tf_partial
)
19555 /* We don't have a full set of template arguments yet; don't touch
19556 the lambda at all. */
19557 gcc_assert (processing_template_decl
);
19560 tree r
= tsubst_lambda_expr (t
, args
, complain
, in_decl
);
19562 RETURN (build_lambda_object (r
));
19566 /* We can get here for a constant initializer of non-dependent type.
19567 FIXME stop folding in cp_parser_initializer_clause. */
19569 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
19574 case TRANSACTION_EXPR
:
19575 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
19576 integral_constant_expression_p
));
19579 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
19581 case VEC_PERM_EXPR
:
19583 tree op0
= RECUR (TREE_OPERAND (t
, 0));
19584 tree op1
= RECUR (TREE_OPERAND (t
, 1));
19585 tree op2
= RECUR (TREE_OPERAND (t
, 2));
19586 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
19590 case REQUIRES_EXPR
:
19591 RETURN (tsubst_requires_expr (t
, args
, complain
, in_decl
));
19594 /* No need to substitute further, a RANGE_EXPR will always be built
19595 with constant operands. */
19598 case NON_LVALUE_EXPR
:
19599 case VIEW_CONVERT_EXPR
:
19600 if (location_wrapper_p (t
))
19601 /* We need to do this here as well as in tsubst_copy so we get the
19602 other tsubst_copy_and_build semantics for a PARM_DECL operand. */
19603 RETURN (maybe_wrap_with_location (RECUR (TREE_OPERAND (t
, 0)),
19604 EXPR_LOCATION (t
)));
19608 /* Handle Objective-C++ constructs, if appropriate. */
19611 = objcp_tsubst_copy_and_build (t
, args
, complain
,
19612 in_decl
, /*function_p=*/false);
19616 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
19622 input_location
= loc
;
19626 /* Verify that the instantiated ARGS are valid. For type arguments,
19627 make sure that the type's linkage is ok. For non-type arguments,
19628 make sure they are constants if they are integral or enumerations.
19629 Emit an error under control of COMPLAIN, and return TRUE on error. */
19632 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
19634 if (dependent_template_arg_p (t
))
19636 if (ARGUMENT_PACK_P (t
))
19638 tree vec
= ARGUMENT_PACK_ARGS (t
);
19639 int len
= TREE_VEC_LENGTH (vec
);
19640 bool result
= false;
19643 for (i
= 0; i
< len
; ++i
)
19644 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
19648 else if (TYPE_P (t
))
19650 /* [basic.link]: A name with no linkage (notably, the name
19651 of a class or enumeration declared in a local scope)
19652 shall not be used to declare an entity with linkage.
19653 This implies that names with no linkage cannot be used as
19656 DR 757 relaxes this restriction for C++0x. */
19657 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
19658 : no_linkage_check (t
, /*relaxed_p=*/false));
19662 /* DR 488 makes use of a type with no linkage cause
19663 type deduction to fail. */
19664 if (complain
& tf_error
)
19666 if (TYPE_UNNAMED_P (nt
))
19667 error ("%qT is/uses unnamed type", t
);
19669 error ("template argument for %qD uses local type %qT",
19674 /* In order to avoid all sorts of complications, we do not
19675 allow variably-modified types as template arguments. */
19676 else if (variably_modified_type_p (t
, NULL_TREE
))
19678 if (complain
& tf_error
)
19679 error ("%qT is a variably modified type", t
);
19683 /* Class template and alias template arguments should be OK. */
19684 else if (DECL_TYPE_TEMPLATE_P (t
))
19686 /* A non-type argument of integral or enumerated type must be a
19688 else if (TREE_TYPE (t
)
19689 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
19690 && !REFERENCE_REF_P (t
)
19691 && !TREE_CONSTANT (t
))
19693 if (complain
& tf_error
)
19694 error ("integral expression %qE is not constant", t
);
19701 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
19703 int ix
, len
= DECL_NTPARMS (tmpl
);
19704 bool result
= false;
19706 for (ix
= 0; ix
!= len
; ix
++)
19708 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
19711 if (result
&& (complain
& tf_error
))
19712 error (" trying to instantiate %qD", tmpl
);
19716 /* We're out of SFINAE context now, so generate diagnostics for the access
19717 errors we saw earlier when instantiating D from TMPL and ARGS. */
19720 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
19722 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19723 tree type
= TREE_TYPE (pattern
);
19724 location_t loc
= input_location
;
19726 push_access_scope (d
);
19727 push_deferring_access_checks (dk_no_deferred
);
19728 input_location
= DECL_SOURCE_LOCATION (pattern
);
19729 tsubst (type
, args
, tf_warning_or_error
, d
);
19730 input_location
= loc
;
19731 pop_deferring_access_checks ();
19732 pop_access_scope (d
);
19735 /* Instantiate the indicated variable, function, or alias template TMPL with
19736 the template arguments in TARG_PTR. */
19739 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
19741 tree targ_ptr
= orig_args
;
19745 bool access_ok
= true;
19747 if (tmpl
== error_mark_node
)
19748 return error_mark_node
;
19750 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
19752 /* If this function is a clone, handle it specially. */
19753 if (DECL_CLONED_FUNCTION_P (tmpl
))
19758 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
19759 DECL_CLONED_FUNCTION. */
19760 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
19761 targ_ptr
, complain
);
19762 if (spec
== error_mark_node
)
19763 return error_mark_node
;
19765 /* Look for the clone. */
19766 FOR_EACH_CLONE (clone
, spec
)
19767 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
19769 /* We should always have found the clone by now. */
19770 gcc_unreachable ();
19774 if (targ_ptr
== error_mark_node
)
19775 return error_mark_node
;
19777 /* Check to see if we already have this specialization. */
19778 gen_tmpl
= most_general_template (tmpl
);
19779 if (TMPL_ARGS_DEPTH (targ_ptr
)
19780 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
)))
19781 /* targ_ptr only has the innermost template args, so add the outer ones
19782 from tmpl, which could be either a partial instantiation or gen_tmpl (in
19783 the case of a non-dependent call within a template definition). */
19784 targ_ptr
= (add_outermost_template_args
19785 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (tmpl
)),
19788 /* It would be nice to avoid hashing here and then again in tsubst_decl,
19789 but it doesn't seem to be on the hot path. */
19790 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
19792 gcc_assert (tmpl
== gen_tmpl
19793 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
19795 || fndecl
== NULL_TREE
);
19797 if (spec
!= NULL_TREE
)
19799 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
19801 if (complain
& tf_error
)
19802 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
19803 return error_mark_node
;
19808 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
19810 return error_mark_node
;
19812 /* We are building a FUNCTION_DECL, during which the access of its
19813 parameters and return types have to be checked. However this
19814 FUNCTION_DECL which is the desired context for access checking
19815 is not built yet. We solve this chicken-and-egg problem by
19816 deferring all checks until we have the FUNCTION_DECL. */
19817 push_deferring_access_checks (dk_deferred
);
19819 /* Instantiation of the function happens in the context of the function
19820 template, not the context of the overload resolution we're doing. */
19821 push_to_top_level ();
19822 /* If there are dependent arguments, e.g. because we're doing partial
19823 ordering, make sure processing_template_decl stays set. */
19824 if (uses_template_parms (targ_ptr
))
19825 ++processing_template_decl
;
19826 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
19828 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
19829 complain
, gen_tmpl
, true);
19830 push_nested_class (ctx
);
19833 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
19835 fndecl
= NULL_TREE
;
19836 if (VAR_P (pattern
))
19838 /* We need to determine if we're using a partial or explicit
19839 specialization now, because the type of the variable could be
19841 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
19842 tree elt
= most_specialized_partial_spec (tid
, complain
);
19843 if (elt
== error_mark_node
)
19844 pattern
= error_mark_node
;
19847 tree partial_tmpl
= TREE_VALUE (elt
);
19848 tree partial_args
= TREE_PURPOSE (elt
);
19849 tree partial_pat
= DECL_TEMPLATE_RESULT (partial_tmpl
);
19850 fndecl
= tsubst (partial_pat
, partial_args
, complain
, gen_tmpl
);
19854 /* Substitute template parameters to obtain the specialization. */
19855 if (fndecl
== NULL_TREE
)
19856 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
19857 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
19858 pop_nested_class ();
19859 pop_from_top_level ();
19861 if (fndecl
== error_mark_node
)
19863 pop_deferring_access_checks ();
19864 return error_mark_node
;
19867 /* The DECL_TI_TEMPLATE should always be the immediate parent
19868 template, not the most general template. */
19869 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
19870 DECL_TI_ARGS (fndecl
) = targ_ptr
;
19872 /* Now we know the specialization, compute access previously
19873 deferred. Do no access control for inheriting constructors,
19874 as we already checked access for the inherited constructor. */
19875 if (!(flag_new_inheriting_ctors
19876 && DECL_INHERITED_CTOR (fndecl
)))
19878 push_access_scope (fndecl
);
19879 if (!perform_deferred_access_checks (complain
))
19881 pop_access_scope (fndecl
);
19883 pop_deferring_access_checks ();
19885 /* If we've just instantiated the main entry point for a function,
19886 instantiate all the alternate entry points as well. We do this
19887 by cloning the instantiation of the main entry point, not by
19888 instantiating the template clones. */
19889 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
19890 clone_function_decl (fndecl
, /*update_methods=*/false);
19894 if (!(complain
& tf_error
))
19896 /* Remember to reinstantiate when we're out of SFINAE so the user
19897 can see the errors. */
19898 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
19900 return error_mark_node
;
19905 /* Wrapper for instantiate_template_1. */
19908 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
19911 timevar_push (TV_TEMPLATE_INST
);
19912 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
19913 timevar_pop (TV_TEMPLATE_INST
);
19917 /* Instantiate the alias template TMPL with ARGS. Also push a template
19918 instantiation level, which instantiate_template doesn't do because
19919 functions and variables have sufficient context established by the
19923 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
19925 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
19926 return error_mark_node
;
19927 if (!push_tinst_level (tmpl
, args
))
19928 return error_mark_node
;
19931 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
19932 args
, tmpl
, complain
,
19933 /*require_all_args=*/true,
19934 /*use_default_args=*/true);
19936 tree r
= instantiate_template (tmpl
, args
, complain
);
19937 pop_tinst_level ();
19942 /* PARM is a template parameter pack for FN. Returns true iff
19943 PARM is used in a deducible way in the argument list of FN. */
19946 pack_deducible_p (tree parm
, tree fn
)
19948 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
19949 for (; t
; t
= TREE_CHAIN (t
))
19951 tree type
= TREE_VALUE (t
);
19953 if (!PACK_EXPANSION_P (type
))
19955 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
19956 packs
; packs
= TREE_CHAIN (packs
))
19957 if (template_args_equal (TREE_VALUE (packs
), parm
))
19959 /* The template parameter pack is used in a function parameter
19960 pack. If this is the end of the parameter list, the
19961 template parameter pack is deducible. */
19962 if (TREE_CHAIN (t
) == void_list_node
)
19965 /* Otherwise, not. Well, it could be deduced from
19966 a non-pack parameter, but doing so would end up with
19967 a deduction mismatch, so don't bother. */
19971 /* The template parameter pack isn't used in any function parameter
19972 packs, but it might be used deeper, e.g. tuple<Args...>. */
19976 /* Subroutine of fn_type_unification: check non-dependent parms for
19980 check_non_deducible_conversions (tree parms
, const tree
*args
, unsigned nargs
,
19981 tree fn
, unification_kind_t strict
, int flags
,
19982 struct conversion
**convs
, bool explain_p
)
19984 /* Non-constructor methods need to leave a conversion for 'this', which
19985 isn't included in nargs here. */
19986 unsigned offset
= (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
19987 && !DECL_CONSTRUCTOR_P (fn
));
19989 for (unsigned ia
= 0;
19990 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
19992 tree parm
= TREE_VALUE (parms
);
19994 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
19995 && (!TREE_CHAIN (parms
)
19996 || TREE_CHAIN (parms
) == void_list_node
))
19997 /* For a function parameter pack that occurs at the end of the
19998 parameter-declaration-list, the type A of each remaining
19999 argument of the call is compared with the type P of the
20000 declarator-id of the function parameter pack. */
20003 parms
= TREE_CHAIN (parms
);
20005 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
20006 /* For a function parameter pack that does not occur at the
20007 end of the parameter-declaration-list, the type of the
20008 parameter pack is a non-deduced context. */
20011 if (!uses_template_parms (parm
))
20013 tree arg
= args
[ia
];
20014 conversion
**conv_p
= convs
? &convs
[ia
+offset
] : NULL
;
20015 int lflags
= conv_flags (ia
, nargs
, fn
, arg
, flags
);
20017 if (check_non_deducible_conversion (parm
, arg
, strict
, lflags
,
20018 conv_p
, explain_p
))
20028 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
20029 NARGS elements of the arguments that are being used when calling
20030 it. TARGS is a vector into which the deduced template arguments
20033 Returns either a FUNCTION_DECL for the matching specialization of FN or
20034 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
20035 true, diagnostics will be printed to explain why it failed.
20037 If FN is a conversion operator, or we are trying to produce a specific
20038 specialization, RETURN_TYPE is the return type desired.
20040 The EXPLICIT_TARGS are explicit template arguments provided via a
20043 The parameter STRICT is one of:
20046 We are deducing arguments for a function call, as in
20047 [temp.deduct.call]. If RETURN_TYPE is non-null, we are
20048 deducing arguments for a call to the result of a conversion
20049 function template, as in [over.call.object].
20052 We are deducing arguments for a conversion function, as in
20053 [temp.deduct.conv].
20056 We are deducing arguments when doing an explicit instantiation
20057 as in [temp.explicit], when determining an explicit specialization
20058 as in [temp.expl.spec], or when taking the address of a function
20059 template, as in [temp.deduct.funcaddr]. */
20062 fn_type_unification (tree fn
,
20063 tree explicit_targs
,
20066 unsigned int nargs
,
20068 unification_kind_t strict
,
20070 struct conversion
**convs
,
20076 tree decl
= NULL_TREE
;
20077 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
20079 static int deduction_depth
;
20080 /* type_unification_real will pass back any access checks from default
20081 template argument substitution. */
20082 vec
<deferred_access_check
, va_gc
> *checks
= NULL
;
20083 /* We don't have all the template args yet. */
20084 bool incomplete
= true;
20087 if (flag_new_inheriting_ctors
)
20088 fn
= strip_inheriting_ctors (fn
);
20090 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
20091 tree r
= error_mark_node
;
20093 tree full_targs
= targs
;
20094 if (TMPL_ARGS_DEPTH (targs
)
20095 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (fn
)))
20096 full_targs
= (add_outermost_template_args
20097 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (fn
)),
20101 complain
|= tf_decltype
;
20103 /* In C++0x, it's possible to have a function template whose type depends
20104 on itself recursively. This is most obvious with decltype, but can also
20105 occur with enumeration scope (c++/48969). So we need to catch infinite
20106 recursion and reject the substitution at deduction time; this function
20107 will return error_mark_node for any repeated substitution.
20109 This also catches excessive recursion such as when f<N> depends on
20110 f<N-1> across all integers, and returns error_mark_node for all the
20111 substitutions back up to the initial one.
20113 This is, of course, not reentrant. */
20114 if (excessive_deduction_depth
)
20115 return error_mark_node
;
20118 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
20120 fntype
= TREE_TYPE (fn
);
20121 if (explicit_targs
)
20125 The specified template arguments must match the template
20126 parameters in kind (i.e., type, nontype, template), and there
20127 must not be more arguments than there are parameters;
20128 otherwise type deduction fails.
20130 Nontype arguments must match the types of the corresponding
20131 nontype template parameters, or must be convertible to the
20132 types of the corresponding nontype parameters as specified in
20133 _temp.arg.nontype_, otherwise type deduction fails.
20135 All references in the function type of the function template
20136 to the corresponding template parameters are replaced by the
20137 specified template argument values. If a substitution in a
20138 template parameter or in the function type of the function
20139 template results in an invalid type, type deduction fails. */
20140 int i
, len
= TREE_VEC_LENGTH (tparms
);
20141 location_t loc
= input_location
;
20142 incomplete
= false;
20144 if (explicit_targs
== error_mark_node
)
20147 if (TMPL_ARGS_DEPTH (explicit_targs
)
20148 < TMPL_ARGS_DEPTH (full_targs
))
20149 explicit_targs
= add_outermost_template_args (full_targs
,
20152 /* Adjust any explicit template arguments before entering the
20153 substitution context. */
20155 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
20156 complain
|tf_partial
,
20157 /*require_all_args=*/false,
20158 /*use_default_args=*/false));
20159 if (explicit_targs
== error_mark_node
)
20162 /* Substitute the explicit args into the function type. This is
20163 necessary so that, for instance, explicitly declared function
20164 arguments can match null pointed constants. If we were given
20165 an incomplete set of explicit args, we must not do semantic
20166 processing during substitution as we could create partial
20168 for (i
= 0; i
< len
; i
++)
20170 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
20171 bool parameter_pack
= false;
20172 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
20174 /* Dig out the actual parm. */
20175 if (TREE_CODE (parm
) == TYPE_DECL
20176 || TREE_CODE (parm
) == TEMPLATE_DECL
)
20178 parm
= TREE_TYPE (parm
);
20179 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
20181 else if (TREE_CODE (parm
) == PARM_DECL
)
20183 parm
= DECL_INITIAL (parm
);
20184 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
20187 if (targ
== NULL_TREE
)
20188 /* No explicit argument for this template parameter. */
20190 else if (parameter_pack
&& pack_deducible_p (parm
, fn
))
20192 /* Mark the argument pack as "incomplete". We could
20193 still deduce more arguments during unification.
20194 We remove this mark in type_unification_real. */
20195 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
20196 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
20197 = ARGUMENT_PACK_ARGS (targ
);
20199 /* We have some incomplete argument packs. */
20206 if (!push_tinst_level (fn
, explicit_targs
))
20208 excessive_deduction_depth
= true;
20211 ++processing_template_decl
;
20212 input_location
= DECL_SOURCE_LOCATION (fn
);
20213 /* Ignore any access checks; we'll see them again in
20214 instantiate_template and they might have the wrong
20215 access path at this point. */
20216 push_deferring_access_checks (dk_deferred
);
20217 tsubst_flags_t ecomplain
= complain
| tf_partial
| tf_fndecl_type
;
20218 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
, ecomplain
, NULL_TREE
);
20219 pop_deferring_access_checks ();
20220 input_location
= loc
;
20221 --processing_template_decl
;
20222 pop_tinst_level ();
20224 if (fntype
== error_mark_node
)
20228 /* Place the explicitly specified arguments in TARGS. */
20229 explicit_targs
= INNERMOST_TEMPLATE_ARGS (explicit_targs
);
20230 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
20231 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
20232 if (!incomplete
&& CHECKING_P
20233 && !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
20234 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
20235 (targs
, NUM_TMPL_ARGS (explicit_targs
));
20238 if (return_type
&& strict
!= DEDUCE_CALL
)
20240 tree
*new_args
= XALLOCAVEC (tree
, nargs
+ 1);
20241 new_args
[0] = return_type
;
20242 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
20250 /* Never do unification on the 'this' parameter. */
20251 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
20253 if (return_type
&& strict
== DEDUCE_CALL
)
20255 /* We're deducing for a call to the result of a template conversion
20256 function. The parms we really want are in return_type. */
20257 if (INDIRECT_TYPE_P (return_type
))
20258 return_type
= TREE_TYPE (return_type
);
20259 parms
= TYPE_ARG_TYPES (return_type
);
20261 else if (return_type
)
20263 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
20266 /* We allow incomplete unification without an error message here
20267 because the standard doesn't seem to explicitly prohibit it. Our
20268 callers must be ready to deal with unification failures in any
20271 /* If we aren't explaining yet, push tinst context so we can see where
20272 any errors (e.g. from class instantiations triggered by instantiation
20273 of default template arguments) come from. If we are explaining, this
20274 context is redundant. */
20275 if (!explain_p
&& !push_tinst_level (fn
, targs
))
20277 excessive_deduction_depth
= true;
20281 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
20282 full_targs
, parms
, args
, nargs
, /*subr=*/0,
20283 strict
, &checks
, explain_p
);
20285 pop_tinst_level ();
20289 /* Now that we have bindings for all of the template arguments,
20290 ensure that the arguments deduced for the template template
20291 parameters have compatible template parameter lists. We cannot
20292 check this property before we have deduced all template
20293 arguments, because the template parameter types of a template
20294 template parameter might depend on prior template parameters
20295 deduced after the template template parameter. The following
20296 ill-formed example illustrates this issue:
20298 template<typename T, template<T> class C> void f(C<5>, T);
20300 template<int N> struct X {};
20303 f(X<5>(), 5l); // error: template argument deduction fails
20306 The template parameter list of 'C' depends on the template type
20307 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
20308 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
20309 time that we deduce 'C'. */
20310 if (!template_template_parm_bindings_ok_p
20311 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
20313 unify_inconsistent_template_template_parameters (explain_p
);
20317 /* DR 1391: All parameters have args, now check non-dependent parms for
20319 if (check_non_deducible_conversions (parms
, args
, nargs
, fn
, strict
, flags
,
20324 /* All is well so far. Now, check:
20328 When all template arguments have been deduced, all uses of
20329 template parameters in nondeduced contexts are replaced with
20330 the corresponding deduced argument values. If the
20331 substitution results in an invalid type, as described above,
20332 type deduction fails. */
20333 if (!push_tinst_level (fn
, targs
))
20335 excessive_deduction_depth
= true;
20339 /* Also collect access checks from the instantiation. */
20340 reopen_deferring_access_checks (checks
);
20342 decl
= instantiate_template (fn
, targs
, complain
);
20344 checks
= get_deferred_access_checks ();
20345 pop_deferring_access_checks ();
20347 pop_tinst_level ();
20349 if (decl
== error_mark_node
)
20352 /* Now perform any access checks encountered during substitution. */
20353 push_access_scope (decl
);
20354 ok
= perform_access_checks (checks
, complain
);
20355 pop_access_scope (decl
);
20359 /* If we're looking for an exact match, check that what we got
20360 is indeed an exact match. It might not be if some template
20361 parameters are used in non-deduced contexts. But don't check
20362 for an exact match if we have dependent template arguments;
20363 in that case we're doing partial ordering, and we already know
20364 that we have two candidates that will provide the actual type. */
20365 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
20367 tree substed
= TREE_TYPE (decl
);
20371 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
20373 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
20374 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
20375 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
20377 unify_type_mismatch (explain_p
, args
[i
],
20378 TREE_VALUE (sarg
));
20383 /* After doing deduction with the inherited constructor, actually return an
20384 instantiation of the inheriting constructor. */
20386 decl
= instantiate_template (orig_fn
, targs
, complain
);
20392 if (excessive_deduction_depth
)
20394 if (deduction_depth
== 0)
20395 /* Reset once we're all the way out. */
20396 excessive_deduction_depth
= false;
20402 /* Adjust types before performing type deduction, as described in
20403 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
20404 sections are symmetric. PARM is the type of a function parameter
20405 or the return type of the conversion function. ARG is the type of
20406 the argument passed to the call, or the type of the value
20407 initialized with the result of the conversion function.
20408 ARG_EXPR is the original argument expression, which may be null. */
20411 maybe_adjust_types_for_deduction (unification_kind_t strict
,
20424 /* Swap PARM and ARG throughout the remainder of this
20425 function; the handling is precisely symmetric since PARM
20426 will initialize ARG rather than vice versa. */
20427 std::swap (parm
, arg
);
20431 /* Core issue #873: Do the DR606 thing (see below) for these cases,
20432 too, but here handle it by stripping the reference from PARM
20433 rather than by adding it to ARG. */
20434 if (TYPE_REF_P (*parm
)
20435 && TYPE_REF_IS_RVALUE (*parm
)
20436 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
20437 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
20438 && TYPE_REF_P (*arg
)
20439 && !TYPE_REF_IS_RVALUE (*arg
))
20440 *parm
= TREE_TYPE (*parm
);
20441 /* Nothing else to do in this case. */
20445 gcc_unreachable ();
20448 if (!TYPE_REF_P (*parm
))
20450 /* [temp.deduct.call]
20452 If P is not a reference type:
20454 --If A is an array type, the pointer type produced by the
20455 array-to-pointer standard conversion (_conv.array_) is
20456 used in place of A for type deduction; otherwise,
20458 --If A is a function type, the pointer type produced by
20459 the function-to-pointer standard conversion
20460 (_conv.func_) is used in place of A for type deduction;
20463 --If A is a cv-qualified type, the top level
20464 cv-qualifiers of A's type are ignored for type
20466 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
20467 *arg
= build_pointer_type (TREE_TYPE (*arg
));
20468 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
20469 *arg
= build_pointer_type (*arg
);
20471 *arg
= TYPE_MAIN_VARIANT (*arg
);
20474 /* [14.8.2.1/3 temp.deduct.call], "A forwarding reference is an rvalue
20475 reference to a cv-unqualified template parameter that does not represent a
20476 template parameter of a class template (during class template argument
20477 deduction (13.3.1.8)). If P is a forwarding reference and the argument is
20478 an lvalue, the type "lvalue reference to A" is used in place of A for type
20480 if (TYPE_REF_P (*parm
)
20481 && TYPE_REF_IS_RVALUE (*parm
)
20482 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
20483 && !TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (*parm
))
20484 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
20485 && (arg_expr
? lvalue_p (arg_expr
)
20486 /* try_one_overload doesn't provide an arg_expr, but
20487 functions are always lvalues. */
20488 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
20489 *arg
= build_reference_type (*arg
);
20491 /* [temp.deduct.call]
20493 If P is a cv-qualified type, the top level cv-qualifiers
20494 of P's type are ignored for type deduction. If P is a
20495 reference type, the type referred to by P is used for
20497 *parm
= TYPE_MAIN_VARIANT (*parm
);
20498 if (TYPE_REF_P (*parm
))
20500 *parm
= TREE_TYPE (*parm
);
20501 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
20504 /* DR 322. For conversion deduction, remove a reference type on parm
20505 too (which has been swapped into ARG). */
20506 if (strict
== DEDUCE_CONV
&& TYPE_REF_P (*arg
))
20507 *arg
= TREE_TYPE (*arg
);
20512 /* Subroutine of fn_type_unification. PARM is a function parameter of a
20513 template which doesn't contain any deducible template parameters; check if
20514 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
20515 unify_one_argument. */
20518 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
20519 int flags
, struct conversion
**conv_p
,
20525 type
= TREE_TYPE (arg
);
20529 if (same_type_p (parm
, type
))
20530 return unify_success (explain_p
);
20532 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
20533 if (strict
== DEDUCE_CONV
)
20535 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
, complain
))
20536 return unify_success (explain_p
);
20538 else if (strict
!= DEDUCE_EXACT
)
20541 tree conv_arg
= TYPE_P (arg
) ? NULL_TREE
: arg
;
20543 /* Avoid recalculating this in add_function_candidate. */
20545 = good_conversion (parm
, type
, conv_arg
, flags
, complain
));
20547 ok
= can_convert_arg (parm
, type
, conv_arg
, flags
, complain
);
20549 return unify_success (explain_p
);
20552 if (strict
== DEDUCE_EXACT
)
20553 return unify_type_mismatch (explain_p
, parm
, arg
);
20555 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
20558 static bool uses_deducible_template_parms (tree type
);
20560 /* Returns true iff the expression EXPR is one from which a template
20561 argument can be deduced. In other words, if it's an undecorated
20562 use of a template non-type parameter. */
20565 deducible_expression (tree expr
)
20567 /* Strip implicit conversions. */
20568 while (CONVERT_EXPR_P (expr
))
20569 expr
= TREE_OPERAND (expr
, 0);
20570 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
20573 /* Returns true iff the array domain DOMAIN uses a template parameter in a
20574 deducible way; that is, if it has a max value of <PARM> - 1. */
20577 deducible_array_bound (tree domain
)
20579 if (domain
== NULL_TREE
)
20582 tree max
= TYPE_MAX_VALUE (domain
);
20583 if (TREE_CODE (max
) != MINUS_EXPR
)
20586 return deducible_expression (TREE_OPERAND (max
, 0));
20589 /* Returns true iff the template arguments ARGS use a template parameter
20590 in a deducible way. */
20593 deducible_template_args (tree args
)
20595 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
20598 tree elt
= TREE_VEC_ELT (args
, i
);
20599 if (ARGUMENT_PACK_P (elt
))
20600 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
20603 if (PACK_EXPANSION_P (elt
))
20604 elt
= PACK_EXPANSION_PATTERN (elt
);
20605 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
20607 else if (TYPE_P (elt
))
20608 deducible
= uses_deducible_template_parms (elt
);
20610 deducible
= deducible_expression (elt
);
20618 /* Returns true iff TYPE contains any deducible references to template
20619 parameters, as per 14.8.2.5. */
20622 uses_deducible_template_parms (tree type
)
20624 if (PACK_EXPANSION_P (type
))
20625 type
= PACK_EXPANSION_PATTERN (type
);
20632 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20633 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20639 if (INDIRECT_TYPE_P (type
))
20640 return uses_deducible_template_parms (TREE_TYPE (type
));
20642 /* T[integer-constant ]
20644 if (TREE_CODE (type
) == ARRAY_TYPE
)
20645 return (uses_deducible_template_parms (TREE_TYPE (type
))
20646 || deducible_array_bound (TYPE_DOMAIN (type
)));
20658 if (TYPE_PTRMEM_P (type
))
20659 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
20660 || (uses_deducible_template_parms
20661 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
20663 /* template-name <T> (where template-name refers to a class template)
20664 template-name <i> (where template-name refers to a class template) */
20665 if (CLASS_TYPE_P (type
)
20666 && CLASSTYPE_TEMPLATE_INFO (type
)
20667 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
20668 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
20669 (CLASSTYPE_TI_ARGS (type
)));
20674 if (FUNC_OR_METHOD_TYPE_P (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 (!OVL_P (arg
))
21219 /* If ARG is, for example, "(0, &f)" then its type will be unknown
21220 -- but the deduction does not succeed because the expression is
21221 not just the function on its own. */
21224 for (lkp_iterator
iter (arg
); iter
; ++iter
)
21227 if (try_one_overload (tparms
, targs
, tempargs
, parm
, TREE_TYPE (fn
),
21228 strict
, sub_strict
, addr_p
, explain_p
)
21229 && (!goodfn
|| !decls_match (goodfn
, fn
)))
21236 /* [temp.deduct.type] A template-argument can be deduced from a pointer
21237 to function or pointer to member function argument if the set of
21238 overloaded functions does not contain function templates and at most
21239 one of a set of overloaded functions provides a unique match.
21241 So if we found multiple possibilities, we return success but don't
21242 deduce anything. */
21246 int i
= TREE_VEC_LENGTH (targs
);
21248 if (TREE_VEC_ELT (tempargs
, i
))
21250 tree old
= TREE_VEC_ELT (targs
, i
);
21251 tree new_
= TREE_VEC_ELT (tempargs
, i
);
21252 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
21253 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
21254 /* Don't forget explicit template arguments in a pack. */
21255 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
21256 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
21257 TREE_VEC_ELT (targs
, i
) = new_
;
21266 /* Core DR 115: In contexts where deduction is done and fails, or in
21267 contexts where deduction is not done, if a template argument list is
21268 specified and it, along with any default template arguments, identifies
21269 a single function template specialization, then the template-id is an
21270 lvalue for the function template specialization. */
21273 resolve_nondeduced_context (tree orig_expr
, tsubst_flags_t complain
)
21275 tree expr
, offset
, baselink
;
21278 if (!type_unknown_p (orig_expr
))
21283 offset
= NULL_TREE
;
21284 baselink
= NULL_TREE
;
21286 if (TREE_CODE (expr
) == ADDR_EXPR
)
21288 expr
= TREE_OPERAND (expr
, 0);
21291 if (TREE_CODE (expr
) == OFFSET_REF
)
21294 expr
= TREE_OPERAND (expr
, 1);
21296 if (BASELINK_P (expr
))
21299 expr
= BASELINK_FUNCTIONS (expr
);
21302 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
21305 tree goodfn
= NULL_TREE
;
21307 /* If we got some explicit template args, we need to plug them into
21308 the affected templates before we try to unify, in case the
21309 explicit args will completely resolve the templates in question. */
21311 tree expl_subargs
= TREE_OPERAND (expr
, 1);
21312 tree arg
= TREE_OPERAND (expr
, 0);
21313 tree badfn
= NULL_TREE
;
21314 tree badargs
= NULL_TREE
;
21316 for (lkp_iterator
iter (arg
); iter
; ++iter
)
21319 tree subargs
, elem
;
21321 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
21324 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
21325 expl_subargs
, NULL_TREE
, tf_none
,
21326 /*require_all_args=*/true,
21327 /*use_default_args=*/true);
21328 if (subargs
!= error_mark_node
21329 && !any_dependent_template_arguments_p (subargs
))
21331 elem
= instantiate_template (fn
, subargs
, tf_none
);
21332 if (elem
== error_mark_node
)
21337 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
21346 mark_used (goodfn
);
21349 expr
= build_baselink (BASELINK_BINFO (baselink
),
21350 BASELINK_ACCESS_BINFO (baselink
),
21351 expr
, BASELINK_OPTYPE (baselink
));
21355 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
21356 expr
= build_offset_ref (base
, expr
, addr
, complain
);
21359 expr
= cp_build_addr_expr (expr
, complain
);
21362 else if (good
== 0 && badargs
&& (complain
& tf_error
))
21363 /* There were no good options and at least one bad one, so let the
21364 user know what the problem is. */
21365 instantiate_template (badfn
, badargs
, complain
);
21370 /* As above, but error out if the expression remains overloaded. */
21373 resolve_nondeduced_context_or_error (tree exp
, tsubst_flags_t complain
)
21375 exp
= resolve_nondeduced_context (exp
, complain
);
21376 if (type_unknown_p (exp
))
21378 if (complain
& tf_error
)
21379 cxx_incomplete_type_error (exp
, TREE_TYPE (exp
));
21380 return error_mark_node
;
21385 /* Subroutine of resolve_overloaded_unification; does deduction for a single
21386 overload. Fills TARGS with any deduced arguments, or error_mark_node if
21387 different overloads deduce different arguments for a given parm.
21388 ADDR_P is true if the expression for which deduction is being
21389 performed was of the form "& fn" rather than simply "fn".
21391 Returns 1 on success. */
21394 try_one_overload (tree tparms
,
21399 unification_kind_t strict
,
21408 if (arg
== error_mark_node
)
21411 /* [temp.deduct.type] A template-argument can be deduced from a pointer
21412 to function or pointer to member function argument if the set of
21413 overloaded functions does not contain function templates and at most
21414 one of a set of overloaded functions provides a unique match.
21416 So if this is a template, just return success. */
21418 if (uses_template_parms (arg
))
21421 if (TREE_CODE (arg
) == METHOD_TYPE
)
21422 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
21424 arg
= build_pointer_type (arg
);
21426 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
21428 /* We don't copy orig_targs for this because if we have already deduced
21429 some template args from previous args, unify would complain when we
21430 try to deduce a template parameter for the same argument, even though
21431 there isn't really a conflict. */
21432 nargs
= TREE_VEC_LENGTH (targs
);
21433 tempargs
= make_tree_vec (nargs
);
21435 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
21438 /* First make sure we didn't deduce anything that conflicts with
21439 explicitly specified args. */
21440 for (i
= nargs
; i
--; )
21442 tree elt
= TREE_VEC_ELT (tempargs
, i
);
21443 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
21447 else if (uses_template_parms (elt
))
21448 /* Since we're unifying against ourselves, we will fill in
21449 template args used in the function parm list with our own
21450 template parms. Discard them. */
21451 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
21452 else if (oldelt
&& ARGUMENT_PACK_P (oldelt
))
21454 /* Check that the argument at each index of the deduced argument pack
21455 is equivalent to the corresponding explicitly specified argument.
21456 We may have deduced more arguments than were explicitly specified,
21459 /* We used to assert ARGUMENT_PACK_INCOMPLETE_P (oldelt) here, but
21460 that's wrong if we deduce the same argument pack from multiple
21461 function arguments: it's only incomplete the first time. */
21463 tree explicit_pack
= ARGUMENT_PACK_ARGS (oldelt
);
21464 tree deduced_pack
= ARGUMENT_PACK_ARGS (elt
);
21466 if (TREE_VEC_LENGTH (deduced_pack
)
21467 < TREE_VEC_LENGTH (explicit_pack
))
21470 for (int j
= 0; j
< TREE_VEC_LENGTH (explicit_pack
); j
++)
21471 if (!template_args_equal (TREE_VEC_ELT (explicit_pack
, j
),
21472 TREE_VEC_ELT (deduced_pack
, j
)))
21475 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
21479 for (i
= nargs
; i
--; )
21481 tree elt
= TREE_VEC_ELT (tempargs
, i
);
21484 TREE_VEC_ELT (targs
, i
) = elt
;
21490 /* PARM is a template class (perhaps with unbound template
21491 parameters). ARG is a fully instantiated type. If ARG can be
21492 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
21493 TARGS are as for unify. */
21496 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
21499 tree copy_of_targs
;
21501 if (!CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
21503 else if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21504 /* Matches anything. */;
21505 else if (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
21506 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
)))
21509 /* We need to make a new template argument vector for the call to
21510 unify. If we used TARGS, we'd clutter it up with the result of
21511 the attempted unification, even if this class didn't work out.
21512 We also don't want to commit ourselves to all the unifications
21513 we've already done, since unification is supposed to be done on
21514 an argument-by-argument basis. In other words, consider the
21515 following pathological case:
21517 template <int I, int J, int K>
21520 template <int I, int J>
21521 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
21523 template <int I, int J, int K>
21524 void f(S<I, J, K>, S<I, I, I>);
21533 Now, by the time we consider the unification involving `s2', we
21534 already know that we must have `f<0, 0, 0>'. But, even though
21535 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
21536 because there are two ways to unify base classes of S<0, 1, 2>
21537 with S<I, I, I>. If we kept the already deduced knowledge, we
21538 would reject the possibility I=1. */
21539 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
21541 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21543 if (unify_bound_ttp_args (tparms
, copy_of_targs
, parm
, arg
, explain_p
))
21548 /* If unification failed, we're done. */
21549 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
21550 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
21556 /* Given a template type PARM and a class type ARG, find the unique
21557 base type in ARG that is an instance of PARM. We do not examine
21558 ARG itself; only its base-classes. If there is not exactly one
21559 appropriate base class, return NULL_TREE. PARM may be the type of
21560 a partial specialization, as well as a plain template type. Used
21563 static enum template_base_result
21564 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
21565 bool explain_p
, tree
*result
)
21567 tree rval
= NULL_TREE
;
21570 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
21572 binfo
= TYPE_BINFO (complete_type (arg
));
21575 /* The type could not be completed. */
21576 *result
= NULL_TREE
;
21577 return tbr_incomplete_type
;
21580 /* Walk in inheritance graph order. The search order is not
21581 important, and this avoids multiple walks of virtual bases. */
21582 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
21584 tree r
= try_class_unification (tparms
, targs
, parm
,
21585 BINFO_TYPE (binfo
), explain_p
);
21589 /* If there is more than one satisfactory baseclass, then:
21593 If they yield more than one possible deduced A, the type
21597 if (rval
&& !same_type_p (r
, rval
))
21599 *result
= NULL_TREE
;
21600 return tbr_ambiguous_baseclass
;
21608 return tbr_success
;
21611 /* Returns the level of DECL, which declares a template parameter. */
21614 template_decl_level (tree decl
)
21616 switch (TREE_CODE (decl
))
21619 case TEMPLATE_DECL
:
21620 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
21623 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
21626 gcc_unreachable ();
21631 /* Decide whether ARG can be unified with PARM, considering only the
21632 cv-qualifiers of each type, given STRICT as documented for unify.
21633 Returns nonzero iff the unification is OK on that basis. */
21636 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
21638 int arg_quals
= cp_type_quals (arg
);
21639 int parm_quals
= cp_type_quals (parm
);
21641 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
21642 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
21644 /* Although a CVR qualifier is ignored when being applied to a
21645 substituted template parameter ([8.3.2]/1 for example), that
21646 does not allow us to unify "const T" with "int&" because both
21647 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
21648 It is ok when we're allowing additional CV qualifiers
21649 at the outer level [14.8.2.1]/3,1st bullet. */
21650 if ((TYPE_REF_P (arg
)
21651 || FUNC_OR_METHOD_TYPE_P (arg
))
21652 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
21655 if ((!INDIRECT_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
21656 && (parm_quals
& TYPE_QUAL_RESTRICT
))
21660 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
21661 && (arg_quals
& parm_quals
) != parm_quals
)
21664 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
21665 && (parm_quals
& arg_quals
) != arg_quals
)
21671 /* Determines the LEVEL and INDEX for the template parameter PARM. */
21673 template_parm_level_and_index (tree parm
, int* level
, int* index
)
21675 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
21676 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
21677 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21679 *index
= TEMPLATE_TYPE_IDX (parm
);
21680 *level
= TEMPLATE_TYPE_LEVEL (parm
);
21684 *index
= TEMPLATE_PARM_IDX (parm
);
21685 *level
= TEMPLATE_PARM_LEVEL (parm
);
21689 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
21691 if (unify (TP, TA, P, A, S, EP)) \
21695 /* Unifies the remaining arguments in PACKED_ARGS with the pack
21696 expansion at the end of PACKED_PARMS. Returns 0 if the type
21697 deduction succeeds, 1 otherwise. STRICT is the same as in
21698 fn_type_unification. CALL_ARGS_P is true iff PACKED_ARGS is actually a
21699 function call argument list. We'll need to adjust the arguments to make them
21700 types. SUBR tells us if this is from a recursive call to
21701 type_unification_real, or for comparing two template argument
21705 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
21706 tree packed_args
, unification_kind_t strict
,
21707 bool subr
, bool explain_p
)
21710 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
21711 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
21712 tree pack
, packs
= NULL_TREE
;
21713 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
21715 /* Add in any args remembered from an earlier partial instantiation. */
21716 targs
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (parm
), targs
);
21717 int levels
= TMPL_ARGS_DEPTH (targs
);
21719 packed_args
= expand_template_argument_pack (packed_args
);
21721 int len
= TREE_VEC_LENGTH (packed_args
);
21723 /* Determine the parameter packs we will be deducing from the
21724 pattern, and record their current deductions. */
21725 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
21726 pack
; pack
= TREE_CHAIN (pack
))
21728 tree parm_pack
= TREE_VALUE (pack
);
21731 /* Only template parameter packs can be deduced, not e.g. function
21732 parameter packs or __bases or __integer_pack. */
21733 if (!TEMPLATE_PARM_P (parm_pack
))
21736 /* Determine the index and level of this parameter pack. */
21737 template_parm_level_and_index (parm_pack
, &level
, &idx
);
21738 if (level
< levels
)
21741 /* Keep track of the parameter packs and their corresponding
21743 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
21744 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
21747 /* Loop through all of the arguments that have not yet been
21748 unified and unify each with the pattern. */
21749 for (i
= start
; i
< len
; i
++)
21752 bool any_explicit
= false;
21753 tree arg
= TREE_VEC_ELT (packed_args
, i
);
21755 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
21756 or the element of its argument pack at the current index if
21757 this argument was explicitly specified. */
21758 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
21762 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
21765 if (TREE_VALUE (pack
)
21766 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
21767 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
21769 any_explicit
= true;
21770 arg
= TREE_VEC_ELT (pargs
, i
- start
);
21772 TMPL_ARG (targs
, level
, idx
) = arg
;
21775 /* If we had explicit template arguments, substitute them into the
21776 pattern before deduction. */
21779 /* Some arguments might still be unspecified or dependent. */
21781 ++processing_template_decl
;
21782 dependent
= any_dependent_template_arguments_p (targs
);
21784 --processing_template_decl
;
21785 parm
= tsubst (pattern
, targs
,
21786 explain_p
? tf_warning_or_error
: tf_none
,
21789 --processing_template_decl
;
21790 if (parm
== error_mark_node
)
21796 /* Unify the pattern with the current argument. */
21797 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
21801 /* For each parameter pack, collect the deduced value. */
21802 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
21805 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
21807 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
21808 TMPL_ARG (targs
, level
, idx
);
21812 /* Verify that the results of unification with the parameter packs
21813 produce results consistent with what we've seen before, and make
21814 the deduced argument packs available. */
21815 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
21817 tree old_pack
= TREE_VALUE (pack
);
21818 tree new_args
= TREE_TYPE (pack
);
21819 int i
, len
= TREE_VEC_LENGTH (new_args
);
21821 bool nondeduced_p
= false;
21823 /* By default keep the original deduced argument pack.
21824 If necessary, more specific code is going to update the
21825 resulting deduced argument later down in this function. */
21826 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
21827 TMPL_ARG (targs
, level
, idx
) = old_pack
;
21829 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
21830 actually deduce anything. */
21831 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
21832 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
21833 nondeduced_p
= true;
21837 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
21839 /* If we had fewer function args than explicit template args,
21840 just use the explicits. */
21841 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
21842 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
21843 if (len
< explicit_len
)
21844 new_args
= explicit_args
;
21850 /* Build the deduced *_ARGUMENT_PACK. */
21851 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
21853 result
= make_node (NONTYPE_ARGUMENT_PACK
);
21854 TREE_CONSTANT (result
) = 1;
21857 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
21859 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
21861 /* Note the deduced argument packs for this parameter
21863 TMPL_ARG (targs
, level
, idx
) = result
;
21865 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
21866 && (ARGUMENT_PACK_ARGS (old_pack
)
21867 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
21869 /* We only had the explicitly-provided arguments before, but
21870 now we have a complete set of arguments. */
21871 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
21873 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
21874 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
21875 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
21879 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
21880 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
21882 if (!comp_template_args (old_args
, new_args
,
21883 &bad_old_arg
, &bad_new_arg
))
21884 /* Inconsistent unification of this parameter pack. */
21885 return unify_parameter_pack_inconsistent (explain_p
,
21891 return unify_success (explain_p
);
21894 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
21895 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
21896 parameters and return value are as for unify. */
21899 unify_array_domain (tree tparms
, tree targs
,
21900 tree parm_dom
, tree arg_dom
,
21908 /* Our representation of array types uses "N - 1" as the
21909 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
21910 not an integer constant. We cannot unify arbitrarily
21911 complex expressions, so we eliminate the MINUS_EXPRs
21913 parm_max
= TYPE_MAX_VALUE (parm_dom
);
21914 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
21917 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
21918 parm_max
= TREE_OPERAND (parm_max
, 0);
21920 arg_max
= TYPE_MAX_VALUE (arg_dom
);
21921 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
21924 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
21925 trying to unify the type of a variable with the type
21926 of a template parameter. For example:
21928 template <unsigned int N>
21929 void f (char (&) [N]);
21936 Here, the type of the ARG will be "int [g(i)]", and
21937 may be a SAVE_EXPR, etc. */
21938 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
21939 return unify_vla_arg (explain_p
, arg_dom
);
21940 arg_max
= TREE_OPERAND (arg_max
, 0);
21943 /* If only one of the bounds used a MINUS_EXPR, compensate
21944 by adding one to the other bound. */
21945 if (parm_cst
&& !arg_cst
)
21946 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
21950 else if (arg_cst
&& !parm_cst
)
21951 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
21956 return unify (tparms
, targs
, parm_max
, arg_max
,
21957 UNIFY_ALLOW_INTEGER
, explain_p
);
21960 /* Returns whether T, a P or A in unify, is a type, template or expression. */
21962 enum pa_kind_t
{ pa_type
, pa_tmpl
, pa_expr
};
21967 if (PACK_EXPANSION_P (t
))
21968 t
= PACK_EXPANSION_PATTERN (t
);
21969 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
21970 || TREE_CODE (t
) == UNBOUND_CLASS_TEMPLATE
21971 || DECL_TYPE_TEMPLATE_P (t
))
21973 else if (TYPE_P (t
))
21979 /* Deduce the value of template parameters. TPARMS is the (innermost)
21980 set of template parameters to a template. TARGS is the bindings
21981 for those template parameters, as determined thus far; TARGS may
21982 include template arguments for outer levels of template parameters
21983 as well. PARM is a parameter to a template function, or a
21984 subcomponent of that parameter; ARG is the corresponding argument.
21985 This function attempts to match PARM with ARG in a manner
21986 consistent with the existing assignments in TARGS. If more values
21987 are deduced, then TARGS is updated.
21989 Returns 0 if the type deduction succeeds, 1 otherwise. The
21990 parameter STRICT is a bitwise or of the following flags:
21993 Require an exact match between PARM and ARG.
21994 UNIFY_ALLOW_MORE_CV_QUAL:
21995 Allow the deduced ARG to be more cv-qualified (by qualification
21996 conversion) than ARG.
21997 UNIFY_ALLOW_LESS_CV_QUAL:
21998 Allow the deduced ARG to be less cv-qualified than ARG.
21999 UNIFY_ALLOW_DERIVED:
22000 Allow the deduced ARG to be a template base class of ARG,
22001 or a pointer to a template base class of the type pointed to by
22003 UNIFY_ALLOW_INTEGER:
22004 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
22005 case for more information.
22006 UNIFY_ALLOW_OUTER_LEVEL:
22007 This is the outermost level of a deduction. Used to determine validity
22008 of qualification conversions. A valid qualification conversion must
22009 have const qualified pointers leading up to the inner type which
22010 requires additional CV quals, except at the outer level, where const
22011 is not required [conv.qual]. It would be normal to set this flag in
22012 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
22013 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
22014 This is the outermost level of a deduction, and PARM can be more CV
22015 qualified at this point.
22016 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
22017 This is the outermost level of a deduction, and PARM can be less CV
22018 qualified at this point. */
22021 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
22027 int strict_in
= strict
;
22028 tsubst_flags_t complain
= (explain_p
22029 ? tf_warning_or_error
22032 /* I don't think this will do the right thing with respect to types.
22033 But the only case I've seen it in so far has been array bounds, where
22034 signedness is the only information lost, and I think that will be
22036 while (CONVERT_EXPR_P (parm
))
22037 parm
= TREE_OPERAND (parm
, 0);
22039 if (arg
== error_mark_node
)
22040 return unify_invalid (explain_p
);
22041 if (arg
== unknown_type_node
22042 || arg
== init_list_type_node
)
22043 /* We can't deduce anything from this, but we might get all the
22044 template args from other function args. */
22045 return unify_success (explain_p
);
22047 if (parm
== any_targ_node
|| arg
== any_targ_node
)
22048 return unify_success (explain_p
);
22050 /* If PARM uses template parameters, then we can't bail out here,
22051 even if ARG == PARM, since we won't record unifications for the
22052 template parameters. We might need them if we're trying to
22053 figure out which of two things is more specialized. */
22054 if (arg
== parm
&& !uses_template_parms (parm
))
22055 return unify_success (explain_p
);
22057 /* Handle init lists early, so the rest of the function can assume
22058 we're dealing with a type. */
22059 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
22063 tree orig_parm
= parm
;
22065 /* Replace T with std::initializer_list<T> for deduction. */
22066 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
22067 && flag_deduce_init_list
)
22068 parm
= listify (parm
);
22070 if (!is_std_init_list (parm
)
22071 && TREE_CODE (parm
) != ARRAY_TYPE
)
22072 /* We can only deduce from an initializer list argument if the
22073 parameter is std::initializer_list or an array; otherwise this
22074 is a non-deduced context. */
22075 return unify_success (explain_p
);
22077 if (TREE_CODE (parm
) == ARRAY_TYPE
)
22078 elttype
= TREE_TYPE (parm
);
22081 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
22082 /* Deduction is defined in terms of a single type, so just punt
22083 on the (bizarre) std::initializer_list<T...>. */
22084 if (PACK_EXPANSION_P (elttype
))
22085 return unify_success (explain_p
);
22088 if (strict
!= DEDUCE_EXACT
22089 && TYPE_P (elttype
)
22090 && !uses_deducible_template_parms (elttype
))
22091 /* If ELTTYPE has no deducible template parms, skip deduction from
22092 the list elements. */;
22094 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
22096 int elt_strict
= strict
;
22098 if (elt
== error_mark_node
)
22099 return unify_invalid (explain_p
);
22101 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
22103 tree type
= TREE_TYPE (elt
);
22104 if (type
== error_mark_node
)
22105 return unify_invalid (explain_p
);
22106 /* It should only be possible to get here for a call. */
22107 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
22108 elt_strict
|= maybe_adjust_types_for_deduction
22109 (DEDUCE_CALL
, &elttype
, &type
, elt
);
22113 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
22117 if (TREE_CODE (parm
) == ARRAY_TYPE
22118 && deducible_array_bound (TYPE_DOMAIN (parm
)))
22120 /* Also deduce from the length of the initializer list. */
22121 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
22122 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
22123 if (idx
== error_mark_node
)
22124 return unify_invalid (explain_p
);
22125 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
22129 /* If the std::initializer_list<T> deduction worked, replace the
22130 deduced A with std::initializer_list<A>. */
22131 if (orig_parm
!= parm
)
22133 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
22134 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
22135 targ
= listify (targ
);
22136 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
22138 return unify_success (explain_p
);
22141 /* If parm and arg aren't the same kind of thing (template, type, or
22142 expression), fail early. */
22143 if (pa_kind (parm
) != pa_kind (arg
))
22144 return unify_invalid (explain_p
);
22146 /* Immediately reject some pairs that won't unify because of
22147 cv-qualification mismatches. */
22148 if (TREE_CODE (arg
) == TREE_CODE (parm
)
22150 /* It is the elements of the array which hold the cv quals of an array
22151 type, and the elements might be template type parms. We'll check
22152 when we recurse. */
22153 && TREE_CODE (arg
) != ARRAY_TYPE
22154 /* We check the cv-qualifiers when unifying with template type
22155 parameters below. We want to allow ARG `const T' to unify with
22156 PARM `T' for example, when computing which of two templates
22157 is more specialized, for example. */
22158 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
22159 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
22160 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22162 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
22163 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
22164 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
22165 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
22166 strict
&= ~UNIFY_ALLOW_DERIVED
;
22167 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
22168 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
22170 switch (TREE_CODE (parm
))
22172 case TYPENAME_TYPE
:
22174 case UNBOUND_CLASS_TEMPLATE
:
22175 /* In a type which contains a nested-name-specifier, template
22176 argument values cannot be deduced for template parameters used
22177 within the nested-name-specifier. */
22178 return unify_success (explain_p
);
22180 case TEMPLATE_TYPE_PARM
:
22181 case TEMPLATE_TEMPLATE_PARM
:
22182 case BOUND_TEMPLATE_TEMPLATE_PARM
:
22183 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
22184 if (error_operand_p (tparm
))
22185 return unify_invalid (explain_p
);
22187 if (TEMPLATE_TYPE_LEVEL (parm
)
22188 != template_decl_level (tparm
))
22189 /* The PARM is not one we're trying to unify. Just check
22190 to see if it matches ARG. */
22192 if (TREE_CODE (arg
) == TREE_CODE (parm
)
22193 && (is_auto (parm
) ? is_auto (arg
)
22194 : same_type_p (parm
, arg
)))
22195 return unify_success (explain_p
);
22197 return unify_type_mismatch (explain_p
, parm
, arg
);
22199 idx
= TEMPLATE_TYPE_IDX (parm
);
22200 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
22201 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
22202 if (error_operand_p (tparm
))
22203 return unify_invalid (explain_p
);
22205 /* Check for mixed types and values. */
22206 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
22207 && TREE_CODE (tparm
) != TYPE_DECL
)
22208 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
22209 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
22210 gcc_unreachable ();
22212 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22214 if ((strict_in
& UNIFY_ALLOW_DERIVED
)
22215 && CLASS_TYPE_P (arg
))
22217 /* First try to match ARG directly. */
22218 tree t
= try_class_unification (tparms
, targs
, parm
, arg
,
22222 /* Otherwise, look for a suitable base of ARG, as below. */
22223 enum template_base_result r
;
22224 r
= get_template_base (tparms
, targs
, parm
, arg
,
22227 return unify_no_common_base (explain_p
, r
, parm
, arg
);
22231 /* ARG must be constructed from a template class or a template
22232 template parameter. */
22233 else if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
22234 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
22235 return unify_template_deduction_failure (explain_p
, parm
, arg
);
22237 /* Deduce arguments T, i from TT<T> or TT<i>. */
22238 if (unify_bound_ttp_args (tparms
, targs
, parm
, arg
, explain_p
))
22241 arg
= TYPE_TI_TEMPLATE (arg
);
22243 /* Fall through to deduce template name. */
22246 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
22247 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22249 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
22251 /* Simple cases: Value already set, does match or doesn't. */
22252 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
22253 return unify_success (explain_p
);
22255 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
22259 /* If PARM is `const T' and ARG is only `int', we don't have
22260 a match unless we are allowing additional qualification.
22261 If ARG is `const int' and PARM is just `T' that's OK;
22262 that binds `const int' to `T'. */
22263 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
22265 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22267 /* Consider the case where ARG is `const volatile int' and
22268 PARM is `const T'. Then, T should be `volatile int'. */
22269 arg
= cp_build_qualified_type_real
22270 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
22271 if (arg
== error_mark_node
)
22272 return unify_invalid (explain_p
);
22274 /* Simple cases: Value already set, does match or doesn't. */
22275 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
22276 return unify_success (explain_p
);
22278 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
22280 /* Make sure that ARG is not a variable-sized array. (Note
22281 that were talking about variable-sized arrays (like
22282 `int[n]'), rather than arrays of unknown size (like
22283 `int[]').) We'll get very confused by such a type since
22284 the bound of the array is not constant, and therefore
22285 not mangleable. Besides, such types are not allowed in
22286 ISO C++, so we can do as we please here. We do allow
22287 them for 'auto' deduction, since that isn't ABI-exposed. */
22288 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
22289 return unify_vla_arg (explain_p
, arg
);
22291 /* Strip typedefs as in convert_template_argument. */
22292 arg
= canonicalize_type_argument (arg
, tf_none
);
22295 /* If ARG is a parameter pack or an expansion, we cannot unify
22296 against it unless PARM is also a parameter pack. */
22297 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
22298 && !template_parameter_pack_p (parm
))
22299 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
22301 /* If the argument deduction results is a METHOD_TYPE,
22302 then there is a problem.
22303 METHOD_TYPE doesn't map to any real C++ type the result of
22304 the deduction cannot be of that type. */
22305 if (TREE_CODE (arg
) == METHOD_TYPE
)
22306 return unify_method_type_error (explain_p
, arg
);
22308 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
22309 return unify_success (explain_p
);
22311 case TEMPLATE_PARM_INDEX
:
22312 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
22313 if (error_operand_p (tparm
))
22314 return unify_invalid (explain_p
);
22316 if (TEMPLATE_PARM_LEVEL (parm
)
22317 != template_decl_level (tparm
))
22319 /* The PARM is not one we're trying to unify. Just check
22320 to see if it matches ARG. */
22321 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
22322 && cp_tree_equal (parm
, arg
));
22324 unify_expression_unequal (explain_p
, parm
, arg
);
22328 idx
= TEMPLATE_PARM_IDX (parm
);
22329 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
22333 if ((strict
& UNIFY_ALLOW_INTEGER
)
22334 && TREE_TYPE (targ
) && TREE_TYPE (arg
)
22335 && CP_INTEGRAL_TYPE_P (TREE_TYPE (targ
)))
22336 /* We're deducing from an array bound, the type doesn't matter. */
22337 arg
= fold_convert (TREE_TYPE (targ
), arg
);
22338 int x
= !cp_tree_equal (targ
, arg
);
22340 unify_inconsistency (explain_p
, parm
, targ
, arg
);
22344 /* [temp.deduct.type] If, in the declaration of a function template
22345 with a non-type template-parameter, the non-type
22346 template-parameter is used in an expression in the function
22347 parameter-list and, if the corresponding template-argument is
22348 deduced, the template-argument type shall match the type of the
22349 template-parameter exactly, except that a template-argument
22350 deduced from an array bound may be of any integral type.
22351 The non-type parameter might use already deduced type parameters. */
22352 tparm
= TREE_TYPE (parm
);
22353 if (TEMPLATE_PARM_LEVEL (parm
) > TMPL_ARGS_DEPTH (targs
))
22354 /* We don't have enough levels of args to do any substitution. This
22355 can happen in the context of -fnew-ttp-matching. */;
22358 ++processing_template_decl
;
22359 tparm
= tsubst (tparm
, targs
, tf_none
, NULL_TREE
);
22360 --processing_template_decl
;
22362 if (tree a
= type_uses_auto (tparm
))
22364 tparm
= do_auto_deduction (tparm
, arg
, a
, complain
, adc_unify
);
22365 if (tparm
== error_mark_node
)
22370 if (!TREE_TYPE (arg
))
22371 /* Template-parameter dependent expression. Just accept it for now.
22372 It will later be processed in convert_template_argument. */
22374 else if (same_type_p (non_reference (TREE_TYPE (arg
)),
22375 non_reference (tparm
)))
22377 else if ((strict
& UNIFY_ALLOW_INTEGER
)
22378 && CP_INTEGRAL_TYPE_P (tparm
))
22379 /* Convert the ARG to the type of PARM; the deduced non-type
22380 template argument must exactly match the types of the
22381 corresponding parameter. */
22382 arg
= fold (build_nop (tparm
, arg
));
22383 else if (uses_template_parms (tparm
))
22385 /* We haven't deduced the type of this parameter yet. */
22386 if (cxx_dialect
>= cxx17
22387 /* We deduce from array bounds in try_array_deduction. */
22388 && !(strict
& UNIFY_ALLOW_INTEGER
))
22390 /* Deduce it from the non-type argument. */
22391 tree atype
= TREE_TYPE (arg
);
22392 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
22394 UNIFY_ALLOW_NONE
, explain_p
);
22397 /* Try again later. */
22398 return unify_success (explain_p
);
22401 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
22403 /* If ARG is a parameter pack or an expansion, we cannot unify
22404 against it unless PARM is also a parameter pack. */
22405 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
22406 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
22407 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
22410 bool removed_attr
= false;
22411 arg
= strip_typedefs_expr (arg
, &removed_attr
);
22413 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
22414 return unify_success (explain_p
);
22418 /* A pointer-to-member constant can be unified only with
22419 another constant. */
22420 if (TREE_CODE (arg
) != PTRMEM_CST
)
22421 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
22423 /* Just unify the class member. It would be useless (and possibly
22424 wrong, depending on the strict flags) to unify also
22425 PTRMEM_CST_CLASS, because we want to be sure that both parm and
22426 arg refer to the same variable, even if through different
22427 classes. For instance:
22429 struct A { int x; };
22432 Unification of &A::x and &B::x must succeed. */
22433 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
22434 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
22439 if (!TYPE_PTR_P (arg
))
22440 return unify_type_mismatch (explain_p
, parm
, arg
);
22442 /* [temp.deduct.call]
22444 A can be another pointer or pointer to member type that can
22445 be converted to the deduced A via a qualification
22446 conversion (_conv.qual_).
22448 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
22449 This will allow for additional cv-qualification of the
22450 pointed-to types if appropriate. */
22452 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
22453 /* The derived-to-base conversion only persists through one
22454 level of pointers. */
22455 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
22457 return unify (tparms
, targs
, TREE_TYPE (parm
),
22458 TREE_TYPE (arg
), strict
, explain_p
);
22461 case REFERENCE_TYPE
:
22462 if (!TYPE_REF_P (arg
))
22463 return unify_type_mismatch (explain_p
, parm
, arg
);
22464 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
22465 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
22468 if (TREE_CODE (arg
) != ARRAY_TYPE
)
22469 return unify_type_mismatch (explain_p
, parm
, arg
);
22470 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
22471 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
22472 return unify_type_mismatch (explain_p
, parm
, arg
);
22473 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
22474 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
22475 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
22476 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
22477 TYPE_DOMAIN (arg
), explain_p
);
22478 return unify_success (explain_p
);
22485 case ENUMERAL_TYPE
:
22488 if (TREE_CODE (arg
) != TREE_CODE (parm
))
22489 return unify_type_mismatch (explain_p
, parm
, arg
);
22491 /* We have already checked cv-qualification at the top of the
22493 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
22494 return unify_type_mismatch (explain_p
, parm
, arg
);
22496 /* As far as unification is concerned, this wins. Later checks
22497 will invalidate it if necessary. */
22498 return unify_success (explain_p
);
22500 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
22501 /* Type INTEGER_CST can come from ordinary constant template args. */
22503 while (CONVERT_EXPR_P (arg
))
22504 arg
= TREE_OPERAND (arg
, 0);
22506 if (TREE_CODE (arg
) != INTEGER_CST
)
22507 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22508 return (tree_int_cst_equal (parm
, arg
)
22509 ? unify_success (explain_p
)
22510 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
22514 int i
, len
, argslen
;
22515 int parm_variadic_p
= 0;
22517 if (TREE_CODE (arg
) != TREE_VEC
)
22518 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22520 len
= TREE_VEC_LENGTH (parm
);
22521 argslen
= TREE_VEC_LENGTH (arg
);
22523 /* Check for pack expansions in the parameters. */
22524 for (i
= 0; i
< len
; ++i
)
22526 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
22529 /* We can unify against something with a trailing
22531 parm_variadic_p
= 1;
22533 /* [temp.deduct.type]/9: If the template argument list of
22534 P contains a pack expansion that is not the last
22535 template argument, the entire template argument list
22536 is a non-deduced context. */
22537 return unify_success (explain_p
);
22541 /* If we don't have enough arguments to satisfy the parameters
22542 (not counting the pack expression at the end), or we have
22543 too many arguments for a parameter list that doesn't end in
22544 a pack expression, we can't unify. */
22545 if (parm_variadic_p
22546 ? argslen
< len
- parm_variadic_p
22548 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
22550 /* Unify all of the parameters that precede the (optional)
22551 pack expression. */
22552 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
22554 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
22555 TREE_VEC_ELT (parm
, i
),
22556 TREE_VEC_ELT (arg
, i
),
22557 UNIFY_ALLOW_NONE
, explain_p
);
22559 if (parm_variadic_p
)
22560 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
22562 /*subr=*/true, explain_p
);
22563 return unify_success (explain_p
);
22568 if (TREE_CODE (arg
) != TREE_CODE (parm
))
22569 return unify_type_mismatch (explain_p
, parm
, arg
);
22571 if (TYPE_PTRMEMFUNC_P (parm
))
22573 if (!TYPE_PTRMEMFUNC_P (arg
))
22574 return unify_type_mismatch (explain_p
, parm
, arg
);
22576 return unify (tparms
, targs
,
22577 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
22578 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
22579 strict
, explain_p
);
22581 else if (TYPE_PTRMEMFUNC_P (arg
))
22582 return unify_type_mismatch (explain_p
, parm
, arg
);
22584 if (CLASSTYPE_TEMPLATE_INFO (parm
))
22586 tree t
= NULL_TREE
;
22588 if (strict_in
& UNIFY_ALLOW_DERIVED
)
22590 /* First, we try to unify the PARM and ARG directly. */
22591 t
= try_class_unification (tparms
, targs
,
22592 parm
, arg
, explain_p
);
22596 /* Fallback to the special case allowed in
22597 [temp.deduct.call]:
22599 If P is a class, and P has the form
22600 template-id, then A can be a derived class of
22601 the deduced A. Likewise, if P is a pointer to
22602 a class of the form template-id, A can be a
22603 pointer to a derived class pointed to by the
22605 enum template_base_result r
;
22606 r
= get_template_base (tparms
, targs
, parm
, arg
,
22611 /* Don't give the derived diagnostic if we're
22612 already dealing with the same template. */
22614 = (CLASSTYPE_TEMPLATE_INFO (arg
)
22615 && (CLASSTYPE_TI_TEMPLATE (parm
)
22616 == CLASSTYPE_TI_TEMPLATE (arg
)));
22617 return unify_no_common_base (explain_p
&& !same_template
,
22622 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
22623 && (CLASSTYPE_TI_TEMPLATE (parm
)
22624 == CLASSTYPE_TI_TEMPLATE (arg
)))
22625 /* Perhaps PARM is something like S<U> and ARG is S<int>.
22626 Then, we should unify `int' and `U'. */
22629 /* There's no chance of unification succeeding. */
22630 return unify_type_mismatch (explain_p
, parm
, arg
);
22632 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
22633 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
22635 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
22636 return unify_type_mismatch (explain_p
, parm
, arg
);
22637 return unify_success (explain_p
);
22640 case FUNCTION_TYPE
:
22642 unsigned int nargs
;
22647 if (TREE_CODE (arg
) != TREE_CODE (parm
))
22648 return unify_type_mismatch (explain_p
, parm
, arg
);
22650 /* CV qualifications for methods can never be deduced, they must
22651 match exactly. We need to check them explicitly here,
22652 because type_unification_real treats them as any other
22653 cv-qualified parameter. */
22654 if (TREE_CODE (parm
) == METHOD_TYPE
22655 && (!check_cv_quals_for_unify
22657 class_of_this_parm (arg
),
22658 class_of_this_parm (parm
))))
22659 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22660 if (TREE_CODE (arg
) == FUNCTION_TYPE
22661 && type_memfn_quals (parm
) != type_memfn_quals (arg
))
22662 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22663 if (type_memfn_rqual (parm
) != type_memfn_rqual (arg
))
22664 return unify_type_mismatch (explain_p
, parm
, arg
);
22666 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
22667 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
22669 nargs
= list_length (TYPE_ARG_TYPES (arg
));
22670 args
= XALLOCAVEC (tree
, nargs
);
22671 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
22672 a
!= NULL_TREE
&& a
!= void_list_node
;
22673 a
= TREE_CHAIN (a
), ++i
)
22674 args
[i
] = TREE_VALUE (a
);
22677 if (type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
22678 args
, nargs
, 1, DEDUCE_EXACT
,
22682 if (flag_noexcept_type
)
22684 tree pspec
= TYPE_RAISES_EXCEPTIONS (parm
);
22685 tree aspec
= canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (arg
));
22686 if (pspec
== NULL_TREE
) pspec
= noexcept_false_spec
;
22687 if (aspec
== NULL_TREE
) aspec
= noexcept_false_spec
;
22688 if (TREE_PURPOSE (pspec
) && TREE_PURPOSE (aspec
)
22689 && uses_template_parms (TREE_PURPOSE (pspec
)))
22690 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_PURPOSE (pspec
),
22691 TREE_PURPOSE (aspec
),
22692 UNIFY_ALLOW_NONE
, explain_p
);
22693 else if (nothrow_spec_p (pspec
) && !nothrow_spec_p (aspec
))
22694 return unify_type_mismatch (explain_p
, parm
, arg
);
22701 /* Unify a pointer to member with a pointer to member function, which
22702 deduces the type of the member as a function type. */
22703 if (TYPE_PTRMEMFUNC_P (arg
))
22705 /* Check top-level cv qualifiers */
22706 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
22707 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22709 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
22710 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
22711 UNIFY_ALLOW_NONE
, explain_p
);
22713 /* Determine the type of the function we are unifying against. */
22714 tree fntype
= static_fn_type (arg
);
22716 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
22719 if (TREE_CODE (arg
) != OFFSET_TYPE
)
22720 return unify_type_mismatch (explain_p
, parm
, arg
);
22721 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
22722 TYPE_OFFSET_BASETYPE (arg
),
22723 UNIFY_ALLOW_NONE
, explain_p
);
22724 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
22725 strict
, explain_p
);
22728 if (DECL_TEMPLATE_PARM_P (parm
))
22729 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
22730 if (arg
!= scalar_constant_value (parm
))
22731 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22732 return unify_success (explain_p
);
22735 case TEMPLATE_DECL
:
22736 /* Matched cases are handled by the ARG == PARM test above. */
22737 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22740 /* We might get a variable as a non-type template argument in parm if the
22741 corresponding parameter is type-dependent. Make any necessary
22742 adjustments based on whether arg is a reference. */
22743 if (CONSTANT_CLASS_P (arg
))
22744 parm
= fold_non_dependent_expr (parm
, complain
);
22745 else if (REFERENCE_REF_P (arg
))
22747 tree sub
= TREE_OPERAND (arg
, 0);
22749 if (TREE_CODE (sub
) == ADDR_EXPR
)
22750 arg
= TREE_OPERAND (sub
, 0);
22752 /* Now use the normal expression code to check whether they match. */
22755 case TYPE_ARGUMENT_PACK
:
22756 case NONTYPE_ARGUMENT_PACK
:
22757 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
22758 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
22761 case DECLTYPE_TYPE
:
22762 case UNDERLYING_TYPE
:
22763 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
22764 or UNDERLYING_TYPE nodes. */
22765 return unify_success (explain_p
);
22768 /* Unification fails if we hit an error node. */
22769 return unify_invalid (explain_p
);
22772 if (REFERENCE_REF_P (parm
))
22774 bool pexp
= PACK_EXPANSION_P (arg
);
22776 arg
= PACK_EXPANSION_PATTERN (arg
);
22777 if (REFERENCE_REF_P (arg
))
22778 arg
= TREE_OPERAND (arg
, 0);
22780 arg
= make_pack_expansion (arg
, complain
);
22781 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
22782 strict
, explain_p
);
22787 /* An unresolved overload is a nondeduced context. */
22788 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
22789 return unify_success (explain_p
);
22790 gcc_assert (EXPR_P (parm
)
22791 || COMPOUND_LITERAL_P (parm
)
22792 || 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>);
22802 template<typename T>
22803 void foo(A<T, T{}>);
22805 This is a "non-deduced context":
22809 The non-deduced contexts are:
22811 --A non-type template argument or an array bound in which
22812 a subexpression references a template parameter.
22814 In these cases, we assume deduction succeeded, but don't
22815 actually infer any unifications. */
22817 if (!uses_template_parms (parm
)
22818 && !template_args_equal (parm
, arg
))
22819 return unify_expression_unequal (explain_p
, parm
, arg
);
22821 return unify_success (explain_p
);
22824 #undef RECUR_AND_CHECK_FAILURE
22826 /* Note that DECL can be defined in this translation unit, if
22830 mark_definable (tree decl
)
22833 DECL_NOT_REALLY_EXTERN (decl
) = 1;
22834 FOR_EACH_CLONE (clone
, decl
)
22835 DECL_NOT_REALLY_EXTERN (clone
) = 1;
22838 /* Called if RESULT is explicitly instantiated, or is a member of an
22839 explicitly instantiated class. */
22842 mark_decl_instantiated (tree result
, int extern_p
)
22844 SET_DECL_EXPLICIT_INSTANTIATION (result
);
22846 /* If this entity has already been written out, it's too late to
22847 make any modifications. */
22848 if (TREE_ASM_WRITTEN (result
))
22851 /* For anonymous namespace we don't need to do anything. */
22852 if (decl_anon_ns_mem_p (result
))
22854 gcc_assert (!TREE_PUBLIC (result
));
22858 if (TREE_CODE (result
) != FUNCTION_DECL
)
22859 /* The TREE_PUBLIC flag for function declarations will have been
22860 set correctly by tsubst. */
22861 TREE_PUBLIC (result
) = 1;
22863 /* This might have been set by an earlier implicit instantiation. */
22864 DECL_COMDAT (result
) = 0;
22867 DECL_NOT_REALLY_EXTERN (result
) = 0;
22870 mark_definable (result
);
22871 mark_needed (result
);
22872 /* Always make artificials weak. */
22873 if (DECL_ARTIFICIAL (result
) && flag_weak
)
22874 comdat_linkage (result
);
22875 /* For WIN32 we also want to put explicit instantiations in
22876 linkonce sections. */
22877 else if (TREE_PUBLIC (result
))
22878 maybe_make_one_only (result
);
22879 if (TREE_CODE (result
) == FUNCTION_DECL
22880 && DECL_TEMPLATE_INSTANTIATED (result
))
22881 /* If the function has already been instantiated, clear DECL_EXTERNAL,
22882 since start_preparsed_function wouldn't have if we had an earlier
22883 extern explicit instantiation. */
22884 DECL_EXTERNAL (result
) = 0;
22887 /* If EXTERN_P, then this function will not be emitted -- unless
22888 followed by an explicit instantiation, at which point its linkage
22889 will be adjusted. If !EXTERN_P, then this function will be
22890 emitted here. In neither circumstance do we want
22891 import_export_decl to adjust the linkage. */
22892 DECL_INTERFACE_KNOWN (result
) = 1;
22895 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
22896 important template arguments. If any are missing, we check whether
22897 they're important by using error_mark_node for substituting into any
22898 args that were used for partial ordering (the ones between ARGS and END)
22899 and seeing if it bubbles up. */
22902 check_undeduced_parms (tree targs
, tree args
, tree end
)
22904 bool found
= false;
22906 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
22907 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
22910 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
22914 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
22915 if (substed
== error_mark_node
)
22921 /* Given two function templates PAT1 and PAT2, return:
22923 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
22924 -1 if PAT2 is more specialized than PAT1.
22925 0 if neither is more specialized.
22927 LEN indicates the number of parameters we should consider
22928 (defaulted parameters should not be considered).
22930 The 1998 std underspecified function template partial ordering, and
22931 DR214 addresses the issue. We take pairs of arguments, one from
22932 each of the templates, and deduce them against each other. One of
22933 the templates will be more specialized if all the *other*
22934 template's arguments deduce against its arguments and at least one
22935 of its arguments *does* *not* deduce against the other template's
22936 corresponding argument. Deduction is done as for class templates.
22937 The arguments used in deduction have reference and top level cv
22938 qualifiers removed. Iff both arguments were originally reference
22939 types *and* deduction succeeds in both directions, an lvalue reference
22940 wins against an rvalue reference and otherwise the template
22941 with the more cv-qualified argument wins for that pairing (if
22942 neither is more cv-qualified, they both are equal). Unlike regular
22943 deduction, after all the arguments have been deduced in this way,
22944 we do *not* verify the deduced template argument values can be
22945 substituted into non-deduced contexts.
22947 The logic can be a bit confusing here, because we look at deduce1 and
22948 targs1 to see if pat2 is at least as specialized, and vice versa; if we
22949 can find template arguments for pat1 to make arg1 look like arg2, that
22950 means that arg2 is at least as specialized as arg1. */
22953 more_specialized_fn (tree pat1
, tree pat2
, int len
)
22955 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
22956 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
22957 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
22958 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
22959 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
22960 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
22961 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
22962 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
22963 tree origs1
, origs2
;
22964 bool lose1
= false;
22965 bool lose2
= false;
22967 /* Remove the this parameter from non-static member functions. If
22968 one is a non-static member function and the other is not a static
22969 member function, remove the first parameter from that function
22970 also. This situation occurs for operator functions where we
22971 locate both a member function (with this pointer) and non-member
22972 operator (with explicit first operand). */
22973 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
22975 len
--; /* LEN is the number of significant arguments for DECL1 */
22976 args1
= TREE_CHAIN (args1
);
22977 if (!DECL_STATIC_FUNCTION_P (decl2
))
22978 args2
= TREE_CHAIN (args2
);
22980 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
22982 args2
= TREE_CHAIN (args2
);
22983 if (!DECL_STATIC_FUNCTION_P (decl1
))
22986 args1
= TREE_CHAIN (args1
);
22990 /* If only one is a conversion operator, they are unordered. */
22991 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
22994 /* Consider the return type for a conversion function */
22995 if (DECL_CONV_FN_P (decl1
))
22997 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
22998 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
23002 processing_template_decl
++;
23008 /* Stop when an ellipsis is seen. */
23009 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
23011 tree arg1
= TREE_VALUE (args1
);
23012 tree arg2
= TREE_VALUE (args2
);
23013 int deduce1
, deduce2
;
23019 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
23020 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
23022 /* When both arguments are pack expansions, we need only
23023 unify the patterns themselves. */
23024 arg1
= PACK_EXPANSION_PATTERN (arg1
);
23025 arg2
= PACK_EXPANSION_PATTERN (arg2
);
23027 /* This is the last comparison we need to do. */
23031 /* DR 1847: If a particular P contains no template-parameters that
23032 participate in template argument deduction, that P is not used to
23033 determine the ordering. */
23034 if (!uses_deducible_template_parms (arg1
)
23035 && !uses_deducible_template_parms (arg2
))
23038 if (TYPE_REF_P (arg1
))
23040 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
23041 arg1
= TREE_TYPE (arg1
);
23042 quals1
= cp_type_quals (arg1
);
23045 if (TYPE_REF_P (arg2
))
23047 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
23048 arg2
= TREE_TYPE (arg2
);
23049 quals2
= cp_type_quals (arg2
);
23052 arg1
= TYPE_MAIN_VARIANT (arg1
);
23053 arg2
= TYPE_MAIN_VARIANT (arg2
);
23055 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
23057 int i
, len2
= remaining_arguments (args2
);
23058 tree parmvec
= make_tree_vec (1);
23059 tree argvec
= make_tree_vec (len2
);
23062 /* Setup the parameter vector, which contains only ARG1. */
23063 TREE_VEC_ELT (parmvec
, 0) = arg1
;
23065 /* Setup the argument vector, which contains the remaining
23067 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
23068 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
23070 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
23071 argvec
, DEDUCE_EXACT
,
23072 /*subr=*/true, /*explain_p=*/false)
23075 /* We cannot deduce in the other direction, because ARG1 is
23076 a pack expansion but ARG2 is not. */
23079 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
23081 int i
, len1
= remaining_arguments (args1
);
23082 tree parmvec
= make_tree_vec (1);
23083 tree argvec
= make_tree_vec (len1
);
23086 /* Setup the parameter vector, which contains only ARG1. */
23087 TREE_VEC_ELT (parmvec
, 0) = arg2
;
23089 /* Setup the argument vector, which contains the remaining
23091 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
23092 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
23094 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
23095 argvec
, DEDUCE_EXACT
,
23096 /*subr=*/true, /*explain_p=*/false)
23099 /* We cannot deduce in the other direction, because ARG2 is
23100 a pack expansion but ARG1 is not.*/
23106 /* The normal case, where neither argument is a pack
23108 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
23109 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
23111 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
23112 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
23116 /* If we couldn't deduce arguments for tparms1 to make arg1 match
23117 arg2, then arg2 is not as specialized as arg1. */
23123 /* "If, for a given type, deduction succeeds in both directions
23124 (i.e., the types are identical after the transformations above)
23125 and both P and A were reference types (before being replaced with
23126 the type referred to above):
23127 - if the type from the argument template was an lvalue reference and
23128 the type from the parameter template was not, the argument type is
23129 considered to be more specialized than the other; otherwise,
23130 - if the type from the argument template is more cv-qualified
23131 than the type from the parameter template (as described above),
23132 the argument type is considered to be more specialized than the other;
23134 - neither type is more specialized than the other." */
23136 if (deduce1
&& deduce2
)
23138 if (ref1
&& ref2
&& ref1
!= ref2
)
23145 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
23147 if ((quals1
& quals2
) == quals2
)
23149 if ((quals1
& quals2
) == quals1
)
23154 if (lose1
&& lose2
)
23155 /* We've failed to deduce something in either direction.
23156 These must be unordered. */
23161 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
23162 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
23163 /* We have already processed all of the arguments in our
23164 handing of the pack expansion type. */
23167 args1
= TREE_CHAIN (args1
);
23168 args2
= TREE_CHAIN (args2
);
23171 /* "In most cases, all template parameters must have values in order for
23172 deduction to succeed, but for partial ordering purposes a template
23173 parameter may remain without a value provided it is not used in the
23174 types being used for partial ordering."
23176 Thus, if we are missing any of the targs1 we need to substitute into
23177 origs1, then pat2 is not as specialized as pat1. This can happen when
23178 there is a nondeduced context. */
23179 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
23181 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
23184 processing_template_decl
--;
23186 /* If both deductions succeed, the partial ordering selects the more
23187 constrained template. */
23188 if (!lose1
&& !lose2
)
23190 tree c1
= get_constraints (DECL_TEMPLATE_RESULT (pat1
));
23191 tree c2
= get_constraints (DECL_TEMPLATE_RESULT (pat2
));
23192 lose1
= !subsumes_constraints (c1
, c2
);
23193 lose2
= !subsumes_constraints (c2
, c1
);
23196 /* All things being equal, if the next argument is a pack expansion
23197 for one function but not for the other, prefer the
23198 non-variadic function. FIXME this is bogus; see c++/41958. */
23200 && args1
&& TREE_VALUE (args1
)
23201 && args2
&& TREE_VALUE (args2
))
23203 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
23204 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
23207 if (lose1
== lose2
)
23215 /* Determine which of two partial specializations of TMPL is more
23218 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
23219 to the first partial specialization. The TREE_PURPOSE is the
23220 innermost set of template parameters for the partial
23221 specialization. PAT2 is similar, but for the second template.
23223 Return 1 if the first partial specialization is more specialized;
23224 -1 if the second is more specialized; 0 if neither is more
23227 See [temp.class.order] for information about determining which of
23228 two templates is more specialized. */
23231 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
23235 bool any_deductions
= false;
23237 tree tmpl1
= TREE_VALUE (pat1
);
23238 tree tmpl2
= TREE_VALUE (pat2
);
23239 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
23240 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
23242 /* Just like what happens for functions, if we are ordering between
23243 different template specializations, we may encounter dependent
23244 types in the arguments, and we need our dependency check functions
23245 to behave correctly. */
23246 ++processing_template_decl
;
23247 targs
= get_partial_spec_bindings (tmpl
, tmpl1
, specargs2
);
23251 any_deductions
= true;
23254 targs
= get_partial_spec_bindings (tmpl
, tmpl2
, specargs1
);
23258 any_deductions
= true;
23260 --processing_template_decl
;
23262 /* If both deductions succeed, the partial ordering selects the more
23263 constrained template. */
23264 if (!winner
&& any_deductions
)
23265 return more_constrained (tmpl1
, tmpl2
);
23267 /* In the case of a tie where at least one of the templates
23268 has a parameter pack at the end, the template with the most
23269 non-packed parameters wins. */
23272 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
23273 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
23275 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
23276 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
23277 int len1
= TREE_VEC_LENGTH (args1
);
23278 int len2
= TREE_VEC_LENGTH (args2
);
23280 /* We don't count the pack expansion at the end. */
23281 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
23283 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
23288 else if (len1
< len2
)
23295 /* Return the template arguments that will produce the function signature
23296 DECL from the function template FN, with the explicit template
23297 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
23298 also match. Return NULL_TREE if no satisfactory arguments could be
23302 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
23304 int ntparms
= DECL_NTPARMS (fn
);
23305 tree targs
= make_tree_vec (ntparms
);
23306 tree decl_type
= TREE_TYPE (decl
);
23307 tree decl_arg_types
;
23309 unsigned int nargs
, ix
;
23312 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
23314 /* Never do unification on the 'this' parameter. */
23315 decl_arg_types
= skip_artificial_parms_for (decl
,
23316 TYPE_ARG_TYPES (decl_type
));
23318 nargs
= list_length (decl_arg_types
);
23319 args
= XALLOCAVEC (tree
, nargs
);
23320 for (arg
= decl_arg_types
, ix
= 0;
23321 arg
!= NULL_TREE
&& arg
!= void_list_node
;
23322 arg
= TREE_CHAIN (arg
), ++ix
)
23323 args
[ix
] = TREE_VALUE (arg
);
23325 if (fn_type_unification (fn
, explicit_args
, targs
,
23327 (check_rettype
|| DECL_CONV_FN_P (fn
)
23328 ? TREE_TYPE (decl_type
) : NULL_TREE
),
23329 DEDUCE_EXACT
, LOOKUP_NORMAL
, NULL
,
23330 /*explain_p=*/false,
23332 == error_mark_node
)
23338 /* Return the innermost template arguments that, when applied to a partial
23339 specialization SPEC_TMPL of TMPL, yield the ARGS.
23341 For example, suppose we have:
23343 template <class T, class U> struct S {};
23344 template <class T> struct S<T*, int> {};
23346 Then, suppose we want to get `S<double*, int>'. SPEC_TMPL will be the
23347 partial specialization and the ARGS will be {double*, int}. The resulting
23348 vector will be {double}, indicating that `T' is bound to `double'. */
23351 get_partial_spec_bindings (tree tmpl
, tree spec_tmpl
, tree args
)
23353 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
23355 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (spec_tmpl
)));
23356 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
23358 tree innermost_deduced_args
;
23360 innermost_deduced_args
= make_tree_vec (ntparms
);
23361 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
23363 deduced_args
= copy_node (args
);
23364 SET_TMPL_ARGS_LEVEL (deduced_args
,
23365 TMPL_ARGS_DEPTH (deduced_args
),
23366 innermost_deduced_args
);
23369 deduced_args
= innermost_deduced_args
;
23371 bool tried_array_deduction
= (cxx_dialect
< cxx17
);
23373 if (unify (tparms
, deduced_args
,
23374 INNERMOST_TEMPLATE_ARGS (spec_args
),
23375 INNERMOST_TEMPLATE_ARGS (args
),
23376 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
23379 for (i
= 0; i
< ntparms
; ++i
)
23380 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
23382 if (!tried_array_deduction
)
23384 try_array_deduction (tparms
, innermost_deduced_args
,
23385 INNERMOST_TEMPLATE_ARGS (spec_args
));
23386 tried_array_deduction
= true;
23387 if (TREE_VEC_ELT (innermost_deduced_args
, i
))
23393 if (!push_tinst_level (spec_tmpl
, deduced_args
))
23395 excessive_deduction_depth
= true;
23399 /* Verify that nondeduced template arguments agree with the type
23400 obtained from argument deduction.
23404 struct A { typedef int X; };
23405 template <class T, class U> struct C {};
23406 template <class T> struct C<T, typename T::X> {};
23408 Then with the instantiation `C<A, int>', we can deduce that
23409 `T' is `A' but unify () does not check whether `typename T::X'
23411 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
23413 if (spec_args
!= error_mark_node
)
23414 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
23415 INNERMOST_TEMPLATE_ARGS (spec_args
),
23416 tmpl
, tf_none
, false, false);
23418 pop_tinst_level ();
23420 if (spec_args
== error_mark_node
23421 /* We only need to check the innermost arguments; the other
23422 arguments will always agree. */
23423 || !comp_template_args_porder (INNERMOST_TEMPLATE_ARGS (spec_args
),
23424 INNERMOST_TEMPLATE_ARGS (args
)))
23427 /* Now that we have bindings for all of the template arguments,
23428 ensure that the arguments deduced for the template template
23429 parameters have compatible template parameter lists. See the use
23430 of template_template_parm_bindings_ok_p in fn_type_unification
23431 for more information. */
23432 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
23435 return deduced_args
;
23438 // Compare two function templates T1 and T2 by deducing bindings
23439 // from one against the other. If both deductions succeed, compare
23440 // constraints to see which is more constrained.
23442 more_specialized_inst (tree t1
, tree t2
)
23447 if (get_bindings (t1
, DECL_TEMPLATE_RESULT (t2
), NULL_TREE
, true))
23453 if (get_bindings (t2
, DECL_TEMPLATE_RESULT (t1
), NULL_TREE
, true))
23459 // If both deductions succeed, then one may be more constrained.
23460 if (count
== 2 && fate
== 0)
23461 fate
= more_constrained (t1
, t2
);
23466 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
23467 Return the TREE_LIST node with the most specialized template, if
23468 any. If there is no most specialized template, the error_mark_node
23471 Note that this function does not look at, or modify, the
23472 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
23473 returned is one of the elements of INSTANTIATIONS, callers may
23474 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
23475 and retrieve it from the value returned. */
23478 most_specialized_instantiation (tree templates
)
23482 ++processing_template_decl
;
23485 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
23487 gcc_assert (TREE_VALUE (champ
) != TREE_VALUE (fn
));
23488 int fate
= more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
));
23493 /* Equally specialized, move to next function. If there
23494 is no next function, nothing's most specialized. */
23495 fn
= TREE_CHAIN (fn
);
23503 /* Now verify that champ is better than everything earlier in the
23504 instantiation list. */
23505 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
)) {
23506 if (more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
)) != 1)
23513 processing_template_decl
--;
23516 return error_mark_node
;
23521 /* If DECL is a specialization of some template, return the most
23522 general such template. Otherwise, returns NULL_TREE.
23524 For example, given:
23526 template <class T> struct S { template <class U> void f(U); };
23528 if TMPL is `template <class U> void S<int>::f(U)' this will return
23529 the full template. This function will not trace past partial
23530 specializations, however. For example, given in addition:
23532 template <class T> struct S<T*> { template <class U> void f(U); };
23534 if TMPL is `template <class U> void S<int*>::f(U)' this will return
23535 `template <class T> template <class U> S<T*>::f(U)'. */
23538 most_general_template (tree decl
)
23540 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
23542 if (tree tinfo
= get_template_info (decl
))
23543 decl
= TI_TEMPLATE (tinfo
);
23544 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
23545 template friend, or a FIELD_DECL for a capture pack. */
23546 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
23550 /* Look for more and more general templates. */
23551 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
23553 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
23554 (See cp-tree.h for details.) */
23555 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
23558 if (CLASS_TYPE_P (TREE_TYPE (decl
))
23559 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
23560 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
23563 /* Stop if we run into an explicitly specialized class template. */
23564 if (!DECL_NAMESPACE_SCOPE_P (decl
)
23565 && DECL_CONTEXT (decl
)
23566 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
23569 decl
= DECL_TI_TEMPLATE (decl
);
23575 /* Return the most specialized of the template partial specializations
23576 which can produce TARGET, a specialization of some class or variable
23577 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
23578 a TEMPLATE_DECL node corresponding to the partial specialization, while
23579 the TREE_PURPOSE is the set of template arguments that must be
23580 substituted into the template pattern in order to generate TARGET.
23582 If the choice of partial specialization is ambiguous, a diagnostic
23583 is issued, and the error_mark_node is returned. If there are no
23584 partial specializations matching TARGET, then NULL_TREE is
23585 returned, indicating that the primary template should be used. */
23588 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
23590 tree list
= NULL_TREE
;
23595 tree outer_args
= NULL_TREE
;
23598 if (TYPE_P (target
))
23600 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
23601 tmpl
= TI_TEMPLATE (tinfo
);
23602 args
= TI_ARGS (tinfo
);
23604 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
23606 tmpl
= TREE_OPERAND (target
, 0);
23607 args
= TREE_OPERAND (target
, 1);
23609 else if (VAR_P (target
))
23611 tree tinfo
= DECL_TEMPLATE_INFO (target
);
23612 tmpl
= TI_TEMPLATE (tinfo
);
23613 args
= TI_ARGS (tinfo
);
23616 gcc_unreachable ();
23618 tree main_tmpl
= most_general_template (tmpl
);
23620 /* For determining which partial specialization to use, only the
23621 innermost args are interesting. */
23622 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
23624 outer_args
= strip_innermost_template_args (args
, 1);
23625 args
= INNERMOST_TEMPLATE_ARGS (args
);
23628 /* The caller hasn't called push_to_top_level yet, but we need
23629 get_partial_spec_bindings to be done in non-template context so that we'll
23630 fully resolve everything. */
23631 processing_template_decl_sentinel ptds
;
23633 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
23636 tree spec_tmpl
= TREE_VALUE (t
);
23640 /* Substitute in the template args from the enclosing class. */
23641 ++processing_template_decl
;
23642 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
23643 --processing_template_decl
;
23646 if (spec_tmpl
== error_mark_node
)
23647 return error_mark_node
;
23649 spec_args
= get_partial_spec_bindings (tmpl
, spec_tmpl
, args
);
23653 spec_args
= add_to_template_args (outer_args
, spec_args
);
23655 /* Keep the candidate only if the constraints are satisfied,
23656 or if we're not compiling with concepts. */
23658 || constraints_satisfied_p (spec_tmpl
, spec_args
))
23660 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
23661 TREE_TYPE (list
) = TREE_TYPE (t
);
23669 ambiguous_p
= false;
23672 t
= TREE_CHAIN (t
);
23673 for (; t
; t
= TREE_CHAIN (t
))
23675 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
23682 t
= TREE_CHAIN (t
);
23685 ambiguous_p
= true;
23694 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
23696 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
23699 ambiguous_p
= true;
23707 char *spaces
= NULL
;
23708 if (!(complain
& tf_error
))
23709 return error_mark_node
;
23710 if (TYPE_P (target
))
23711 error ("ambiguous template instantiation for %q#T", target
);
23713 error ("ambiguous template instantiation for %q#D", target
);
23714 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
23715 for (t
= list
; t
; t
= TREE_CHAIN (t
))
23717 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
23718 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
23719 "%s %#qS", spaces
? spaces
: str
, subst
);
23720 spaces
= spaces
? spaces
: get_spaces (str
);
23723 return error_mark_node
;
23729 /* Explicitly instantiate DECL. */
23732 do_decl_instantiation (tree decl
, tree storage
)
23734 tree result
= NULL_TREE
;
23737 if (!decl
|| decl
== error_mark_node
)
23738 /* An error occurred, for which grokdeclarator has already issued
23739 an appropriate message. */
23741 else if (! DECL_LANG_SPECIFIC (decl
))
23743 error ("explicit instantiation of non-template %q#D", decl
);
23746 else if (DECL_DECLARED_CONCEPT_P (decl
))
23749 error ("explicit instantiation of variable concept %q#D", decl
);
23751 error ("explicit instantiation of function concept %q#D", decl
);
23755 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
23756 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
23758 if (VAR_P (decl
) && !var_templ
)
23760 /* There is an asymmetry here in the way VAR_DECLs and
23761 FUNCTION_DECLs are handled by grokdeclarator. In the case of
23762 the latter, the DECL we get back will be marked as a
23763 template instantiation, and the appropriate
23764 DECL_TEMPLATE_INFO will be set up. This does not happen for
23765 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
23766 should handle VAR_DECLs as it currently handles
23768 if (!DECL_CLASS_SCOPE_P (decl
))
23770 error ("%qD is not a static data member of a class template", decl
);
23773 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
23774 if (!result
|| !VAR_P (result
))
23776 error ("no matching template for %qD found", decl
);
23779 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
23781 error ("type %qT for explicit instantiation %qD does not match "
23782 "declared type %qT", TREE_TYPE (result
), decl
,
23787 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
23789 error ("explicit instantiation of %q#D", decl
);
23795 /* Check for various error cases. Note that if the explicit
23796 instantiation is valid the RESULT will currently be marked as an
23797 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
23798 until we get here. */
23800 if (DECL_TEMPLATE_SPECIALIZATION (result
))
23802 /* DR 259 [temp.spec].
23804 Both an explicit instantiation and a declaration of an explicit
23805 specialization shall not appear in a program unless the explicit
23806 instantiation follows a declaration of the explicit specialization.
23808 For a given set of template parameters, if an explicit
23809 instantiation of a template appears after a declaration of an
23810 explicit specialization for that template, the explicit
23811 instantiation has no effect. */
23814 else if (DECL_EXPLICIT_INSTANTIATION (result
))
23818 No program shall explicitly instantiate any template more
23821 We check DECL_NOT_REALLY_EXTERN so as not to complain when
23822 the first instantiation was `extern' and the second is not,
23823 and EXTERN_P for the opposite case. */
23824 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
23825 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
23826 /* If an "extern" explicit instantiation follows an ordinary
23827 explicit instantiation, the template is instantiated. */
23831 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
23833 error ("no matching template for %qD found", result
);
23836 else if (!DECL_TEMPLATE_INFO (result
))
23838 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
23842 if (storage
== NULL_TREE
)
23844 else if (storage
== ridpointers
[(int) RID_EXTERN
])
23846 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
23847 pedwarn (input_location
, OPT_Wpedantic
,
23848 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
23853 error ("storage class %qD applied to template instantiation", storage
);
23855 check_explicit_instantiation_namespace (result
);
23856 mark_decl_instantiated (result
, extern_p
);
23858 instantiate_decl (result
, /*defer_ok=*/true,
23859 /*expl_inst_class_mem_p=*/false);
23863 mark_class_instantiated (tree t
, int extern_p
)
23865 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
23866 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
23867 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
23868 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
23871 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
23872 rest_of_type_compilation (t
, 1);
23876 /* Called from do_type_instantiation through binding_table_foreach to
23877 do recursive instantiation for the type bound in ENTRY. */
23879 bt_instantiate_type_proc (binding_entry entry
, void *data
)
23881 tree storage
= *(tree
*) data
;
23883 if (MAYBE_CLASS_TYPE_P (entry
->type
)
23884 && CLASSTYPE_TEMPLATE_INFO (entry
->type
)
23885 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
23886 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
23889 /* Perform an explicit instantiation of template class T. STORAGE, if
23890 non-null, is the RID for extern, inline or static. COMPLAIN is
23891 nonzero if this is called from the parser, zero if called recursively,
23892 since the standard is unclear (as detailed below). */
23895 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
23900 int previous_instantiation_extern_p
= 0;
23902 if (TREE_CODE (t
) == TYPE_DECL
)
23905 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
23908 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
23910 error ("explicit instantiation of non-class template %qD", tmpl
);
23912 error ("explicit instantiation of non-template type %qT", t
);
23918 if (!COMPLETE_TYPE_P (t
))
23920 if (complain
& tf_error
)
23921 error ("explicit instantiation of %q#T before definition of template",
23926 if (storage
!= NULL_TREE
)
23928 if (!in_system_header_at (input_location
))
23930 if (storage
== ridpointers
[(int) RID_EXTERN
])
23932 if (cxx_dialect
== cxx98
)
23933 pedwarn (input_location
, OPT_Wpedantic
,
23934 "ISO C++ 1998 forbids the use of %<extern%> on "
23935 "explicit instantiations");
23938 pedwarn (input_location
, OPT_Wpedantic
,
23939 "ISO C++ forbids the use of %qE"
23940 " on explicit instantiations", storage
);
23943 if (storage
== ridpointers
[(int) RID_INLINE
])
23945 else if (storage
== ridpointers
[(int) RID_EXTERN
])
23947 else if (storage
== ridpointers
[(int) RID_STATIC
])
23951 error ("storage class %qD applied to template instantiation",
23957 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
23959 /* DR 259 [temp.spec].
23961 Both an explicit instantiation and a declaration of an explicit
23962 specialization shall not appear in a program unless the explicit
23963 instantiation follows a declaration of the explicit specialization.
23965 For a given set of template parameters, if an explicit
23966 instantiation of a template appears after a declaration of an
23967 explicit specialization for that template, the explicit
23968 instantiation has no effect. */
23971 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
23975 No program shall explicitly instantiate any template more
23978 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
23979 instantiation was `extern'. If EXTERN_P then the second is.
23980 These cases are OK. */
23981 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
23983 if (!previous_instantiation_extern_p
&& !extern_p
23984 && (complain
& tf_error
))
23985 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
23987 /* If we've already instantiated the template, just return now. */
23988 if (!CLASSTYPE_INTERFACE_ONLY (t
))
23992 check_explicit_instantiation_namespace (TYPE_NAME (t
));
23993 mark_class_instantiated (t
, extern_p
);
23998 /* In contrast to implicit instantiation, where only the
23999 declarations, and not the definitions, of members are
24000 instantiated, we have here:
24004 The explicit instantiation of a class template specialization
24005 implies the instantiation of all of its members not
24006 previously explicitly specialized in the translation unit
24007 containing the explicit instantiation.
24009 Of course, we can't instantiate member template classes, since we
24010 don't have any arguments for them. Note that the standard is
24011 unclear on whether the instantiation of the members are
24012 *explicit* instantiations or not. However, the most natural
24013 interpretation is that it should be an explicit
24015 for (tree fld
= TYPE_FIELDS (t
); fld
; fld
= DECL_CHAIN (fld
))
24017 || (TREE_CODE (fld
) == FUNCTION_DECL
24019 && user_provided_p (fld
)))
24020 && DECL_TEMPLATE_INSTANTIATION (fld
))
24022 mark_decl_instantiated (fld
, extern_p
);
24024 instantiate_decl (fld
, /*defer_ok=*/true,
24025 /*expl_inst_class_mem_p=*/true);
24028 if (CLASSTYPE_NESTED_UTDS (t
))
24029 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
24030 bt_instantiate_type_proc
, &storage
);
24033 /* Given a function DECL, which is a specialization of TMPL, modify
24034 DECL to be a re-instantiation of TMPL with the same template
24035 arguments. TMPL should be the template into which tsubst'ing
24036 should occur for DECL, not the most general template.
24038 One reason for doing this is a scenario like this:
24041 void f(const T&, int i);
24043 void g() { f(3, 7); }
24046 void f(const T& t, const int i) { }
24048 Note that when the template is first instantiated, with
24049 instantiate_template, the resulting DECL will have no name for the
24050 first parameter, and the wrong type for the second. So, when we go
24051 to instantiate the DECL, we regenerate it. */
24054 regenerate_decl_from_template (tree decl
, tree tmpl
, tree args
)
24056 /* The arguments used to instantiate DECL, from the most general
24060 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
24062 /* Make sure that we can see identifiers, and compute access
24064 push_access_scope (decl
);
24066 if (TREE_CODE (decl
) == FUNCTION_DECL
)
24074 args_depth
= TMPL_ARGS_DEPTH (args
);
24075 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
24076 if (args_depth
> parms_depth
)
24077 args
= get_innermost_template_args (args
, parms_depth
);
24079 /* Instantiate a dynamic exception-specification. noexcept will be
24081 if (tree raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (code_pattern
)))
24082 if (TREE_VALUE (raises
))
24084 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
24085 args
, tf_error
, NULL_TREE
,
24086 /*defer_ok*/false);
24087 if (specs
&& specs
!= error_mark_node
)
24088 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
24092 /* Merge parameter declarations. */
24093 decl_parm
= skip_artificial_parms_for (decl
,
24094 DECL_ARGUMENTS (decl
));
24096 = skip_artificial_parms_for (code_pattern
,
24097 DECL_ARGUMENTS (code_pattern
));
24098 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
24103 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
24104 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
24105 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
24107 parm_type
= type_decays_to (parm_type
);
24108 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
24109 TREE_TYPE (decl_parm
) = parm_type
;
24110 attributes
= DECL_ATTRIBUTES (pattern_parm
);
24111 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
24113 DECL_ATTRIBUTES (decl_parm
) = attributes
;
24114 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
24116 decl_parm
= DECL_CHAIN (decl_parm
);
24117 pattern_parm
= DECL_CHAIN (pattern_parm
);
24119 /* Merge any parameters that match with the function parameter
24121 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
24124 tree expanded_types
;
24125 /* Expand the TYPE_PACK_EXPANSION that provides the types for
24126 the parameters in this function parameter pack. */
24127 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
24128 args
, tf_error
, NULL_TREE
);
24129 len
= TREE_VEC_LENGTH (expanded_types
);
24130 for (i
= 0; i
< len
; i
++)
24135 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
24136 /* Rename the parameter to include the index. */
24137 DECL_NAME (decl_parm
) =
24138 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
24139 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
24140 parm_type
= type_decays_to (parm_type
);
24141 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
24142 TREE_TYPE (decl_parm
) = parm_type
;
24143 attributes
= DECL_ATTRIBUTES (pattern_parm
);
24144 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
24146 DECL_ATTRIBUTES (decl_parm
) = attributes
;
24147 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
24149 decl_parm
= DECL_CHAIN (decl_parm
);
24152 /* Merge additional specifiers from the CODE_PATTERN. */
24153 if (DECL_DECLARED_INLINE_P (code_pattern
)
24154 && !DECL_DECLARED_INLINE_P (decl
))
24155 DECL_DECLARED_INLINE_P (decl
) = 1;
24157 maybe_instantiate_noexcept (decl
, tf_error
);
24159 else if (VAR_P (decl
))
24161 start_lambda_scope (decl
);
24162 DECL_INITIAL (decl
) =
24163 tsubst_init (DECL_INITIAL (code_pattern
), decl
, args
,
24164 tf_error
, DECL_TI_TEMPLATE (decl
));
24165 finish_lambda_scope ();
24166 if (VAR_HAD_UNKNOWN_BOUND (decl
))
24167 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
24168 tf_error
, DECL_TI_TEMPLATE (decl
));
24171 gcc_unreachable ();
24173 pop_access_scope (decl
);
24176 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
24177 substituted to get DECL. */
24180 template_for_substitution (tree decl
)
24182 tree tmpl
= DECL_TI_TEMPLATE (decl
);
24184 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
24185 for the instantiation. This is not always the most general
24186 template. Consider, for example:
24189 struct S { template <class U> void f();
24190 template <> void f<int>(); };
24192 and an instantiation of S<double>::f<int>. We want TD to be the
24193 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
24194 while (/* An instantiation cannot have a definition, so we need a
24195 more general template. */
24196 DECL_TEMPLATE_INSTANTIATION (tmpl
)
24197 /* We must also deal with friend templates. Given:
24199 template <class T> struct S {
24200 template <class U> friend void f() {};
24203 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
24204 so far as the language is concerned, but that's still
24205 where we get the pattern for the instantiation from. On
24206 other hand, if the definition comes outside the class, say:
24208 template <class T> struct S {
24209 template <class U> friend void f();
24211 template <class U> friend void f() {}
24213 we don't need to look any further. That's what the check for
24214 DECL_INITIAL is for. */
24215 || (TREE_CODE (decl
) == FUNCTION_DECL
24216 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
24217 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
24219 /* The present template, TD, should not be a definition. If it
24220 were a definition, we should be using it! Note that we
24221 cannot restructure the loop to just keep going until we find
24222 a template with a definition, since that might go too far if
24223 a specialization was declared, but not defined. */
24225 /* Fetch the more general template. */
24226 tmpl
= DECL_TI_TEMPLATE (tmpl
);
24232 /* Returns true if we need to instantiate this template instance even if we
24233 know we aren't going to emit it. */
24236 always_instantiate_p (tree decl
)
24238 /* We always instantiate inline functions so that we can inline them. An
24239 explicit instantiation declaration prohibits implicit instantiation of
24240 non-inline functions. With high levels of optimization, we would
24241 normally inline non-inline functions -- but we're not allowed to do
24242 that for "extern template" functions. Therefore, we check
24243 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
24244 return ((TREE_CODE (decl
) == FUNCTION_DECL
24245 && (DECL_DECLARED_INLINE_P (decl
)
24246 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
24247 /* And we need to instantiate static data members so that
24248 their initializers are available in integral constant
24251 && decl_maybe_constant_var_p (decl
)));
24254 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
24255 instantiate it now, modifying TREE_TYPE (fn). Returns false on
24256 error, true otherwise. */
24259 maybe_instantiate_noexcept (tree fn
, tsubst_flags_t complain
)
24261 tree fntype
, spec
, noex
, clone
;
24263 /* Don't instantiate a noexcept-specification from template context. */
24264 if (processing_template_decl
24265 && (!flag_noexcept_type
|| type_dependent_expression_p (fn
)))
24268 if (DECL_CLONED_FUNCTION_P (fn
))
24269 fn
= DECL_CLONED_FUNCTION (fn
);
24271 tree orig_fn
= NULL_TREE
;
24272 /* For a member friend template we can get a TEMPLATE_DECL. Let's use
24273 its FUNCTION_DECL for the rest of this function -- push_access_scope
24274 doesn't accept TEMPLATE_DECLs. */
24275 if (DECL_FUNCTION_TEMPLATE_P (fn
))
24278 fn
= DECL_TEMPLATE_RESULT (fn
);
24281 fntype
= TREE_TYPE (fn
);
24282 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
24284 if (!spec
|| !TREE_PURPOSE (spec
))
24287 noex
= TREE_PURPOSE (spec
);
24289 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
24291 static hash_set
<tree
>* fns
= new hash_set
<tree
>;
24292 bool added
= false;
24293 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
24295 spec
= get_defaulted_eh_spec (fn
, complain
);
24296 if (spec
== error_mark_node
)
24297 /* This might have failed because of an unparsed DMI, so
24298 let's try again later. */
24301 else if (!(added
= !fns
->add (fn
)))
24303 /* If hash_set::add returns true, the element was already there. */
24304 location_t loc
= cp_expr_loc_or_loc (DEFERRED_NOEXCEPT_PATTERN (noex
),
24305 DECL_SOURCE_LOCATION (fn
));
24307 "exception specification of %qD depends on itself",
24309 spec
= noexcept_false_spec
;
24311 else if (push_tinst_level (fn
))
24313 push_access_scope (fn
);
24314 push_deferring_access_checks (dk_no_deferred
);
24315 input_location
= DECL_SOURCE_LOCATION (fn
);
24317 tree save_ccp
= current_class_ptr
;
24318 tree save_ccr
= current_class_ref
;
24319 /* If needed, set current_class_ptr for the benefit of
24320 tsubst_copy/PARM_DECL. */
24321 tree tdecl
= DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (fn
));
24322 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tdecl
))
24324 tree this_parm
= DECL_ARGUMENTS (tdecl
);
24325 current_class_ptr
= NULL_TREE
;
24326 current_class_ref
= cp_build_fold_indirect_ref (this_parm
);
24327 current_class_ptr
= this_parm
;
24330 /* If this function is represented by a TEMPLATE_DECL, then
24331 the deferred noexcept-specification might still contain
24332 dependent types, even after substitution. And we need the
24333 dependency check functions to work in build_noexcept_spec. */
24335 ++processing_template_decl
;
24337 /* Do deferred instantiation of the noexcept-specifier. */
24338 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
24339 DEFERRED_NOEXCEPT_ARGS (noex
),
24340 tf_warning_or_error
, fn
,
24341 /*function_p=*/false,
24344 current_class_ptr
= save_ccp
;
24345 current_class_ref
= save_ccr
;
24347 /* Build up the noexcept-specification. */
24348 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
24351 --processing_template_decl
;
24353 pop_deferring_access_checks ();
24354 pop_access_scope (fn
);
24355 pop_tinst_level ();
24358 spec
= noexcept_false_spec
;
24363 if (spec
== error_mark_node
)
24365 /* This failed with a hard error, so let's go with false. */
24366 gcc_assert (seen_error ());
24367 spec
= noexcept_false_spec
;
24370 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
24372 TREE_TYPE (orig_fn
) = TREE_TYPE (fn
);
24375 FOR_EACH_CLONE (clone
, fn
)
24377 if (TREE_TYPE (clone
) == fntype
)
24378 TREE_TYPE (clone
) = TREE_TYPE (fn
);
24380 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
24386 /* We're starting to process the function INST, an instantiation of PATTERN;
24387 add their parameters to local_specializations. */
24390 register_parameter_specializations (tree pattern
, tree inst
)
24392 tree tmpl_parm
= DECL_ARGUMENTS (pattern
);
24393 tree spec_parm
= DECL_ARGUMENTS (inst
);
24394 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (inst
))
24396 register_local_specialization (spec_parm
, tmpl_parm
);
24397 spec_parm
= skip_artificial_parms_for (inst
, spec_parm
);
24398 tmpl_parm
= skip_artificial_parms_for (pattern
, tmpl_parm
);
24400 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
24402 if (!DECL_PACK_P (tmpl_parm
))
24404 register_local_specialization (spec_parm
, tmpl_parm
);
24405 spec_parm
= DECL_CHAIN (spec_parm
);
24409 /* Register the (value) argument pack as a specialization of
24410 TMPL_PARM, then move on. */
24411 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
24412 register_local_specialization (argpack
, tmpl_parm
);
24415 gcc_assert (!spec_parm
);
24418 /* Produce the definition of D, a _DECL generated from a template. If
24419 DEFER_OK is true, then we don't have to actually do the
24420 instantiation now; we just have to do it sometime. Normally it is
24421 an error if this is an explicit instantiation but D is undefined.
24422 EXPL_INST_CLASS_MEM_P is true iff D is a member of an explicitly
24423 instantiated class template. */
24426 instantiate_decl (tree d
, bool defer_ok
, bool expl_inst_class_mem_p
)
24428 tree tmpl
= DECL_TI_TEMPLATE (d
);
24435 bool pattern_defined
;
24436 location_t saved_loc
= input_location
;
24437 int saved_unevaluated_operand
= cp_unevaluated_operand
;
24438 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
24442 /* This function should only be used to instantiate templates for
24443 functions and static member variables. */
24444 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
24446 /* A concept is never instantiated. */
24447 gcc_assert (!DECL_DECLARED_CONCEPT_P (d
));
24449 /* Variables are never deferred; if instantiation is required, they
24450 are instantiated right away. That allows for better code in the
24451 case that an expression refers to the value of the variable --
24452 if the variable has a constant value the referring expression can
24453 take advantage of that fact. */
24457 /* Don't instantiate cloned functions. Instead, instantiate the
24458 functions they cloned. */
24459 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
24460 d
= DECL_CLONED_FUNCTION (d
);
24462 if (DECL_TEMPLATE_INSTANTIATED (d
)
24463 || (TREE_CODE (d
) == FUNCTION_DECL
24464 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
24465 || DECL_TEMPLATE_SPECIALIZATION (d
))
24466 /* D has already been instantiated or explicitly specialized, so
24467 there's nothing for us to do here.
24469 It might seem reasonable to check whether or not D is an explicit
24470 instantiation, and, if so, stop here. But when an explicit
24471 instantiation is deferred until the end of the compilation,
24472 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
24473 the instantiation. */
24476 /* Check to see whether we know that this template will be
24477 instantiated in some other file, as with "extern template"
24479 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
24481 /* In general, we do not instantiate such templates. */
24482 if (external_p
&& !always_instantiate_p (d
))
24485 gen_tmpl
= most_general_template (tmpl
);
24486 gen_args
= DECL_TI_ARGS (d
);
24488 if (tmpl
!= gen_tmpl
)
24489 /* We should already have the extra args. */
24490 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
24491 == TMPL_ARGS_DEPTH (gen_args
));
24492 /* And what's in the hash table should match D. */
24493 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
24494 || spec
== NULL_TREE
);
24496 /* This needs to happen before any tsubsting. */
24497 if (! push_tinst_level (d
))
24500 timevar_push (TV_TEMPLATE_INST
);
24502 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
24503 for the instantiation. */
24504 td
= template_for_substitution (d
);
24509 /* Look up an explicit specialization, if any. */
24510 tree tid
= lookup_template_variable (gen_tmpl
, gen_args
);
24511 tree elt
= most_specialized_partial_spec (tid
, tf_warning_or_error
);
24512 if (elt
&& elt
!= error_mark_node
)
24514 td
= TREE_VALUE (elt
);
24515 args
= TREE_PURPOSE (elt
);
24519 code_pattern
= DECL_TEMPLATE_RESULT (td
);
24521 /* We should never be trying to instantiate a member of a class
24522 template or partial specialization. */
24523 gcc_assert (d
!= code_pattern
);
24525 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
24526 || DECL_TEMPLATE_SPECIALIZATION (td
))
24527 /* In the case of a friend template whose definition is provided
24528 outside the class, we may have too many arguments. Drop the
24529 ones we don't need. The same is true for specializations. */
24530 args
= get_innermost_template_args
24531 (args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
24533 if (TREE_CODE (d
) == FUNCTION_DECL
)
24535 deleted_p
= DECL_DELETED_FN (code_pattern
);
24536 pattern_defined
= ((DECL_SAVED_TREE (code_pattern
) != NULL_TREE
24537 && DECL_INITIAL (code_pattern
) != error_mark_node
)
24538 || DECL_DEFAULTED_FN (code_pattern
)
24544 if (DECL_CLASS_SCOPE_P (code_pattern
))
24545 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
24547 pattern_defined
= ! DECL_EXTERNAL (code_pattern
);
24550 /* We may be in the middle of deferred access check. Disable it now. */
24551 push_deferring_access_checks (dk_no_deferred
);
24553 /* Unless an explicit instantiation directive has already determined
24554 the linkage of D, remember that a definition is available for
24556 if (pattern_defined
24557 && !DECL_INTERFACE_KNOWN (d
)
24558 && !DECL_NOT_REALLY_EXTERN (d
))
24559 mark_definable (d
);
24561 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
24562 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
24563 input_location
= DECL_SOURCE_LOCATION (d
);
24565 /* If D is a member of an explicitly instantiated class template,
24566 and no definition is available, treat it like an implicit
24568 if (!pattern_defined
&& expl_inst_class_mem_p
24569 && DECL_EXPLICIT_INSTANTIATION (d
))
24571 /* Leave linkage flags alone on instantiations with anonymous
24573 if (TREE_PUBLIC (d
))
24575 DECL_NOT_REALLY_EXTERN (d
) = 0;
24576 DECL_INTERFACE_KNOWN (d
) = 0;
24578 SET_DECL_IMPLICIT_INSTANTIATION (d
);
24581 /* Defer all other templates, unless we have been explicitly
24582 forbidden from doing so. */
24583 if (/* If there is no definition, we cannot instantiate the
24586 /* If it's OK to postpone instantiation, do so. */
24588 /* If this is a static data member that will be defined
24589 elsewhere, we don't want to instantiate the entire data
24590 member, but we do want to instantiate the initializer so that
24591 we can substitute that elsewhere. */
24592 || (external_p
&& VAR_P (d
))
24593 /* Handle here a deleted function too, avoid generating
24594 its body (c++/61080). */
24597 /* The definition of the static data member is now required so
24598 we must substitute the initializer. */
24600 && !DECL_INITIAL (d
)
24601 && DECL_INITIAL (code_pattern
))
24605 bool const_init
= false;
24606 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
24608 ns
= decl_namespace_context (d
);
24609 push_nested_namespace (ns
);
24611 push_nested_class (DECL_CONTEXT (d
));
24612 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
24614 tf_warning_or_error
, NULL_TREE
,
24615 /*integral_constant_expression_p=*/false);
24616 /* If instantiating the initializer involved instantiating this
24617 again, don't call cp_finish_decl twice. */
24618 if (!DECL_INITIAL (d
))
24620 /* Make sure the initializer is still constant, in case of
24621 circular dependency (template/instantiate6.C). */
24623 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
24624 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
24625 /*asmspec_tree=*/NULL_TREE
,
24626 LOOKUP_ONLYCONVERTING
);
24629 pop_nested_class ();
24630 pop_nested_namespace (ns
);
24633 /* We restore the source position here because it's used by
24634 add_pending_template. */
24635 input_location
= saved_loc
;
24637 if (at_eof
&& !pattern_defined
24638 && DECL_EXPLICIT_INSTANTIATION (d
)
24639 && DECL_NOT_REALLY_EXTERN (d
))
24642 The definition of a non-exported function template, a
24643 non-exported member function template, or a non-exported
24644 member function or static data member of a class template
24645 shall be present in every translation unit in which it is
24646 explicitly instantiated. */
24647 permerror (input_location
, "explicit instantiation of %qD "
24648 "but no definition available", d
);
24650 /* If we're in unevaluated context, we just wanted to get the
24651 constant value; this isn't an odr use, so don't queue
24652 a full instantiation. */
24653 if (cp_unevaluated_operand
!= 0)
24655 /* ??? Historically, we have instantiated inline functions, even
24656 when marked as "extern template". */
24657 if (!(external_p
&& VAR_P (d
)))
24658 add_pending_template (d
);
24661 /* Tell the repository that D is available in this translation unit
24662 -- and see if it is supposed to be instantiated here. */
24663 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
24665 /* In a PCH file, despite the fact that the repository hasn't
24666 requested instantiation in the PCH it is still possible that
24667 an instantiation will be required in a file that includes the
24670 add_pending_template (d
);
24671 /* Instantiate inline functions so that the inliner can do its
24672 job, even though we'll not be emitting a copy of this
24674 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
24678 bool push_to_top
, nested
;
24680 fn_context
= decl_function_context (d
);
24681 if (LAMBDA_FUNCTION_P (d
))
24682 /* tsubst_lambda_expr resolved any references to enclosing functions. */
24683 fn_context
= NULL_TREE
;
24684 nested
= current_function_decl
!= NULL_TREE
;
24685 push_to_top
= !(nested
&& fn_context
== current_function_decl
);
24687 vec
<tree
> omp_privatization_save
;
24689 save_omp_privatization_clauses (omp_privatization_save
);
24692 push_to_top_level ();
24695 gcc_assert (!processing_template_decl
);
24696 push_function_context ();
24697 cp_unevaluated_operand
= 0;
24698 c_inhibit_evaluation_warnings
= 0;
24701 /* Mark D as instantiated so that recursive calls to
24702 instantiate_decl do not try to instantiate it again. */
24703 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
24705 /* Regenerate the declaration in case the template has been modified
24706 by a subsequent redeclaration. */
24707 regenerate_decl_from_template (d
, td
, args
);
24709 /* We already set the file and line above. Reset them now in case
24710 they changed as a result of calling regenerate_decl_from_template. */
24711 input_location
= DECL_SOURCE_LOCATION (d
);
24716 bool const_init
= false;
24718 /* Clear out DECL_RTL; whatever was there before may not be right
24719 since we've reset the type of the declaration. */
24720 SET_DECL_RTL (d
, NULL
);
24721 DECL_IN_AGGR_P (d
) = 0;
24723 /* The initializer is placed in DECL_INITIAL by
24724 regenerate_decl_from_template so we don't need to
24725 push/pop_access_scope again here. Pull it out so that
24726 cp_finish_decl can process it. */
24727 init
= DECL_INITIAL (d
);
24728 DECL_INITIAL (d
) = NULL_TREE
;
24729 DECL_INITIALIZED_P (d
) = 0;
24731 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
24732 initializer. That function will defer actual emission until
24733 we have a chance to determine linkage. */
24734 DECL_EXTERNAL (d
) = 0;
24736 /* Enter the scope of D so that access-checking works correctly. */
24737 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
24739 push_nested_class (DECL_CONTEXT (d
));
24741 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
24742 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
24745 pop_nested_class ();
24747 if (variable_template_p (gen_tmpl
))
24748 note_variable_template_instantiation (d
);
24750 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
24751 synthesize_method (d
);
24752 else if (TREE_CODE (d
) == FUNCTION_DECL
)
24754 /* Set up the list of local specializations. */
24755 local_specialization_stack
lss (push_to_top
? lss_blank
: lss_copy
);
24756 tree block
= NULL_TREE
;
24758 /* Set up context. */
24759 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
24760 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
24761 block
= push_stmt_list ();
24763 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
24765 /* Some typedefs referenced from within the template code need to be
24766 access checked at template instantiation time, i.e now. These
24767 types were added to the template at parsing time. Let's get those
24768 and perform the access checks then. */
24769 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (td
),
24772 /* Create substitution entries for the parameters. */
24773 register_parameter_specializations (code_pattern
, d
);
24775 /* Substitute into the body of the function. */
24776 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
24777 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
24778 tf_warning_or_error
, tmpl
);
24781 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
24782 tf_warning_or_error
, tmpl
,
24783 /*integral_constant_expression_p=*/false);
24785 /* Set the current input_location to the end of the function
24786 so that finish_function knows where we are. */
24788 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
24790 /* Remember if we saw an infinite loop in the template. */
24791 current_function_infinite_loop
24792 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
24795 /* Finish the function. */
24796 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
24797 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
24798 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
24801 d
= finish_function (/*inline_p=*/false);
24802 expand_or_defer_fn (d
);
24805 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
24806 cp_check_omp_declare_reduction (d
);
24809 /* We're not deferring instantiation any more. */
24810 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
24813 pop_from_top_level ();
24815 pop_function_context ();
24818 restore_omp_privatization_clauses (omp_privatization_save
);
24821 pop_deferring_access_checks ();
24822 timevar_pop (TV_TEMPLATE_INST
);
24823 pop_tinst_level ();
24824 input_location
= saved_loc
;
24825 cp_unevaluated_operand
= saved_unevaluated_operand
;
24826 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
24831 /* Run through the list of templates that we wish we could
24832 instantiate, and instantiate any we can. RETRIES is the
24833 number of times we retry pending template instantiation. */
24836 instantiate_pending_templates (int retries
)
24839 location_t saved_loc
= input_location
;
24841 /* Instantiating templates may trigger vtable generation. This in turn
24842 may require further template instantiations. We place a limit here
24843 to avoid infinite loop. */
24844 if (pending_templates
&& retries
>= max_tinst_depth
)
24846 tree decl
= pending_templates
->tinst
->maybe_get_node ();
24848 fatal_error (input_location
,
24849 "template instantiation depth exceeds maximum of %d"
24850 " instantiating %q+D, possibly from virtual table generation"
24851 " (use %<-ftemplate-depth=%> to increase the maximum)",
24852 max_tinst_depth
, decl
);
24853 if (TREE_CODE (decl
) == FUNCTION_DECL
)
24854 /* Pretend that we defined it. */
24855 DECL_INITIAL (decl
) = error_mark_node
;
24861 struct pending_template
**t
= &pending_templates
;
24862 struct pending_template
*last
= NULL
;
24866 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
24867 bool complete
= false;
24869 if (TYPE_P (instantiation
))
24871 if (!COMPLETE_TYPE_P (instantiation
))
24873 instantiate_class_template (instantiation
);
24874 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
24875 for (tree fld
= TYPE_FIELDS (instantiation
);
24876 fld
; fld
= TREE_CHAIN (fld
))
24878 || (TREE_CODE (fld
) == FUNCTION_DECL
24879 && !DECL_ARTIFICIAL (fld
)))
24880 && DECL_TEMPLATE_INSTANTIATION (fld
))
24881 instantiate_decl (fld
,
24882 /*defer_ok=*/false,
24883 /*expl_inst_class_mem_p=*/false);
24885 if (COMPLETE_TYPE_P (instantiation
))
24889 complete
= COMPLETE_TYPE_P (instantiation
);
24893 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
24894 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
24897 = instantiate_decl (instantiation
,
24898 /*defer_ok=*/false,
24899 /*expl_inst_class_mem_p=*/false);
24900 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
24904 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
24905 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
24910 /* If INSTANTIATION has been instantiated, then we don't
24911 need to consider it again in the future. */
24912 struct pending_template
*drop
= *t
;
24914 set_refcount_ptr (drop
->tinst
);
24915 pending_template_freelist ().free (drop
);
24923 set_refcount_ptr (current_tinst_level
);
24925 last_pending_template
= last
;
24927 while (reconsider
);
24929 input_location
= saved_loc
;
24932 /* Substitute ARGVEC into T, which is a list of initializers for
24933 either base class or a non-static data member. The TREE_PURPOSEs
24934 are DECLs, and the TREE_VALUEs are the initializer values. Used by
24935 instantiate_decl. */
24938 tsubst_initializer_list (tree t
, tree argvec
)
24940 tree inits
= NULL_TREE
;
24941 tree target_ctor
= error_mark_node
;
24943 for (; t
; t
= TREE_CHAIN (t
))
24947 tree expanded_bases
= NULL_TREE
;
24948 tree expanded_arguments
= NULL_TREE
;
24951 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
24956 /* Expand the base class expansion type into separate base
24958 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
24959 tf_warning_or_error
,
24961 if (expanded_bases
== error_mark_node
)
24964 /* We'll be building separate TREE_LISTs of arguments for
24966 len
= TREE_VEC_LENGTH (expanded_bases
);
24967 expanded_arguments
= make_tree_vec (len
);
24968 for (i
= 0; i
< len
; i
++)
24969 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
24971 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
24972 expand each argument in the TREE_VALUE of t. */
24973 expr
= make_node (EXPR_PACK_EXPANSION
);
24974 PACK_EXPANSION_LOCAL_P (expr
) = true;
24975 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
24976 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
24978 if (TREE_VALUE (t
) == void_type_node
)
24979 /* VOID_TYPE_NODE is used to indicate
24980 value-initialization. */
24982 for (i
= 0; i
< len
; i
++)
24983 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
24987 /* Substitute parameter packs into each argument in the
24989 in_base_initializer
= 1;
24990 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
24992 tree expanded_exprs
;
24994 /* Expand the argument. */
24995 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
24997 = tsubst_pack_expansion (expr
, argvec
,
24998 tf_warning_or_error
,
25000 if (expanded_exprs
== error_mark_node
)
25003 /* Prepend each of the expanded expressions to the
25004 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
25005 for (i
= 0; i
< len
; i
++)
25007 TREE_VEC_ELT (expanded_arguments
, i
) =
25008 tree_cons (NULL_TREE
,
25009 TREE_VEC_ELT (expanded_exprs
, i
),
25010 TREE_VEC_ELT (expanded_arguments
, i
));
25013 in_base_initializer
= 0;
25015 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
25016 since we built them backwards. */
25017 for (i
= 0; i
< len
; i
++)
25019 TREE_VEC_ELT (expanded_arguments
, i
) =
25020 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
25025 for (i
= 0; i
< len
; ++i
)
25027 if (expanded_bases
)
25029 decl
= TREE_VEC_ELT (expanded_bases
, i
);
25030 decl
= expand_member_init (decl
);
25031 init
= TREE_VEC_ELT (expanded_arguments
, i
);
25036 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
25037 tf_warning_or_error
, NULL_TREE
);
25039 decl
= expand_member_init (decl
);
25040 if (decl
&& !DECL_P (decl
))
25041 in_base_initializer
= 1;
25043 init
= TREE_VALUE (t
);
25045 if (init
!= void_type_node
)
25046 init
= tsubst_expr (init
, argvec
,
25047 tf_warning_or_error
, NULL_TREE
,
25048 /*integral_constant_expression_p=*/false);
25049 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
25050 /* If we had an initializer but it instantiated to nothing,
25051 value-initialize the object. This will only occur when
25052 the initializer was a pack expansion where the parameter
25053 packs used in that expansion were of length zero. */
25054 init
= void_type_node
;
25055 in_base_initializer
= 0;
25058 if (target_ctor
!= error_mark_node
25059 && init
!= error_mark_node
)
25061 error ("mem-initializer for %qD follows constructor delegation",
25065 /* Look for a target constructor. */
25066 if (init
!= error_mark_node
25067 && decl
&& CLASS_TYPE_P (decl
)
25068 && same_type_p (decl
, current_class_type
))
25070 maybe_warn_cpp0x (CPP0X_DELEGATING_CTORS
);
25073 error ("constructor delegation follows mem-initializer for %qD",
25074 TREE_PURPOSE (inits
));
25077 target_ctor
= init
;
25082 init
= build_tree_list (decl
, init
);
25083 TREE_CHAIN (init
) = inits
;
25091 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
25094 set_current_access_from_decl (tree decl
)
25096 if (TREE_PRIVATE (decl
))
25097 current_access_specifier
= access_private_node
;
25098 else if (TREE_PROTECTED (decl
))
25099 current_access_specifier
= access_protected_node
;
25101 current_access_specifier
= access_public_node
;
25104 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
25105 is the instantiation (which should have been created with
25106 start_enum) and ARGS are the template arguments to use. */
25109 tsubst_enum (tree tag
, tree newtag
, tree args
)
25113 if (SCOPED_ENUM_P (newtag
))
25114 begin_scope (sk_scoped_enum
, newtag
);
25116 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
25121 decl
= TREE_VALUE (e
);
25122 /* Note that in a template enum, the TREE_VALUE is the
25123 CONST_DECL, not the corresponding INTEGER_CST. */
25124 value
= tsubst_expr (DECL_INITIAL (decl
),
25125 args
, tf_warning_or_error
, NULL_TREE
,
25126 /*integral_constant_expression_p=*/true);
25128 /* Give this enumeration constant the correct access. */
25129 set_current_access_from_decl (decl
);
25131 /* Actually build the enumerator itself. Here we're assuming that
25132 enumerators can't have dependent attributes. */
25133 build_enumerator (DECL_NAME (decl
), value
, newtag
,
25134 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
25137 if (SCOPED_ENUM_P (newtag
))
25140 finish_enum_value_list (newtag
);
25141 finish_enum (newtag
);
25143 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
25144 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
25147 /* DECL is a FUNCTION_DECL that is a template specialization. Return
25148 its type -- but without substituting the innermost set of template
25149 arguments. So, innermost set of template parameters will appear in
25153 get_mostly_instantiated_function_type (tree decl
)
25155 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
25156 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
25159 /* Return truthvalue if we're processing a template different from
25160 the last one involved in diagnostics. */
25162 problematic_instantiation_changed (void)
25164 return current_tinst_level
!= last_error_tinst_level
;
25167 /* Remember current template involved in diagnostics. */
25169 record_last_problematic_instantiation (void)
25171 set_refcount_ptr (last_error_tinst_level
, current_tinst_level
);
25174 struct tinst_level
*
25175 current_instantiation (void)
25177 return current_tinst_level
;
25180 /* Return TRUE if current_function_decl is being instantiated, false
25184 instantiating_current_function_p (void)
25186 return (current_instantiation ()
25187 && (current_instantiation ()->maybe_get_node ()
25188 == current_function_decl
));
25191 /* [temp.param] Check that template non-type parm TYPE is of an allowable
25192 type. Return false for ok, true for disallowed. Issue error and
25193 inform messages under control of COMPLAIN. */
25196 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
25198 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
25200 else if (TYPE_PTR_P (type
))
25202 else if (TYPE_REF_P (type
)
25203 && !TYPE_REF_IS_RVALUE (type
))
25205 else if (TYPE_PTRMEM_P (type
))
25207 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
25209 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
25211 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
25213 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
25215 /* A bound template template parm could later be instantiated to have a valid
25216 nontype parm type via an alias template. */
25217 else if (cxx_dialect
>= cxx11
25218 && TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
25220 else if (CLASS_TYPE_P (type
))
25222 if (cxx_dialect
< cxx2a
)
25224 error ("non-type template parameters of class type only available "
25225 "with %<-std=c++2a%> or %<-std=gnu++2a%>");
25228 if (!complete_type_or_else (type
, NULL_TREE
))
25230 if (!literal_type_p (type
))
25232 error ("%qT is not a valid type for a template non-type parameter "
25233 "because it is not literal", type
);
25234 explain_non_literal_class (type
);
25237 if (cp_has_mutable_p (type
))
25239 error ("%qT is not a valid type for a template non-type parameter "
25240 "because it has a mutable member", type
);
25243 /* FIXME check op<=> and strong structural equality once spaceship is
25248 if (complain
& tf_error
)
25250 if (type
== error_mark_node
)
25251 inform (input_location
, "invalid template non-type parameter");
25253 error ("%q#T is not a valid type for a template non-type parameter",
25259 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
25260 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
25263 dependent_type_p_r (tree type
)
25269 A type is dependent if it is:
25271 -- a template parameter. Template template parameters are types
25272 for us (since TYPE_P holds true for them) so we handle
25274 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
25275 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
25277 /* -- a qualified-id with a nested-name-specifier which contains a
25278 class-name that names a dependent type or whose unqualified-id
25279 names a dependent type. */
25280 if (TREE_CODE (type
) == TYPENAME_TYPE
)
25283 /* An alias template specialization can be dependent even if the
25284 resulting type is not. */
25285 if (dependent_alias_template_spec_p (type
))
25288 /* -- a cv-qualified type where the cv-unqualified type is
25290 No code is necessary for this bullet; the code below handles
25291 cv-qualified types, and we don't want to strip aliases with
25292 TYPE_MAIN_VARIANT because of DR 1558. */
25293 /* -- a compound type constructed from any dependent type. */
25294 if (TYPE_PTRMEM_P (type
))
25295 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
25296 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
25298 else if (INDIRECT_TYPE_P (type
))
25299 return dependent_type_p (TREE_TYPE (type
));
25300 else if (FUNC_OR_METHOD_TYPE_P (type
))
25304 if (dependent_type_p (TREE_TYPE (type
)))
25306 for (arg_type
= TYPE_ARG_TYPES (type
);
25308 arg_type
= TREE_CHAIN (arg_type
))
25309 if (dependent_type_p (TREE_VALUE (arg_type
)))
25311 if (cxx_dialect
>= cxx17
)
25312 /* A value-dependent noexcept-specifier makes the type dependent. */
25313 if (tree spec
= TYPE_RAISES_EXCEPTIONS (type
))
25314 if (tree noex
= TREE_PURPOSE (spec
))
25315 /* Treat DEFERRED_NOEXCEPT as non-dependent, since it doesn't
25316 affect overload resolution and treating it as dependent breaks
25317 things. Same for an unparsed noexcept expression. */
25318 if (TREE_CODE (noex
) != DEFERRED_NOEXCEPT
25319 && TREE_CODE (noex
) != DEFERRED_PARSE
25320 && value_dependent_expression_p (noex
))
25324 /* -- an array type constructed from any dependent type or whose
25325 size is specified by a constant expression that is
25328 We checked for type- and value-dependence of the bounds in
25329 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
25330 if (TREE_CODE (type
) == ARRAY_TYPE
)
25332 if (TYPE_DOMAIN (type
)
25333 && dependent_type_p (TYPE_DOMAIN (type
)))
25335 return dependent_type_p (TREE_TYPE (type
));
25338 /* -- a template-id in which either the template name is a template
25340 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
25342 /* ... or any of the template arguments is a dependent type or
25343 an expression that is type-dependent or value-dependent. */
25344 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
25345 && (any_dependent_template_arguments_p
25346 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
25349 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
25350 dependent; if the argument of the `typeof' expression is not
25351 type-dependent, then it should already been have resolved. */
25352 if (TREE_CODE (type
) == TYPEOF_TYPE
25353 || TREE_CODE (type
) == DECLTYPE_TYPE
25354 || TREE_CODE (type
) == UNDERLYING_TYPE
)
25357 /* A template argument pack is dependent if any of its packed
25359 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
25361 tree args
= ARGUMENT_PACK_ARGS (type
);
25362 int i
, len
= TREE_VEC_LENGTH (args
);
25363 for (i
= 0; i
< len
; ++i
)
25364 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
25368 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
25369 be template parameters. */
25370 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
25373 if (any_dependent_type_attributes_p (TYPE_ATTRIBUTES (type
)))
25376 /* The standard does not specifically mention types that are local
25377 to template functions or local classes, but they should be
25378 considered dependent too. For example:
25380 template <int I> void f() {
25385 The size of `E' cannot be known until the value of `I' has been
25386 determined. Therefore, `E' must be considered dependent. */
25387 scope
= TYPE_CONTEXT (type
);
25388 if (scope
&& TYPE_P (scope
))
25389 return dependent_type_p (scope
);
25390 /* Don't use type_dependent_expression_p here, as it can lead
25391 to infinite recursion trying to determine whether a lambda
25392 nested in a lambda is dependent (c++/47687). */
25393 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
25394 && DECL_LANG_SPECIFIC (scope
)
25395 && DECL_TEMPLATE_INFO (scope
)
25396 && (any_dependent_template_arguments_p
25397 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
25400 /* Other types are non-dependent. */
25404 /* Returns TRUE if TYPE is dependent, in the sense of
25405 [temp.dep.type]. Note that a NULL type is considered dependent. */
25408 dependent_type_p (tree type
)
25410 /* If there are no template parameters in scope, then there can't be
25411 any dependent types. */
25412 if (!processing_template_decl
)
25414 /* If we are not processing a template, then nobody should be
25415 providing us with a dependent type. */
25417 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
25421 /* If the type is NULL, we have not computed a type for the entity
25422 in question; in that case, the type is dependent. */
25426 /* Erroneous types can be considered non-dependent. */
25427 if (type
== error_mark_node
)
25430 /* Getting here with global_type_node means we improperly called this
25431 function on the TREE_TYPE of an IDENTIFIER_NODE. */
25432 gcc_checking_assert (type
!= global_type_node
);
25434 /* If we have not already computed the appropriate value for TYPE,
25436 if (!TYPE_DEPENDENT_P_VALID (type
))
25438 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
25439 TYPE_DEPENDENT_P_VALID (type
) = 1;
25442 return TYPE_DEPENDENT_P (type
);
25445 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
25446 lookup. In other words, a dependent type that is not the current
25450 dependent_scope_p (tree scope
)
25452 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
25453 && !currently_open_class (scope
));
25456 /* T is a SCOPE_REF. Return whether it represents a non-static member of
25457 an unknown base of 'this' (and is therefore instantiation-dependent). */
25460 unknown_base_ref_p (tree t
)
25462 if (!current_class_ptr
)
25465 tree mem
= TREE_OPERAND (t
, 1);
25466 if (shared_member_p (mem
))
25469 tree cur
= current_nonlambda_class_type ();
25470 if (!any_dependent_bases_p (cur
))
25473 tree ctx
= TREE_OPERAND (t
, 0);
25474 if (DERIVED_FROM_P (ctx
, cur
))
25480 /* T is a SCOPE_REF; return whether we need to consider it
25481 instantiation-dependent so that we can check access at instantiation
25482 time even though we know which member it resolves to. */
25485 instantiation_dependent_scope_ref_p (tree t
)
25487 if (DECL_P (TREE_OPERAND (t
, 1))
25488 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
25489 && !unknown_base_ref_p (t
)
25490 && accessible_in_template_p (TREE_OPERAND (t
, 0),
25491 TREE_OPERAND (t
, 1)))
25497 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
25498 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
25501 /* Note that this predicate is not appropriate for general expressions;
25502 only constant expressions (that satisfy potential_constant_expression)
25503 can be tested for value dependence. */
25506 value_dependent_expression_p (tree expression
)
25508 if (!processing_template_decl
|| expression
== NULL_TREE
)
25511 /* A type-dependent expression is also value-dependent. */
25512 if (type_dependent_expression_p (expression
))
25515 switch (TREE_CODE (expression
))
25518 /* A dependent member function of the current instantiation. */
25519 return dependent_type_p (BINFO_TYPE (BASELINK_BINFO (expression
)));
25521 case FUNCTION_DECL
:
25522 /* A dependent member function of the current instantiation. */
25523 if (DECL_CLASS_SCOPE_P (expression
)
25524 && dependent_type_p (DECL_CONTEXT (expression
)))
25528 case IDENTIFIER_NODE
:
25529 /* A name that has not been looked up -- must be dependent. */
25532 case TEMPLATE_PARM_INDEX
:
25533 /* A non-type template parm. */
25537 /* A non-type template parm. */
25538 if (DECL_TEMPLATE_PARM_P (expression
))
25540 return value_dependent_expression_p (DECL_INITIAL (expression
));
25543 /* A constant with literal type and is initialized
25544 with an expression that is value-dependent. */
25545 if (DECL_DEPENDENT_INIT_P (expression
)
25546 /* FIXME cp_finish_decl doesn't fold reference initializers. */
25547 || TYPE_REF_P (TREE_TYPE (expression
)))
25549 if (DECL_HAS_VALUE_EXPR_P (expression
))
25551 tree value_expr
= DECL_VALUE_EXPR (expression
);
25552 if (value_dependent_expression_p (value_expr
))
25557 case DYNAMIC_CAST_EXPR
:
25558 case STATIC_CAST_EXPR
:
25559 case CONST_CAST_EXPR
:
25560 case REINTERPRET_CAST_EXPR
:
25562 case IMPLICIT_CONV_EXPR
:
25563 /* These expressions are value-dependent if the type to which
25564 the cast occurs is dependent or the expression being casted
25565 is value-dependent. */
25567 tree type
= TREE_TYPE (expression
);
25569 if (dependent_type_p (type
))
25572 /* A functional cast has a list of operands. */
25573 expression
= TREE_OPERAND (expression
, 0);
25576 /* If there are no operands, it must be an expression such
25577 as "int()". This should not happen for aggregate types
25578 because it would form non-constant expressions. */
25579 gcc_assert (cxx_dialect
>= cxx11
25580 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
25585 if (TREE_CODE (expression
) == TREE_LIST
)
25586 return any_value_dependent_elements_p (expression
);
25588 return value_dependent_expression_p (expression
);
25592 if (SIZEOF_EXPR_TYPE_P (expression
))
25593 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
25597 /* A `sizeof' expression is value-dependent if the operand is
25598 type-dependent or is a pack expansion. */
25599 expression
= TREE_OPERAND (expression
, 0);
25600 if (PACK_EXPANSION_P (expression
))
25602 else if (TYPE_P (expression
))
25603 return dependent_type_p (expression
);
25604 return instantiation_dependent_uneval_expression_p (expression
);
25606 case AT_ENCODE_EXPR
:
25607 /* An 'encode' expression is value-dependent if the operand is
25609 expression
= TREE_OPERAND (expression
, 0);
25610 return dependent_type_p (expression
);
25612 case NOEXCEPT_EXPR
:
25613 expression
= TREE_OPERAND (expression
, 0);
25614 return instantiation_dependent_uneval_expression_p (expression
);
25617 /* All instantiation-dependent expressions should also be considered
25618 value-dependent. */
25619 return instantiation_dependent_scope_ref_p (expression
);
25621 case COMPONENT_REF
:
25622 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
25623 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
25625 case NONTYPE_ARGUMENT_PACK
:
25626 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
25627 is value-dependent. */
25629 tree values
= ARGUMENT_PACK_ARGS (expression
);
25630 int i
, len
= TREE_VEC_LENGTH (values
);
25632 for (i
= 0; i
< len
; ++i
)
25633 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
25641 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
25643 if (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
)))
25649 if (TREE_CODE (type2
) != TREE_LIST
)
25650 return dependent_type_p (type2
);
25652 for (; type2
; type2
= TREE_CHAIN (type2
))
25653 if (dependent_type_p (TREE_VALUE (type2
)))
25660 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
25661 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
25664 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
25665 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
25669 tree op
= TREE_OPERAND (expression
, 0);
25670 return (value_dependent_expression_p (op
)
25671 || has_value_dependent_address (op
));
25674 case REQUIRES_EXPR
:
25675 /* Treat all requires-expressions as value-dependent so
25676 we don't try to fold them. */
25680 return dependent_type_p (TREE_OPERAND (expression
, 0));
25684 if (value_dependent_expression_p (CALL_EXPR_FN (expression
)))
25686 tree fn
= get_callee_fndecl (expression
);
25688 nargs
= call_expr_nargs (expression
);
25689 for (i
= 0; i
< nargs
; ++i
)
25691 tree op
= CALL_EXPR_ARG (expression
, i
);
25692 /* In a call to a constexpr member function, look through the
25693 implicit ADDR_EXPR on the object argument so that it doesn't
25694 cause the call to be considered value-dependent. We also
25695 look through it in potential_constant_expression. */
25696 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
25697 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
25698 && TREE_CODE (op
) == ADDR_EXPR
)
25699 op
= TREE_OPERAND (op
, 0);
25700 if (value_dependent_expression_p (op
))
25706 case TEMPLATE_ID_EXPR
:
25707 return variable_concept_p (TREE_OPERAND (expression
, 0));
25713 if (dependent_type_p (TREE_TYPE (expression
)))
25715 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
25716 if (value_dependent_expression_p (val
))
25722 /* Treat a GNU statement expression as dependent to avoid crashing
25723 under instantiate_non_dependent_expr; it can't be constant. */
25727 /* A constant expression is value-dependent if any subexpression is
25728 value-dependent. */
25729 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
25731 case tcc_reference
:
25733 case tcc_comparison
:
25735 case tcc_expression
:
25738 int i
, len
= cp_tree_operand_length (expression
);
25740 for (i
= 0; i
< len
; i
++)
25742 tree t
= TREE_OPERAND (expression
, i
);
25744 /* In some cases, some of the operands may be missing.
25745 (For example, in the case of PREDECREMENT_EXPR, the
25746 amount to increment by may be missing.) That doesn't
25747 make the expression dependent. */
25748 if (t
&& value_dependent_expression_p (t
))
25759 /* The expression is not value-dependent. */
25763 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
25764 [temp.dep.expr]. Note that an expression with no type is
25765 considered dependent. Other parts of the compiler arrange for an
25766 expression with type-dependent subexpressions to have no type, so
25767 this function doesn't have to be fully recursive. */
25770 type_dependent_expression_p (tree expression
)
25772 if (!processing_template_decl
)
25775 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
25778 STRIP_ANY_LOCATION_WRAPPER (expression
);
25780 /* An unresolved name is always dependent. */
25781 if (identifier_p (expression
)
25782 || TREE_CODE (expression
) == USING_DECL
25783 || TREE_CODE (expression
) == WILDCARD_DECL
)
25786 /* A lambda-expression in template context is dependent. dependent_type_p is
25787 true for a lambda in the scope of a class or function template, but that
25788 doesn't cover all template contexts, like a default template argument. */
25789 if (TREE_CODE (expression
) == LAMBDA_EXPR
)
25792 /* A fold expression is type-dependent. */
25793 if (TREE_CODE (expression
) == UNARY_LEFT_FOLD_EXPR
25794 || TREE_CODE (expression
) == UNARY_RIGHT_FOLD_EXPR
25795 || TREE_CODE (expression
) == BINARY_LEFT_FOLD_EXPR
25796 || TREE_CODE (expression
) == BINARY_RIGHT_FOLD_EXPR
)
25799 /* Some expression forms are never type-dependent. */
25800 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
25801 || TREE_CODE (expression
) == SIZEOF_EXPR
25802 || TREE_CODE (expression
) == ALIGNOF_EXPR
25803 || TREE_CODE (expression
) == AT_ENCODE_EXPR
25804 || TREE_CODE (expression
) == NOEXCEPT_EXPR
25805 || TREE_CODE (expression
) == TRAIT_EXPR
25806 || TREE_CODE (expression
) == TYPEID_EXPR
25807 || TREE_CODE (expression
) == DELETE_EXPR
25808 || TREE_CODE (expression
) == VEC_DELETE_EXPR
25809 || TREE_CODE (expression
) == THROW_EXPR
25810 || TREE_CODE (expression
) == REQUIRES_EXPR
)
25813 /* The types of these expressions depends only on the type to which
25814 the cast occurs. */
25815 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
25816 || TREE_CODE (expression
) == STATIC_CAST_EXPR
25817 || TREE_CODE (expression
) == CONST_CAST_EXPR
25818 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
25819 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
25820 || TREE_CODE (expression
) == CAST_EXPR
)
25821 return dependent_type_p (TREE_TYPE (expression
));
25823 /* The types of these expressions depends only on the type created
25824 by the expression. */
25825 if (TREE_CODE (expression
) == NEW_EXPR
25826 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
25828 /* For NEW_EXPR tree nodes created inside a template, either
25829 the object type itself or a TREE_LIST may appear as the
25831 tree type
= TREE_OPERAND (expression
, 1);
25832 if (TREE_CODE (type
) == TREE_LIST
)
25833 /* This is an array type. We need to check array dimensions
25835 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
25836 || value_dependent_expression_p
25837 (TREE_OPERAND (TREE_VALUE (type
), 1));
25839 return dependent_type_p (type
);
25842 if (TREE_CODE (expression
) == SCOPE_REF
)
25844 tree scope
= TREE_OPERAND (expression
, 0);
25845 tree name
= TREE_OPERAND (expression
, 1);
25847 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
25848 contains an identifier associated by name lookup with one or more
25849 declarations declared with a dependent type, or...a
25850 nested-name-specifier or qualified-id that names a member of an
25851 unknown specialization. */
25852 return (type_dependent_expression_p (name
)
25853 || dependent_scope_p (scope
));
25856 if (TREE_CODE (expression
) == TEMPLATE_DECL
25857 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
25858 return uses_outer_template_parms (expression
);
25860 if (TREE_CODE (expression
) == STMT_EXPR
)
25861 expression
= stmt_expr_value_expr (expression
);
25863 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
25868 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
25870 if (type_dependent_expression_p (elt
))
25876 /* A static data member of the current instantiation with incomplete
25877 array type is type-dependent, as the definition and specializations
25878 can have different bounds. */
25879 if (VAR_P (expression
)
25880 && DECL_CLASS_SCOPE_P (expression
)
25881 && dependent_type_p (DECL_CONTEXT (expression
))
25882 && VAR_HAD_UNKNOWN_BOUND (expression
))
25885 /* An array of unknown bound depending on a variadic parameter, eg:
25887 template<typename... Args>
25888 void foo (Args... args)
25890 int arr[] = { args... };
25893 template<int... vals>
25896 int arr[] = { vals... };
25899 If the array has no length and has an initializer, it must be that
25900 we couldn't determine its length in cp_complete_array_type because
25901 it is dependent. */
25902 if (VAR_P (expression
)
25903 && TREE_TYPE (expression
) != NULL_TREE
25904 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
25905 && !TYPE_DOMAIN (TREE_TYPE (expression
))
25906 && DECL_INITIAL (expression
))
25909 /* A function or variable template-id is type-dependent if it has any
25910 dependent template arguments. */
25911 if (VAR_OR_FUNCTION_DECL_P (expression
)
25912 && DECL_LANG_SPECIFIC (expression
)
25913 && DECL_TEMPLATE_INFO (expression
))
25915 /* Consider the innermost template arguments, since those are the ones
25916 that come from the template-id; the template arguments for the
25917 enclosing class do not make it type-dependent unless they are used in
25918 the type of the decl. */
25919 if (instantiates_primary_template_p (expression
)
25920 && (any_dependent_template_arguments_p
25921 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
25925 /* Otherwise, if the function decl isn't from a dependent scope, it can't be
25926 type-dependent. Checking this is important for functions with auto return
25927 type, which looks like a dependent type. */
25928 if (TREE_CODE (expression
) == FUNCTION_DECL
25929 && !(DECL_CLASS_SCOPE_P (expression
)
25930 && dependent_type_p (DECL_CONTEXT (expression
)))
25931 && !(DECL_LANG_SPECIFIC (expression
)
25932 && DECL_FRIEND_P (expression
)
25933 && (!DECL_FRIEND_CONTEXT (expression
)
25934 || dependent_type_p (DECL_FRIEND_CONTEXT (expression
))))
25935 && !DECL_LOCAL_FUNCTION_P (expression
))
25937 gcc_assert (!dependent_type_p (TREE_TYPE (expression
))
25938 || undeduced_auto_decl (expression
));
25942 /* Always dependent, on the number of arguments if nothing else. */
25943 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
25946 if (TREE_TYPE (expression
) == unknown_type_node
)
25948 if (TREE_CODE (expression
) == ADDR_EXPR
)
25949 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
25950 if (TREE_CODE (expression
) == COMPONENT_REF
25951 || TREE_CODE (expression
) == OFFSET_REF
)
25953 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
25955 expression
= TREE_OPERAND (expression
, 1);
25956 if (identifier_p (expression
))
25959 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
25960 if (TREE_CODE (expression
) == SCOPE_REF
)
25963 if (BASELINK_P (expression
))
25965 if (BASELINK_OPTYPE (expression
)
25966 && dependent_type_p (BASELINK_OPTYPE (expression
)))
25968 expression
= BASELINK_FUNCTIONS (expression
);
25971 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
25973 if (any_dependent_template_arguments_p
25974 (TREE_OPERAND (expression
, 1)))
25976 expression
= TREE_OPERAND (expression
, 0);
25977 if (identifier_p (expression
))
25981 gcc_assert (OVL_P (expression
));
25983 for (lkp_iterator
iter (expression
); iter
; ++iter
)
25984 if (type_dependent_expression_p (*iter
))
25990 /* The type of a non-type template parm declared with a placeholder type
25991 depends on the corresponding template argument, even though
25992 placeholders are not normally considered dependent. */
25993 if (TREE_CODE (expression
) == TEMPLATE_PARM_INDEX
25994 && is_auto (TREE_TYPE (expression
)))
25997 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
25999 /* Dependent type attributes might not have made it from the decl to
26001 if (DECL_P (expression
)
26002 && any_dependent_type_attributes_p (DECL_ATTRIBUTES (expression
)))
26005 return (dependent_type_p (TREE_TYPE (expression
)));
26008 /* [temp.dep.expr]/5: A class member access expression (5.2.5) is
26009 type-dependent if the expression refers to a member of the current
26010 instantiation and the type of the referenced member is dependent, or the
26011 class member access expression refers to a member of an unknown
26014 This function returns true if the OBJECT in such a class member access
26015 expression is of an unknown specialization. */
26018 type_dependent_object_expression_p (tree object
)
26020 /* An IDENTIFIER_NODE can sometimes have a TREE_TYPE, but it's still
26022 if (TREE_CODE (object
) == IDENTIFIER_NODE
)
26024 tree scope
= TREE_TYPE (object
);
26025 return (!scope
|| dependent_scope_p (scope
));
26028 /* walk_tree callback function for instantiation_dependent_expression_p,
26029 below. Returns non-zero if a dependent subexpression is found. */
26032 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
26037 /* We don't have to worry about decltype currently because decltype
26038 of an instantiation-dependent expr is a dependent type. This
26039 might change depending on the resolution of DR 1172. */
26040 *walk_subtrees
= false;
26043 enum tree_code code
= TREE_CODE (*tp
);
26046 /* Don't treat an argument list as dependent just because it has no
26050 case NONTYPE_ARGUMENT_PACK
:
26053 case TEMPLATE_PARM_INDEX
:
26054 if (dependent_type_p (TREE_TYPE (*tp
)))
26056 if (TEMPLATE_PARM_PARAMETER_PACK (*tp
))
26058 /* We'll check value-dependence separately. */
26061 /* Handle expressions with type operands. */
26065 case AT_ENCODE_EXPR
:
26067 tree op
= TREE_OPERAND (*tp
, 0);
26068 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
26069 op
= TREE_TYPE (op
);
26072 if (dependent_type_p (op
))
26076 *walk_subtrees
= false;
26083 case COMPONENT_REF
:
26084 if (identifier_p (TREE_OPERAND (*tp
, 1)))
26085 /* In a template, finish_class_member_access_expr creates a
26086 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
26087 type-dependent, so that we can check access control at
26088 instantiation time (PR 42277). See also Core issue 1273. */
26093 if (instantiation_dependent_scope_ref_p (*tp
))
26098 /* Treat statement-expressions as dependent. */
26102 /* Treat requires-expressions as dependent. */
26103 case REQUIRES_EXPR
:
26107 /* Treat calls to function concepts as dependent. */
26108 if (function_concept_check_p (*tp
))
26112 case TEMPLATE_ID_EXPR
:
26113 /* And variable concepts. */
26114 if (variable_concept_p (TREE_OPERAND (*tp
, 0)))
26119 if (CONSTRUCTOR_IS_DEPENDENT (*tp
))
26127 if (type_dependent_expression_p (*tp
))
26133 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
26134 sense defined by the ABI:
26136 "An expression is instantiation-dependent if it is type-dependent
26137 or value-dependent, or it has a subexpression that is type-dependent
26138 or value-dependent."
26140 Except don't actually check value-dependence for unevaluated expressions,
26141 because in sizeof(i) we don't care about the value of i. Checking
26142 type-dependence will in turn check value-dependence of array bounds/template
26143 arguments as needed. */
26146 instantiation_dependent_uneval_expression_p (tree expression
)
26150 if (!processing_template_decl
)
26153 if (expression
== error_mark_node
)
26156 result
= cp_walk_tree_without_duplicates (&expression
,
26157 instantiation_dependent_r
, NULL
);
26158 return result
!= NULL_TREE
;
26161 /* As above, but also check value-dependence of the expression as a whole. */
26164 instantiation_dependent_expression_p (tree expression
)
26166 return (instantiation_dependent_uneval_expression_p (expression
)
26167 || value_dependent_expression_p (expression
));
26170 /* Like type_dependent_expression_p, but it also works while not processing
26171 a template definition, i.e. during substitution or mangling. */
26174 type_dependent_expression_p_push (tree expr
)
26177 ++processing_template_decl
;
26178 b
= type_dependent_expression_p (expr
);
26179 --processing_template_decl
;
26183 /* Returns TRUE if ARGS contains a type-dependent expression. */
26186 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
26191 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
26193 if (type_dependent_expression_p (arg
))
26199 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
26200 expressions) contains any type-dependent expressions. */
26203 any_type_dependent_elements_p (const_tree list
)
26205 for (; list
; list
= TREE_CHAIN (list
))
26206 if (type_dependent_expression_p (TREE_VALUE (list
)))
26212 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
26213 expressions) contains any value-dependent expressions. */
26216 any_value_dependent_elements_p (const_tree list
)
26218 for (; list
; list
= TREE_CHAIN (list
))
26219 if (value_dependent_expression_p (TREE_VALUE (list
)))
26225 /* Returns TRUE if the ARG (a template argument) is dependent. */
26228 dependent_template_arg_p (tree arg
)
26230 if (!processing_template_decl
)
26233 /* Assume a template argument that was wrongly written by the user
26234 is dependent. This is consistent with what
26235 any_dependent_template_arguments_p [that calls this function]
26237 if (!arg
|| arg
== error_mark_node
)
26240 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
26241 arg
= argument_pack_select_arg (arg
);
26243 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
26245 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
26247 if (DECL_TEMPLATE_PARM_P (arg
))
26249 /* A member template of a dependent class is not necessarily
26250 type-dependent, but it is a dependent template argument because it
26251 will be a member of an unknown specialization to that template. */
26252 tree scope
= CP_DECL_CONTEXT (arg
);
26253 return TYPE_P (scope
) && dependent_type_p (scope
);
26255 else if (ARGUMENT_PACK_P (arg
))
26257 tree args
= ARGUMENT_PACK_ARGS (arg
);
26258 int i
, len
= TREE_VEC_LENGTH (args
);
26259 for (i
= 0; i
< len
; ++i
)
26261 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
26267 else if (TYPE_P (arg
))
26268 return dependent_type_p (arg
);
26270 return (type_dependent_expression_p (arg
)
26271 || value_dependent_expression_p (arg
));
26274 /* Returns true if ARGS (a collection of template arguments) contains
26275 any types that require structural equality testing. */
26278 any_template_arguments_need_structural_equality_p (tree args
)
26285 if (args
== error_mark_node
)
26288 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
26290 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
26291 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
26293 tree arg
= TREE_VEC_ELT (level
, j
);
26294 tree packed_args
= NULL_TREE
;
26297 if (ARGUMENT_PACK_P (arg
))
26299 /* Look inside the argument pack. */
26300 packed_args
= ARGUMENT_PACK_ARGS (arg
);
26301 len
= TREE_VEC_LENGTH (packed_args
);
26304 for (k
= 0; k
< len
; ++k
)
26307 arg
= TREE_VEC_ELT (packed_args
, k
);
26309 if (error_operand_p (arg
))
26311 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
26313 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
26315 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
26316 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
26325 /* Returns true if ARGS (a collection of template arguments) contains
26326 any dependent arguments. */
26329 any_dependent_template_arguments_p (const_tree args
)
26336 if (args
== error_mark_node
)
26339 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
26341 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
26342 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
26343 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
26350 /* Returns true if ARGS contains any errors. */
26353 any_erroneous_template_args_p (const_tree args
)
26358 if (args
== error_mark_node
)
26361 if (args
&& TREE_CODE (args
) != TREE_VEC
)
26363 if (tree ti
= get_template_info (args
))
26364 args
= TI_ARGS (ti
);
26372 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
26374 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
26375 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
26376 if (error_operand_p (TREE_VEC_ELT (level
, j
)))
26383 /* Returns TRUE if the template TMPL is type-dependent. */
26386 dependent_template_p (tree tmpl
)
26388 if (TREE_CODE (tmpl
) == OVERLOAD
)
26390 for (lkp_iterator
iter (tmpl
); iter
; ++iter
)
26391 if (dependent_template_p (*iter
))
26396 /* Template template parameters are dependent. */
26397 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
26398 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
26400 /* So are names that have not been looked up. */
26401 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
26406 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
26409 dependent_template_id_p (tree tmpl
, tree args
)
26411 return (dependent_template_p (tmpl
)
26412 || any_dependent_template_arguments_p (args
));
26415 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
26419 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
26423 if (!processing_template_decl
)
26426 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
26428 tree decl
= TREE_VEC_ELT (declv
, i
);
26429 tree init
= TREE_VEC_ELT (initv
, i
);
26430 tree cond
= TREE_VEC_ELT (condv
, i
);
26431 tree incr
= TREE_VEC_ELT (incrv
, i
);
26433 if (type_dependent_expression_p (decl
)
26434 || TREE_CODE (decl
) == SCOPE_REF
)
26437 if (init
&& type_dependent_expression_p (init
))
26440 if (cond
== global_namespace
)
26443 if (type_dependent_expression_p (cond
))
26446 if (COMPARISON_CLASS_P (cond
)
26447 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
26448 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
26451 if (TREE_CODE (incr
) == MODOP_EXPR
)
26453 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
26454 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
26457 else if (type_dependent_expression_p (incr
))
26459 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
26461 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
26463 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
26465 tree t
= TREE_OPERAND (incr
, 1);
26466 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
26467 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
26470 /* If this loop has a class iterator with != comparison
26471 with increment other than i++/++i/i--/--i, make sure the
26472 increment is constant. */
26473 if (CLASS_TYPE_P (TREE_TYPE (decl
))
26474 && TREE_CODE (cond
) == NE_EXPR
)
26476 if (TREE_OPERAND (t
, 0) == decl
)
26477 t
= TREE_OPERAND (t
, 1);
26479 t
= TREE_OPERAND (t
, 0);
26480 if (TREE_CODE (t
) != INTEGER_CST
)
26490 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
26491 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
26492 no such TYPE can be found. Note that this function peers inside
26493 uninstantiated templates and therefore should be used only in
26494 extremely limited situations. ONLY_CURRENT_P restricts this
26495 peering to the currently open classes hierarchy (which is required
26496 when comparing types). */
26499 resolve_typename_type (tree type
, bool only_current_p
)
26508 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
26510 scope
= TYPE_CONTEXT (type
);
26511 /* We shouldn't have built a TYPENAME_TYPE with a non-dependent scope. */
26512 gcc_checking_assert (uses_template_parms (scope
));
26514 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
26515 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
26516 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
26517 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
26518 identifier of the TYPENAME_TYPE anymore.
26519 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
26520 TYPENAME_TYPE instead, we avoid messing up with a possible
26521 typedef variant case. */
26522 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
26524 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
26525 it first before we can figure out what NAME refers to. */
26526 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
26528 if (TYPENAME_IS_RESOLVING_P (scope
))
26529 /* Given a class template A with a dependent base with nested type C,
26530 typedef typename A::C::C C will land us here, as trying to resolve
26531 the initial A::C leads to the local C typedef, which leads back to
26532 A::C::C. So we break the recursion now. */
26535 scope
= resolve_typename_type (scope
, only_current_p
);
26537 /* If we don't know what SCOPE refers to, then we cannot resolve the
26539 if (!CLASS_TYPE_P (scope
))
26541 /* If this is a typedef, we don't want to look inside (c++/11987). */
26542 if (typedef_variant_p (type
))
26544 /* If SCOPE isn't the template itself, it will not have a valid
26545 TYPE_FIELDS list. */
26546 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
26547 /* scope is either the template itself or a compatible instantiation
26548 like X<T>, so look up the name in the original template. */
26549 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
26550 /* If scope has no fields, it can't be a current instantiation. Check this
26551 before currently_open_class to avoid infinite recursion (71515). */
26552 if (!TYPE_FIELDS (scope
))
26554 /* If the SCOPE is not the current instantiation, there's no reason
26555 to look inside it. */
26556 if (only_current_p
&& !currently_open_class (scope
))
26558 /* Enter the SCOPE so that name lookup will be resolved as if we
26559 were in the class definition. In particular, SCOPE will no
26560 longer be considered a dependent type. */
26561 pushed_scope
= push_scope (scope
);
26562 /* Look up the declaration. */
26563 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
26564 tf_warning_or_error
);
26566 result
= NULL_TREE
;
26568 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
26569 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
26570 tree fullname
= TYPENAME_TYPE_FULLNAME (type
);
26573 else if (identifier_p (fullname
)
26574 && TREE_CODE (decl
) == TYPE_DECL
)
26576 result
= TREE_TYPE (decl
);
26577 if (result
== error_mark_node
)
26578 result
= NULL_TREE
;
26580 else if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
26581 && DECL_CLASS_TEMPLATE_P (decl
))
26583 /* Obtain the template and the arguments. */
26584 tree tmpl
= TREE_OPERAND (fullname
, 0);
26585 if (TREE_CODE (tmpl
) == IDENTIFIER_NODE
)
26587 /* We get here with a plain identifier because a previous tentative
26588 parse of the nested-name-specifier as part of a ptr-operator saw
26589 ::template X<A>. The use of ::template is necessary in a
26590 ptr-operator, but wrong in a declarator-id.
26592 [temp.names]: In a qualified-id of a declarator-id, the keyword
26593 template shall not appear at the top level. */
26594 pedwarn (cp_expr_loc_or_loc (fullname
, input_location
), OPT_Wpedantic
,
26595 "keyword %<template%> not allowed in declarator-id");
26598 tree args
= TREE_OPERAND (fullname
, 1);
26599 /* Instantiate the template. */
26600 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
26601 /*entering_scope=*/true,
26602 tf_error
| tf_user
);
26603 if (result
== error_mark_node
)
26604 result
= NULL_TREE
;
26607 /* Leave the SCOPE. */
26609 pop_scope (pushed_scope
);
26611 /* If we failed to resolve it, return the original typename. */
26615 /* If lookup found a typename type, resolve that too. */
26616 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
26618 /* Ill-formed programs can cause infinite recursion here, so we
26619 must catch that. */
26620 TYPENAME_IS_RESOLVING_P (result
) = 1;
26621 result
= resolve_typename_type (result
, only_current_p
);
26622 TYPENAME_IS_RESOLVING_P (result
) = 0;
26625 /* Qualify the resulting type. */
26626 quals
= cp_type_quals (type
);
26628 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
26633 /* EXPR is an expression which is not type-dependent. Return a proxy
26634 for EXPR that can be used to compute the types of larger
26635 expressions containing EXPR. */
26638 build_non_dependent_expr (tree expr
)
26640 tree orig_expr
= expr
;
26643 /* When checking, try to get a constant value for all non-dependent
26644 expressions in order to expose bugs in *_dependent_expression_p
26645 and constexpr. This can affect code generation, see PR70704, so
26646 only do this for -fchecking=2. */
26647 if (flag_checking
> 1
26648 && cxx_dialect
>= cxx11
26649 /* Don't do this during nsdmi parsing as it can lead to
26650 unexpected recursive instantiations. */
26651 && !parsing_nsdmi ()
26652 /* Don't do this during concept expansion either and for
26653 the same reason. */
26654 && !expanding_concept ())
26655 fold_non_dependent_expr (expr
, tf_none
);
26657 STRIP_ANY_LOCATION_WRAPPER (expr
);
26659 /* Preserve OVERLOADs; the functions must be available to resolve
26662 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
26663 inner_expr
= stmt_expr_value_expr (inner_expr
);
26664 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
26665 inner_expr
= TREE_OPERAND (inner_expr
, 0);
26666 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
26667 inner_expr
= TREE_OPERAND (inner_expr
, 1);
26668 if (is_overloaded_fn (inner_expr
)
26669 || TREE_CODE (inner_expr
) == OFFSET_REF
)
26671 /* There is no need to return a proxy for a variable or enumerator. */
26672 if (VAR_P (expr
) || TREE_CODE (expr
) == CONST_DECL
)
26674 /* Preserve string constants; conversions from string constants to
26675 "char *" are allowed, even though normally a "const char *"
26676 cannot be used to initialize a "char *". */
26677 if (TREE_CODE (expr
) == STRING_CST
)
26679 /* Preserve void and arithmetic constants, as an optimization -- there is no
26680 reason to create a new node. */
26681 if (TREE_CODE (expr
) == VOID_CST
26682 || TREE_CODE (expr
) == INTEGER_CST
26683 || TREE_CODE (expr
) == REAL_CST
)
26685 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
26686 There is at least one place where we want to know that a
26687 particular expression is a throw-expression: when checking a ?:
26688 expression, there are special rules if the second or third
26689 argument is a throw-expression. */
26690 if (TREE_CODE (expr
) == THROW_EXPR
)
26693 /* Don't wrap an initializer list, we need to be able to look inside. */
26694 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
26697 /* Don't wrap a dummy object, we need to be able to test for it. */
26698 if (is_dummy_object (expr
))
26701 if (TREE_CODE (expr
) == COND_EXPR
)
26702 return build3 (COND_EXPR
,
26704 TREE_OPERAND (expr
, 0),
26705 (TREE_OPERAND (expr
, 1)
26706 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
26707 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
26708 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
26709 if (TREE_CODE (expr
) == COMPOUND_EXPR
26710 && !COMPOUND_EXPR_OVERLOADED (expr
))
26711 return build2 (COMPOUND_EXPR
,
26713 TREE_OPERAND (expr
, 0),
26714 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
26716 /* If the type is unknown, it can't really be non-dependent */
26717 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
26719 /* Otherwise, build a NON_DEPENDENT_EXPR. */
26720 return build1_loc (EXPR_LOCATION (orig_expr
), NON_DEPENDENT_EXPR
,
26721 TREE_TYPE (expr
), expr
);
26724 /* ARGS is a vector of expressions as arguments to a function call.
26725 Replace the arguments with equivalent non-dependent expressions.
26726 This modifies ARGS in place. */
26729 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
26734 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
26736 tree newarg
= build_non_dependent_expr (arg
);
26738 (*args
)[ix
] = newarg
;
26742 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
26743 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
26744 parms. If set_canonical is true, we set TYPE_CANONICAL on it. */
26747 make_auto_1 (tree name
, bool set_canonical
)
26749 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
26750 TYPE_NAME (au
) = build_decl (input_location
,
26751 TYPE_DECL
, name
, au
);
26752 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
26753 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
26754 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
26755 TYPE_NAME (au
), NULL_TREE
);
26757 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
26758 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
26759 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
26765 make_decltype_auto (void)
26767 return make_auto_1 (decltype_auto_identifier
, true);
26773 return make_auto_1 (auto_identifier
, true);
26776 /* Return a C++17 deduction placeholder for class template TMPL. */
26779 make_template_placeholder (tree tmpl
)
26781 tree t
= make_auto_1 (auto_identifier
, false);
26782 CLASS_PLACEHOLDER_TEMPLATE (t
) = tmpl
;
26783 /* Our canonical type depends on the placeholder. */
26784 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
26788 /* True iff T is a C++17 class template deduction placeholder. */
26791 template_placeholder_p (tree t
)
26793 return is_auto (t
) && CLASS_PLACEHOLDER_TEMPLATE (t
);
26796 /* Make a "constrained auto" type-specifier. This is an
26797 auto type with constraints that must be associated after
26798 deduction. The constraint is formed from the given
26799 CONC and its optional sequence of arguments, which are
26800 non-null if written as partial-concept-id. */
26803 make_constrained_auto (tree con
, tree args
)
26805 tree type
= make_auto_1 (auto_identifier
, false);
26807 /* Build the constraint. */
26808 tree tmpl
= DECL_TI_TEMPLATE (con
);
26809 tree expr
= VAR_P (con
) ? tmpl
: ovl_make (tmpl
);
26810 expr
= build_concept_check (expr
, type
, args
);
26812 tree constr
= normalize_expression (expr
);
26813 PLACEHOLDER_TYPE_CONSTRAINTS (type
) = constr
;
26815 /* Our canonical type depends on the constraint. */
26816 TYPE_CANONICAL (type
) = canonical_type_parameter (type
);
26818 /* Attach the constraint to the type declaration. */
26819 tree decl
= TYPE_NAME (type
);
26823 /* Given type ARG, return std::initializer_list<ARG>. */
26828 tree std_init_list
= get_namespace_binding (std_node
, init_list_identifier
);
26830 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
26832 gcc_rich_location
richloc (input_location
);
26833 maybe_add_include_fixit (&richloc
, "<initializer_list>", false);
26834 error_at (&richloc
,
26835 "deducing from brace-enclosed initializer list"
26836 " requires %<#include <initializer_list>%>");
26838 return error_mark_node
;
26840 tree argvec
= make_tree_vec (1);
26841 TREE_VEC_ELT (argvec
, 0) = arg
;
26843 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
26844 NULL_TREE
, 0, tf_warning_or_error
);
26847 /* Replace auto in TYPE with std::initializer_list<auto>. */
26850 listify_autos (tree type
, tree auto_node
)
26852 tree init_auto
= listify (strip_top_quals (auto_node
));
26853 tree argvec
= make_tree_vec (1);
26854 TREE_VEC_ELT (argvec
, 0) = init_auto
;
26855 if (processing_template_decl
)
26856 argvec
= add_to_template_args (current_template_args (), argvec
);
26857 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
26860 /* Hash traits for hashing possibly constrained 'auto'
26861 TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
26863 struct auto_hash
: default_hash_traits
<tree
>
26865 static inline hashval_t
hash (tree
);
26866 static inline bool equal (tree
, tree
);
26869 /* Hash the 'auto' T. */
26872 auto_hash::hash (tree t
)
26874 if (tree c
= NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS (t
)))
26875 /* Matching constrained-type-specifiers denote the same template
26876 parameter, so hash the constraint. */
26877 return hash_placeholder_constraint (c
);
26879 /* But unconstrained autos are all separate, so just hash the pointer. */
26880 return iterative_hash_object (t
, 0);
26883 /* Compare two 'auto's. */
26886 auto_hash::equal (tree t1
, tree t2
)
26891 tree c1
= PLACEHOLDER_TYPE_CONSTRAINTS (t1
);
26892 tree c2
= PLACEHOLDER_TYPE_CONSTRAINTS (t2
);
26894 /* Two unconstrained autos are distinct. */
26898 return equivalent_placeholder_constraints (c1
, c2
);
26901 /* for_each_template_parm callback for extract_autos: if t is a (possibly
26902 constrained) auto, add it to the vector. */
26905 extract_autos_r (tree t
, void *data
)
26907 hash_table
<auto_hash
> &hash
= *(hash_table
<auto_hash
>*)data
;
26910 /* All the autos were built with index 0; fix that up now. */
26911 tree
*p
= hash
.find_slot (t
, INSERT
);
26914 /* If this is a repeated constrained-type-specifier, use the index we
26916 idx
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (*p
));
26919 /* Otherwise this is new, so use the current count. */
26921 idx
= hash
.elements () - 1;
26923 TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (t
)) = idx
;
26926 /* Always keep walking. */
26930 /* Return a TREE_VEC of the 'auto's used in type under the Concepts TS, which
26931 says they can appear anywhere in the type. */
26934 extract_autos (tree type
)
26936 hash_set
<tree
> visited
;
26937 hash_table
<auto_hash
> hash (2);
26939 for_each_template_parm (type
, extract_autos_r
, &hash
, &visited
, true);
26941 tree tree_vec
= make_tree_vec (hash
.elements());
26942 for (hash_table
<auto_hash
>::iterator iter
= hash
.begin();
26943 iter
!= hash
.end(); ++iter
)
26946 unsigned i
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (elt
));
26947 TREE_VEC_ELT (tree_vec
, i
)
26948 = build_tree_list (NULL_TREE
, TYPE_NAME (elt
));
26954 /* The stem for deduction guide names. */
26955 const char *const dguide_base
= "__dguide_";
26957 /* Return the name for a deduction guide for class template TMPL. */
26960 dguide_name (tree tmpl
)
26962 tree type
= (TYPE_P (tmpl
) ? tmpl
: TREE_TYPE (tmpl
));
26963 tree tname
= TYPE_IDENTIFIER (type
);
26964 char *buf
= (char *) alloca (1 + strlen (dguide_base
)
26965 + IDENTIFIER_LENGTH (tname
));
26966 memcpy (buf
, dguide_base
, strlen (dguide_base
));
26967 memcpy (buf
+ strlen (dguide_base
), IDENTIFIER_POINTER (tname
),
26968 IDENTIFIER_LENGTH (tname
) + 1);
26969 tree dname
= get_identifier (buf
);
26970 TREE_TYPE (dname
) = type
;
26974 /* True if NAME is the name of a deduction guide. */
26977 dguide_name_p (tree name
)
26979 return (TREE_CODE (name
) == IDENTIFIER_NODE
26980 && TREE_TYPE (name
)
26981 && !strncmp (IDENTIFIER_POINTER (name
), dguide_base
,
26982 strlen (dguide_base
)));
26985 /* True if FN is a deduction guide. */
26988 deduction_guide_p (const_tree fn
)
26991 if (tree name
= DECL_NAME (fn
))
26992 return dguide_name_p (name
);
26996 /* True if FN is the copy deduction guide, i.e. A(A)->A. */
26999 copy_guide_p (const_tree fn
)
27001 gcc_assert (deduction_guide_p (fn
));
27002 if (!DECL_ARTIFICIAL (fn
))
27004 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (DECL_TI_TEMPLATE (fn
));
27005 return (TREE_CHAIN (parms
) == void_list_node
27006 && same_type_p (TREE_VALUE (parms
), TREE_TYPE (DECL_NAME (fn
))));
27009 /* True if FN is a guide generated from a constructor template. */
27012 template_guide_p (const_tree fn
)
27014 gcc_assert (deduction_guide_p (fn
));
27015 if (!DECL_ARTIFICIAL (fn
))
27017 tree tmpl
= DECL_TI_TEMPLATE (fn
);
27018 if (tree org
= DECL_ABSTRACT_ORIGIN (tmpl
))
27019 return PRIMARY_TEMPLATE_P (org
);
27023 /* OLDDECL is a _DECL for a template parameter. Return a similar parameter at
27024 LEVEL:INDEX, using tsubst_args and complain for substitution into non-type
27025 template parameter types. Note that the handling of template template
27026 parameters relies on current_template_parms being set appropriately for the
27030 rewrite_template_parm (tree olddecl
, unsigned index
, unsigned level
,
27031 tree tsubst_args
, tsubst_flags_t complain
)
27033 if (olddecl
== error_mark_node
)
27034 return error_mark_node
;
27036 tree oldidx
= get_template_parm_index (olddecl
);
27039 if (TREE_CODE (olddecl
) == TYPE_DECL
27040 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
27042 tree oldtype
= TREE_TYPE (olddecl
);
27043 newtype
= cxx_make_type (TREE_CODE (oldtype
));
27044 TYPE_MAIN_VARIANT (newtype
) = newtype
;
27045 if (TREE_CODE (oldtype
) == TEMPLATE_TYPE_PARM
)
27046 TEMPLATE_TYPE_PARM_FOR_CLASS (newtype
)
27047 = TEMPLATE_TYPE_PARM_FOR_CLASS (oldtype
);
27051 newtype
= TREE_TYPE (olddecl
);
27052 if (type_uses_auto (newtype
))
27054 // Substitute once to fix references to other template parameters.
27055 newtype
= tsubst (newtype
, tsubst_args
,
27056 complain
|tf_partial
, NULL_TREE
);
27057 // Now substitute again to reduce the level of the auto.
27058 newtype
= tsubst (newtype
, current_template_args (),
27059 complain
, NULL_TREE
);
27062 newtype
= tsubst (newtype
, tsubst_args
,
27063 complain
, NULL_TREE
);
27067 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TREE_CODE (olddecl
),
27068 DECL_NAME (olddecl
), newtype
);
27069 SET_DECL_TEMPLATE_PARM_P (newdecl
);
27072 if (TREE_CODE (olddecl
) == TYPE_DECL
27073 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
27075 newidx
= TEMPLATE_TYPE_PARM_INDEX (newtype
)
27076 = build_template_parm_index (index
, level
, level
,
27078 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
27079 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
27080 TYPE_STUB_DECL (newtype
) = TYPE_NAME (newtype
) = newdecl
;
27081 TYPE_CANONICAL (newtype
) = canonical_type_parameter (newtype
);
27083 if (TREE_CODE (olddecl
) == TEMPLATE_DECL
)
27085 DECL_TEMPLATE_RESULT (newdecl
)
27086 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TYPE_DECL
,
27087 DECL_NAME (olddecl
), newtype
);
27088 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (newdecl
)) = true;
27089 // First create a copy (ttargs) of tsubst_args with an
27090 // additional level for the template template parameter's own
27091 // template parameters (ttparms).
27092 tree ttparms
= (INNERMOST_TEMPLATE_PARMS
27093 (DECL_TEMPLATE_PARMS (olddecl
)));
27094 const int depth
= TMPL_ARGS_DEPTH (tsubst_args
);
27095 tree ttargs
= make_tree_vec (depth
+ 1);
27096 for (int i
= 0; i
< depth
; ++i
)
27097 TREE_VEC_ELT (ttargs
, i
) = TREE_VEC_ELT (tsubst_args
, i
);
27098 TREE_VEC_ELT (ttargs
, depth
)
27099 = template_parms_level_to_args (ttparms
);
27100 // Substitute ttargs into ttparms to fix references to
27101 // other template parameters.
27102 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
27103 complain
|tf_partial
);
27104 // Now substitute again with args based on tparms, to reduce
27105 // the level of the ttparms.
27106 ttargs
= current_template_args ();
27107 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
27109 // Finally, tack the adjusted parms onto tparms.
27110 ttparms
= tree_cons (size_int (depth
), ttparms
,
27111 current_template_parms
);
27112 DECL_TEMPLATE_PARMS (newdecl
) = ttparms
;
27117 tree oldconst
= TEMPLATE_PARM_DECL (oldidx
);
27119 = build_decl (DECL_SOURCE_LOCATION (oldconst
),
27120 TREE_CODE (oldconst
),
27121 DECL_NAME (oldconst
), newtype
);
27122 TREE_CONSTANT (newconst
) = TREE_CONSTANT (newdecl
)
27123 = TREE_READONLY (newconst
) = TREE_READONLY (newdecl
) = true;
27124 SET_DECL_TEMPLATE_PARM_P (newconst
);
27125 newidx
= build_template_parm_index (index
, level
, level
,
27126 newconst
, newtype
);
27127 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
27128 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
27129 DECL_INITIAL (newdecl
) = DECL_INITIAL (newconst
) = newidx
;
27135 /* Returns a C++17 class deduction guide template based on the constructor
27136 CTOR. As a special case, CTOR can be a RECORD_TYPE for an implicit default
27137 guide, or REFERENCE_TYPE for an implicit copy/move guide. */
27140 build_deduction_guide (tree ctor
, tree outer_args
, tsubst_flags_t complain
)
27142 tree type
, tparms
, targs
, fparms
, fargs
, ci
;
27143 bool memtmpl
= false;
27146 tree fn_tmpl
= NULL_TREE
;
27151 bool copy_p
= TYPE_REF_P (type
);
27154 type
= TREE_TYPE (type
);
27155 fparms
= tree_cons (NULL_TREE
, type
, void_list_node
);
27158 fparms
= void_list_node
;
27160 tree ctmpl
= CLASSTYPE_TI_TEMPLATE (type
);
27161 tparms
= DECL_TEMPLATE_PARMS (ctmpl
);
27162 targs
= CLASSTYPE_TI_ARGS (type
);
27165 loc
= DECL_SOURCE_LOCATION (ctmpl
);
27166 explicit_p
= false;
27170 ++processing_template_decl
;
27174 = (TREE_CODE (ctor
) == TEMPLATE_DECL
? ctor
27175 : DECL_TI_TEMPLATE (ctor
));
27177 fn_tmpl
= tsubst (fn_tmpl
, outer_args
, complain
, ctor
);
27178 ctor
= DECL_TEMPLATE_RESULT (fn_tmpl
);
27180 type
= DECL_CONTEXT (ctor
);
27182 tparms
= DECL_TEMPLATE_PARMS (fn_tmpl
);
27183 /* If type is a member class template, DECL_TI_ARGS (ctor) will have
27184 fully specialized args for the enclosing class. Strip those off, as
27185 the deduction guide won't have those template parameters. */
27186 targs
= get_innermost_template_args (DECL_TI_ARGS (ctor
),
27187 TMPL_PARMS_DEPTH (tparms
));
27188 /* Discard the 'this' parameter. */
27189 fparms
= FUNCTION_ARG_CHAIN (ctor
);
27190 fargs
= TREE_CHAIN (DECL_ARGUMENTS (ctor
));
27191 ci
= get_constraints (ctor
);
27192 loc
= DECL_SOURCE_LOCATION (ctor
);
27193 explicit_p
= DECL_NONCONVERTING_P (ctor
);
27195 if (PRIMARY_TEMPLATE_P (fn_tmpl
))
27199 /* For a member template constructor, we need to flatten the two
27200 template parameter lists into one, and then adjust the function
27201 signature accordingly. This gets...complicated. */
27202 tree save_parms
= current_template_parms
;
27204 /* For a member template we should have two levels of parms/args, one
27205 for the class and one for the constructor. We stripped
27206 specialized args for further enclosing classes above. */
27207 const int depth
= 2;
27208 gcc_assert (TMPL_ARGS_DEPTH (targs
) == depth
);
27210 /* Template args for translating references to the two-level template
27211 parameters into references to the one-level template parameters we
27213 tree tsubst_args
= copy_node (targs
);
27214 TMPL_ARGS_LEVEL (tsubst_args
, depth
)
27215 = copy_node (TMPL_ARGS_LEVEL (tsubst_args
, depth
));
27217 /* Template parms for the constructor template. */
27218 tree ftparms
= TREE_VALUE (tparms
);
27219 unsigned flen
= TREE_VEC_LENGTH (ftparms
);
27220 /* Template parms for the class template. */
27221 tparms
= TREE_CHAIN (tparms
);
27222 tree ctparms
= TREE_VALUE (tparms
);
27223 unsigned clen
= TREE_VEC_LENGTH (ctparms
);
27224 /* Template parms for the deduction guide start as a copy of the
27225 template parms for the class. We set current_template_parms for
27226 lookup_template_class_1. */
27227 current_template_parms
= tparms
= copy_node (tparms
);
27228 tree new_vec
= TREE_VALUE (tparms
) = make_tree_vec (flen
+ clen
);
27229 for (unsigned i
= 0; i
< clen
; ++i
)
27230 TREE_VEC_ELT (new_vec
, i
) = TREE_VEC_ELT (ctparms
, i
);
27232 /* Now we need to rewrite the constructor parms to append them to the
27234 for (unsigned i
= 0; i
< flen
; ++i
)
27236 unsigned index
= i
+ clen
;
27237 unsigned level
= 1;
27238 tree oldelt
= TREE_VEC_ELT (ftparms
, i
);
27239 tree olddecl
= TREE_VALUE (oldelt
);
27240 tree newdecl
= rewrite_template_parm (olddecl
, index
, level
,
27241 tsubst_args
, complain
);
27242 if (newdecl
== error_mark_node
)
27244 tree newdef
= tsubst_template_arg (TREE_PURPOSE (oldelt
),
27245 tsubst_args
, complain
, ctor
);
27246 tree list
= build_tree_list (newdef
, newdecl
);
27247 TEMPLATE_PARM_CONSTRAINTS (list
)
27248 = tsubst_constraint_info (TEMPLATE_PARM_CONSTRAINTS (oldelt
),
27249 tsubst_args
, complain
, ctor
);
27250 TREE_VEC_ELT (new_vec
, index
) = list
;
27251 TMPL_ARG (tsubst_args
, depth
, i
) = template_parm_to_arg (list
);
27254 /* Now we have a final set of template parms to substitute into the
27255 function signature. */
27256 targs
= template_parms_to_args (tparms
);
27257 fparms
= tsubst_arg_types (fparms
, tsubst_args
, NULL_TREE
,
27259 if (fparms
== error_mark_node
)
27261 fargs
= tsubst (fargs
, tsubst_args
, complain
, ctor
);
27263 ci
= tsubst_constraint_info (ci
, tsubst_args
, complain
, ctor
);
27265 current_template_parms
= save_parms
;
27268 --processing_template_decl
;
27270 return error_mark_node
;
27275 /* Copy the parms so we can set DECL_PRIMARY_TEMPLATE. */
27276 tparms
= copy_node (tparms
);
27277 INNERMOST_TEMPLATE_PARMS (tparms
)
27278 = copy_node (INNERMOST_TEMPLATE_PARMS (tparms
));
27281 tree fntype
= build_function_type (type
, fparms
);
27282 tree ded_fn
= build_lang_decl_loc (loc
,
27284 dguide_name (type
), fntype
);
27285 DECL_ARGUMENTS (ded_fn
) = fargs
;
27286 DECL_ARTIFICIAL (ded_fn
) = true;
27287 DECL_NONCONVERTING_P (ded_fn
) = explicit_p
;
27288 tree ded_tmpl
= build_template_decl (ded_fn
, tparms
, /*member*/false);
27289 DECL_ARTIFICIAL (ded_tmpl
) = true;
27290 DECL_TEMPLATE_RESULT (ded_tmpl
) = ded_fn
;
27291 TREE_TYPE (ded_tmpl
) = TREE_TYPE (ded_fn
);
27292 DECL_TEMPLATE_INFO (ded_fn
) = build_template_info (ded_tmpl
, targs
);
27293 DECL_PRIMARY_TEMPLATE (ded_tmpl
) = ded_tmpl
;
27295 DECL_ABSTRACT_ORIGIN (ded_tmpl
) = fn_tmpl
;
27297 set_constraints (ded_tmpl
, ci
);
27302 /* Deduce template arguments for the class template placeholder PTYPE for
27303 template TMPL based on the initializer INIT, and return the resulting
27307 do_class_deduction (tree ptype
, tree tmpl
, tree init
, int flags
,
27308 tsubst_flags_t complain
)
27310 if (!DECL_CLASS_TEMPLATE_P (tmpl
))
27312 /* We should have handled this in the caller. */
27313 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
))
27315 if (complain
& tf_error
)
27316 error ("non-class template %qT used without template arguments", tmpl
);
27317 return error_mark_node
;
27319 if (init
&& TREE_TYPE (init
) == ptype
)
27320 /* Using the template parm as its own argument. */
27323 tree type
= TREE_TYPE (tmpl
);
27325 bool try_list_ctor
= false;
27327 releasing_vec rv_args
= NULL
;
27328 vec
<tree
,va_gc
> *&args
= *&rv_args
;
27329 if (init
== NULL_TREE
27330 || TREE_CODE (init
) == TREE_LIST
)
27331 args
= make_tree_vector_from_list (init
);
27332 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
27334 try_list_ctor
= TYPE_HAS_LIST_CTOR (type
);
27335 if (try_list_ctor
&& CONSTRUCTOR_NELTS (init
) == 1)
27337 /* As an exception, the first phase in 16.3.1.7 (considering the
27338 initializer list as a single argument) is omitted if the
27339 initializer list consists of a single expression of type cv U,
27340 where U is a specialization of C or a class derived from a
27341 specialization of C. */
27342 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
27343 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
27345 tree etype
= TREE_TYPE (elt
);
27346 tree tparms
= (INNERMOST_TEMPLATE_PARMS
27347 (DECL_TEMPLATE_PARMS (tmpl
)));
27348 tree targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
27349 int err
= unify (tparms
, targs
, type
, etype
,
27350 UNIFY_ALLOW_DERIVED
, /*explain*/false);
27352 try_list_ctor
= false;
27356 if (try_list_ctor
|| is_std_init_list (type
))
27357 args
= make_tree_vector_single (init
);
27359 args
= make_tree_vector_from_ctor (init
);
27362 args
= make_tree_vector_single (init
);
27364 tree dname
= dguide_name (tmpl
);
27365 tree cands
= lookup_qualified_name (CP_DECL_CONTEXT (tmpl
), dname
,
27366 /*type*/false, /*complain*/false,
27368 bool elided
= false;
27369 if (cands
== error_mark_node
)
27372 /* Prune explicit deduction guides in copy-initialization context. */
27373 if (flags
& LOOKUP_ONLYCONVERTING
)
27375 for (lkp_iterator
iter (cands
); !elided
&& iter
; ++iter
)
27376 if (DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
27381 /* Found a nonconverting guide, prune the candidates. */
27382 tree pruned
= NULL_TREE
;
27383 for (lkp_iterator
iter (cands
); iter
; ++iter
)
27384 if (!DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
27385 pruned
= lookup_add (*iter
, pruned
);
27391 tree outer_args
= NULL_TREE
;
27392 if (DECL_CLASS_SCOPE_P (tmpl
)
27393 && CLASSTYPE_TEMPLATE_INSTANTIATION (DECL_CONTEXT (tmpl
)))
27395 outer_args
= CLASSTYPE_TI_ARGS (DECL_CONTEXT (tmpl
));
27396 type
= TREE_TYPE (most_general_template (tmpl
));
27399 bool saw_ctor
= false;
27400 // FIXME cache artificial deduction guides
27401 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (type
)); iter
; ++iter
)
27403 /* Skip inherited constructors. */
27404 if (iter
.using_p ())
27407 tree guide
= build_deduction_guide (*iter
, outer_args
, complain
);
27408 if (guide
== error_mark_node
)
27409 return error_mark_node
;
27410 if ((flags
& LOOKUP_ONLYCONVERTING
)
27411 && DECL_NONCONVERTING_P (STRIP_TEMPLATE (guide
)))
27414 cands
= lookup_add (guide
, cands
);
27419 tree call
= error_mark_node
;
27421 /* If this is list-initialization and the class has a list constructor, first
27422 try deducing from the list as a single argument, as [over.match.list]. */
27423 tree list_cands
= NULL_TREE
;
27424 if (try_list_ctor
&& cands
)
27425 for (lkp_iterator
iter (cands
); iter
; ++iter
)
27428 if (is_list_ctor (dg
))
27429 list_cands
= lookup_add (dg
, list_cands
);
27433 ++cp_unevaluated_operand
;
27434 call
= build_new_function_call (list_cands
, &args
, tf_decltype
);
27435 --cp_unevaluated_operand
;
27437 if (call
== error_mark_node
)
27439 /* That didn't work, now try treating the list as a sequence of
27441 release_tree_vector (args
);
27442 args
= make_tree_vector_from_ctor (init
);
27446 /* Maybe generate an implicit deduction guide. */
27447 if (call
== error_mark_node
&& args
->length () < 2)
27449 tree gtype
= NULL_TREE
;
27451 if (args
->length () == 1)
27452 /* Generate a copy guide. */
27453 gtype
= build_reference_type (type
);
27454 else if (!saw_ctor
)
27455 /* Generate a default guide. */
27460 tree guide
= build_deduction_guide (gtype
, outer_args
, complain
);
27461 if (guide
== error_mark_node
)
27462 return error_mark_node
;
27463 cands
= lookup_add (guide
, cands
);
27467 if (elided
&& !cands
)
27469 error ("cannot deduce template arguments for copy-initialization"
27470 " of %qT, as it has no non-explicit deduction guides or "
27471 "user-declared constructors", type
);
27472 return error_mark_node
;
27474 else if (!cands
&& call
== error_mark_node
)
27476 error ("cannot deduce template arguments of %qT, as it has no viable "
27477 "deduction guides", type
);
27478 return error_mark_node
;
27481 if (call
== error_mark_node
)
27483 ++cp_unevaluated_operand
;
27484 call
= build_new_function_call (cands
, &args
, tf_decltype
);
27485 --cp_unevaluated_operand
;
27488 if (call
== error_mark_node
&& (complain
& tf_warning_or_error
))
27490 error ("class template argument deduction failed:");
27492 ++cp_unevaluated_operand
;
27493 call
= build_new_function_call (cands
, &args
, complain
| tf_decltype
);
27494 --cp_unevaluated_operand
;
27497 inform (input_location
, "explicit deduction guides not considered "
27498 "for copy-initialization");
27501 return cp_build_qualified_type (TREE_TYPE (call
), cp_type_quals (ptype
));
27504 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
27505 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
27506 The CONTEXT determines the context in which auto deduction is performed
27507 and is used to control error diagnostics. FLAGS are the LOOKUP_* flags.
27508 OUTER_TARGS are used during template argument deduction
27509 (context == adc_unify) to properly substitute the result, and is ignored
27512 For partial-concept-ids, extra args may be appended to the list of deduced
27513 template arguments prior to determining constraint satisfaction. */
27516 do_auto_deduction (tree type
, tree init
, tree auto_node
,
27517 tsubst_flags_t complain
, auto_deduction_context context
,
27518 tree outer_targs
, int flags
)
27522 if (init
== error_mark_node
)
27523 return error_mark_node
;
27525 if (init
&& type_dependent_expression_p (init
)
27526 && context
!= adc_unify
)
27527 /* Defining a subset of type-dependent expressions that we can deduce
27528 from ahead of time isn't worth the trouble. */
27531 /* Similarly, we can't deduce from another undeduced decl. */
27532 if (init
&& undeduced_auto_decl (init
))
27535 /* We may be doing a partial substitution, but we still want to replace
27537 complain
&= ~tf_partial
;
27539 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
27540 /* C++17 class template argument deduction. */
27541 return do_class_deduction (type
, tmpl
, init
, flags
, complain
);
27543 if (init
== NULL_TREE
|| TREE_TYPE (init
) == NULL_TREE
)
27544 /* Nothing we can do with this, even in deduction context. */
27547 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
27548 with either a new invented type template parameter U or, if the
27549 initializer is a braced-init-list (8.5.4), with
27550 std::initializer_list<U>. */
27551 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
27553 if (!DIRECT_LIST_INIT_P (init
))
27554 type
= listify_autos (type
, auto_node
);
27555 else if (CONSTRUCTOR_NELTS (init
) == 1)
27556 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
27559 if (complain
& tf_warning_or_error
)
27561 if (permerror (input_location
, "direct-list-initialization of "
27562 "%<auto%> requires exactly one element"))
27563 inform (input_location
,
27564 "for deduction to %<std::initializer_list%>, use copy-"
27565 "list-initialization (i.e. add %<=%> before the %<{%>)");
27567 type
= listify_autos (type
, auto_node
);
27571 if (type
== error_mark_node
)
27572 return error_mark_node
;
27574 init
= resolve_nondeduced_context (init
, complain
);
27576 if (context
== adc_decomp_type
27577 && auto_node
== type
27578 && init
!= error_mark_node
27579 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
27580 /* [dcl.decomp]/1 - if decomposition declaration has no ref-qualifiers
27581 and initializer has array type, deduce cv-qualified array type. */
27582 return cp_build_qualified_type_real (TREE_TYPE (init
), TYPE_QUALS (type
),
27584 else if (AUTO_IS_DECLTYPE (auto_node
))
27586 tree stripped_init
= tree_strip_any_location_wrapper (init
);
27587 bool id
= (DECL_P (stripped_init
)
27588 || ((TREE_CODE (init
) == COMPONENT_REF
27589 || TREE_CODE (init
) == SCOPE_REF
)
27590 && !REF_PARENTHESIZED_P (init
)));
27591 targs
= make_tree_vec (1);
27592 TREE_VEC_ELT (targs
, 0)
27593 = finish_decltype_type (init
, id
, tf_warning_or_error
);
27594 if (type
!= auto_node
)
27596 if (complain
& tf_error
)
27597 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
27598 return error_mark_node
;
27603 tree parms
= build_tree_list (NULL_TREE
, type
);
27607 tparms
= extract_autos (type
);
27610 tparms
= make_tree_vec (1);
27611 TREE_VEC_ELT (tparms
, 0)
27612 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
27615 targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
27616 int val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
27618 NULL
, /*explain_p=*/false);
27621 if (processing_template_decl
)
27622 /* Try again at instantiation time. */
27624 if (type
&& type
!= error_mark_node
27625 && (complain
& tf_error
))
27626 /* If type is error_mark_node a diagnostic must have been
27627 emitted by now. Also, having a mention to '<type error>'
27628 in the diagnostic is not really useful to the user. */
27631 && FNDECL_USED_AUTO (current_function_decl
)
27633 == DECL_SAVED_AUTO_RETURN_TYPE (current_function_decl
))
27634 && LAMBDA_FUNCTION_P (current_function_decl
))
27635 error ("unable to deduce lambda return type from %qE", init
);
27637 error ("unable to deduce %qT from %qE", type
, init
);
27638 type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
27640 NULL
, /*explain_p=*/true);
27642 return error_mark_node
;
27646 /* Check any placeholder constraints against the deduced type. */
27647 if (flag_concepts
&& !processing_template_decl
)
27648 if (tree constr
= NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS (auto_node
)))
27650 /* Use the deduced type to check the associated constraints. If we
27651 have a partial-concept-id, rebuild the argument list so that
27652 we check using the extra arguments. */
27653 gcc_assert (TREE_CODE (constr
) == CHECK_CONSTR
);
27654 tree cargs
= CHECK_CONSTR_ARGS (constr
);
27655 if (TREE_VEC_LENGTH (cargs
) > 1)
27657 cargs
= copy_node (cargs
);
27658 TREE_VEC_ELT (cargs
, 0) = TREE_VEC_ELT (targs
, 0);
27662 if (!constraints_satisfied_p (constr
, cargs
))
27664 if (complain
& tf_warning_or_error
)
27666 auto_diagnostic_group d
;
27669 case adc_unspecified
:
27671 error("placeholder constraints not satisfied");
27673 case adc_variable_type
:
27674 case adc_decomp_type
:
27675 error ("deduced initializer does not satisfy "
27676 "placeholder constraints");
27678 case adc_return_type
:
27679 error ("deduced return type does not satisfy "
27680 "placeholder constraints");
27682 case adc_requirement
:
27683 error ("deduced expression type does not satisfy "
27684 "placeholder constraints");
27687 diagnose_constraints (input_location
, constr
, targs
);
27689 return error_mark_node
;
27693 if (processing_template_decl
&& context
!= adc_unify
)
27694 outer_targs
= current_template_args ();
27695 targs
= add_to_template_args (outer_targs
, targs
);
27696 return tsubst (type
, targs
, complain
, NULL_TREE
);
27699 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
27703 splice_late_return_type (tree type
, tree late_return_type
)
27705 if (is_auto (type
))
27707 if (late_return_type
)
27708 return late_return_type
;
27710 tree idx
= get_template_parm_index (type
);
27711 if (TEMPLATE_PARM_LEVEL (idx
) <= processing_template_decl
)
27712 /* In an abbreviated function template we didn't know we were dealing
27713 with a function template when we saw the auto return type, so update
27714 it to have the correct level. */
27715 return make_auto_1 (TYPE_IDENTIFIER (type
), true);
27720 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
27721 'decltype(auto)' or a deduced class template. */
27724 is_auto (const_tree type
)
27726 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
27727 && (TYPE_IDENTIFIER (type
) == auto_identifier
27728 || TYPE_IDENTIFIER (type
) == decltype_auto_identifier
))
27734 /* for_each_template_parm callback for type_uses_auto. */
27737 is_auto_r (tree tp
, void */
*data*/
)
27739 return is_auto (tp
);
27742 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
27743 a use of `auto'. Returns NULL_TREE otherwise. */
27746 type_uses_auto (tree type
)
27748 if (type
== NULL_TREE
)
27750 else if (flag_concepts
)
27752 /* The Concepts TS allows multiple autos in one type-specifier; just
27753 return the first one we find, do_auto_deduction will collect all of
27755 if (uses_template_parms (type
))
27756 return for_each_template_parm (type
, is_auto_r
, /*data*/NULL
,
27757 /*visited*/NULL
, /*nondeduced*/false);
27762 return find_type_usage (type
, is_auto
);
27765 /* Report ill-formed occurrences of auto types in ARGUMENTS. If
27766 concepts are enabled, auto is acceptable in template arguments, but
27767 only when TEMPL identifies a template class. Return TRUE if any
27768 such errors were reported. */
27771 check_auto_in_tmpl_args (tree tmpl
, tree args
)
27773 /* If there were previous errors, nevermind. */
27774 if (!args
|| TREE_CODE (args
) != TREE_VEC
)
27777 /* If TMPL is an identifier, we're parsing and we can't tell yet
27778 whether TMPL is supposed to be a type, a function or a variable.
27779 We'll only be able to tell during template substitution, so we
27780 expect to be called again then. If concepts are enabled and we
27781 know we have a type, we're ok. */
27783 && (identifier_p (tmpl
)
27785 && (DECL_TYPE_TEMPLATE_P (tmpl
)
27786 || DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)))))
27789 /* Quickly search for any occurrences of auto; usually there won't
27790 be any, and then we'll avoid allocating the vector. */
27791 if (!type_uses_auto (args
))
27794 bool errors
= false;
27796 tree vec
= extract_autos (args
);
27797 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); i
++)
27799 tree xauto
= TREE_VALUE (TREE_VEC_ELT (vec
, i
));
27800 error_at (DECL_SOURCE_LOCATION (xauto
),
27801 "invalid use of %qT in template argument", xauto
);
27808 /* For a given template T, return the vector of typedefs referenced
27809 in T for which access check is needed at T instantiation time.
27810 T is either a FUNCTION_DECL or a RECORD_TYPE.
27811 Those typedefs were added to T by the function
27812 append_type_to_template_for_access_check. */
27814 vec
<qualified_typedef_usage_t
, va_gc
> *
27815 get_types_needing_access_check (tree t
)
27818 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
27820 if (!t
|| t
== error_mark_node
)
27823 if (!(ti
= get_template_info (t
)))
27826 if (CLASS_TYPE_P (t
)
27827 || TREE_CODE (t
) == FUNCTION_DECL
)
27829 if (!TI_TEMPLATE (ti
))
27832 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
27838 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
27839 tied to T. That list of typedefs will be access checked at
27840 T instantiation time.
27841 T is either a FUNCTION_DECL or a RECORD_TYPE.
27842 TYPE_DECL is a TYPE_DECL node representing a typedef.
27843 SCOPE is the scope through which TYPE_DECL is accessed.
27844 LOCATION is the location of the usage point of TYPE_DECL.
27846 This function is a subroutine of
27847 append_type_to_template_for_access_check. */
27850 append_type_to_template_for_access_check_1 (tree t
,
27853 location_t location
)
27855 qualified_typedef_usage_t typedef_usage
;
27858 if (!t
|| t
== error_mark_node
)
27861 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
27862 || CLASS_TYPE_P (t
))
27864 && TREE_CODE (type_decl
) == TYPE_DECL
27867 if (!(ti
= get_template_info (t
)))
27870 gcc_assert (TI_TEMPLATE (ti
));
27872 typedef_usage
.typedef_decl
= type_decl
;
27873 typedef_usage
.context
= scope
;
27874 typedef_usage
.locus
= location
;
27876 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
27879 /* Append TYPE_DECL to the template TEMPL.
27880 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
27881 At TEMPL instanciation time, TYPE_DECL will be checked to see
27882 if it can be accessed through SCOPE.
27883 LOCATION is the location of the usage point of TYPE_DECL.
27885 e.g. consider the following code snippet:
27892 template<class U> struct S
27894 C::myint mi; // <-- usage point of the typedef C::myint
27899 At S<char> instantiation time, we need to check the access of C::myint
27900 In other words, we need to check the access of the myint typedef through
27901 the C scope. For that purpose, this function will add the myint typedef
27902 and the scope C through which its being accessed to a list of typedefs
27903 tied to the template S. That list will be walked at template instantiation
27904 time and access check performed on each typedefs it contains.
27905 Note that this particular code snippet should yield an error because
27906 myint is private to C. */
27909 append_type_to_template_for_access_check (tree templ
,
27912 location_t location
)
27914 qualified_typedef_usage_t
*iter
;
27917 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
27919 /* Make sure we don't append the type to the template twice. */
27920 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
27921 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
27924 append_type_to_template_for_access_check_1 (templ
, type_decl
,
27928 /* Convert the generic type parameters in PARM that match the types given in the
27929 range [START_IDX, END_IDX) from the current_template_parms into generic type
27933 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
27935 tree current
= current_template_parms
;
27936 int depth
= TMPL_PARMS_DEPTH (current
);
27937 current
= INNERMOST_TEMPLATE_PARMS (current
);
27938 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
27940 for (int i
= 0; i
< start_idx
; ++i
)
27941 TREE_VEC_ELT (replacement
, i
)
27942 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
27944 for (int i
= start_idx
; i
< end_idx
; ++i
)
27946 /* Create a distinct parameter pack type from the current parm and add it
27947 to the replacement args to tsubst below into the generic function
27950 tree o
= TREE_TYPE (TREE_VALUE
27951 (TREE_VEC_ELT (current
, i
)));
27952 tree t
= copy_type (o
);
27953 TEMPLATE_TYPE_PARM_INDEX (t
)
27954 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
27956 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
27957 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
27958 TYPE_MAIN_VARIANT (t
) = t
;
27959 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
27960 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
27961 TREE_VEC_ELT (replacement
, i
) = t
;
27962 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
27965 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
27966 TREE_VEC_ELT (replacement
, i
)
27967 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
27969 /* If there are more levels then build up the replacement with the outer
27972 replacement
= add_to_template_args (template_parms_to_args
27973 (TREE_CHAIN (current_template_parms
)),
27976 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
27979 /* Entries in the decl_constraint hash table. */
27980 struct GTY((for_user
)) constr_entry
27986 /* Hashing function and equality for constraint entries. */
27987 struct constr_hasher
: ggc_ptr_hash
<constr_entry
>
27989 static hashval_t
hash (constr_entry
*e
)
27991 return (hashval_t
)DECL_UID (e
->decl
);
27994 static bool equal (constr_entry
*e1
, constr_entry
*e2
)
27996 return e1
->decl
== e2
->decl
;
28000 /* A mapping from declarations to constraint information. Note that
28001 both templates and their underlying declarations are mapped to the
28002 same constraint information.
28004 FIXME: This is defined in pt.c because garbage collection
28005 code is not being generated for constraint.cc. */
28007 static GTY (()) hash_table
<constr_hasher
> *decl_constraints
;
28009 /* Returns the template constraints of declaration T. If T is not
28010 constrained, return NULL_TREE. Note that T must be non-null. */
28013 get_constraints (tree t
)
28015 if (!flag_concepts
)
28018 gcc_assert (DECL_P (t
));
28019 if (TREE_CODE (t
) == TEMPLATE_DECL
)
28020 t
= DECL_TEMPLATE_RESULT (t
);
28021 constr_entry elt
= { t
, NULL_TREE
};
28022 constr_entry
* found
= decl_constraints
->find (&elt
);
28029 /* Associate the given constraint information CI with the declaration
28030 T. If T is a template, then the constraints are associated with
28031 its underlying declaration. Don't build associations if CI is
28035 set_constraints (tree t
, tree ci
)
28039 gcc_assert (t
&& flag_concepts
);
28040 if (TREE_CODE (t
) == TEMPLATE_DECL
)
28041 t
= DECL_TEMPLATE_RESULT (t
);
28042 gcc_assert (!get_constraints (t
));
28043 constr_entry elt
= {t
, ci
};
28044 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, INSERT
);
28045 constr_entry
* entry
= ggc_alloc
<constr_entry
> ();
28050 /* Remove the associated constraints of the declaration T. */
28053 remove_constraints (tree t
)
28055 gcc_assert (DECL_P (t
));
28056 if (TREE_CODE (t
) == TEMPLATE_DECL
)
28057 t
= DECL_TEMPLATE_RESULT (t
);
28059 constr_entry elt
= {t
, NULL_TREE
};
28060 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, NO_INSERT
);
28062 decl_constraints
->clear_slot (slot
);
28065 /* Memoized satisfaction results for declarations. This
28066 maps the pair (constraint_info, arguments) to the result computed
28067 by constraints_satisfied_p. */
28069 struct GTY((for_user
)) constraint_sat_entry
28076 /* Hashing function and equality for constraint entries. */
28078 struct constraint_sat_hasher
: ggc_ptr_hash
<constraint_sat_entry
>
28080 static hashval_t
hash (constraint_sat_entry
*e
)
28082 hashval_t val
= iterative_hash_object(e
->ci
, 0);
28083 return iterative_hash_template_arg (e
->args
, val
);
28086 static bool equal (constraint_sat_entry
*e1
, constraint_sat_entry
*e2
)
28088 return e1
->ci
== e2
->ci
&& comp_template_args (e1
->args
, e2
->args
);
28092 /* Memoized satisfaction results for concept checks. */
28094 struct GTY((for_user
)) concept_spec_entry
28101 /* Hashing function and equality for constraint entries. */
28103 struct concept_spec_hasher
: ggc_ptr_hash
<concept_spec_entry
>
28105 static hashval_t
hash (concept_spec_entry
*e
)
28107 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
28110 static bool equal (concept_spec_entry
*e1
, concept_spec_entry
*e2
)
28112 ++comparing_specializations
;
28113 bool eq
= e1
->tmpl
== e2
->tmpl
&& comp_template_args (e1
->args
, e2
->args
);
28114 --comparing_specializations
;
28119 static GTY (()) hash_table
<constraint_sat_hasher
> *constraint_memos
;
28120 static GTY (()) hash_table
<concept_spec_hasher
> *concept_memos
;
28122 /* Search for a memoized satisfaction result. Returns one of the
28123 truth value nodes if previously memoized, or NULL_TREE otherwise. */
28126 lookup_constraint_satisfaction (tree ci
, tree args
)
28128 constraint_sat_entry elt
= { ci
, args
, NULL_TREE
};
28129 constraint_sat_entry
* found
= constraint_memos
->find (&elt
);
28131 return found
->result
;
28136 /* Memoize the result of a satisfication test. Returns the saved result. */
28139 memoize_constraint_satisfaction (tree ci
, tree args
, tree result
)
28141 constraint_sat_entry elt
= {ci
, args
, result
};
28142 constraint_sat_entry
** slot
= constraint_memos
->find_slot (&elt
, INSERT
);
28143 constraint_sat_entry
* entry
= ggc_alloc
<constraint_sat_entry
> ();
28149 /* Search for a memoized satisfaction result for a concept. */
28152 lookup_concept_satisfaction (tree tmpl
, tree args
)
28154 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
28155 concept_spec_entry
* found
= concept_memos
->find (&elt
);
28157 return found
->result
;
28162 /* Memoize the result of a concept check. Returns the saved result. */
28165 memoize_concept_satisfaction (tree tmpl
, tree args
, tree result
)
28167 concept_spec_entry elt
= {tmpl
, args
, result
};
28168 concept_spec_entry
** slot
= concept_memos
->find_slot (&elt
, INSERT
);
28169 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
28175 static GTY (()) hash_table
<concept_spec_hasher
> *concept_expansions
;
28177 /* Returns a prior concept specialization. This returns the substituted
28178 and normalized constraints defined by the concept. */
28181 get_concept_expansion (tree tmpl
, tree args
)
28183 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
28184 concept_spec_entry
* found
= concept_expansions
->find (&elt
);
28186 return found
->result
;
28191 /* Save a concept expansion for later. */
28194 save_concept_expansion (tree tmpl
, tree args
, tree def
)
28196 concept_spec_entry elt
= {tmpl
, args
, def
};
28197 concept_spec_entry
** slot
= concept_expansions
->find_slot (&elt
, INSERT
);
28198 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
28205 hash_subsumption_args (tree t1
, tree t2
)
28207 gcc_assert (TREE_CODE (t1
) == CHECK_CONSTR
);
28208 gcc_assert (TREE_CODE (t2
) == CHECK_CONSTR
);
28210 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t1
), val
);
28211 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t1
), val
);
28212 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t2
), val
);
28213 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t2
), val
);
28217 /* Compare the constraints of two subsumption entries. The LEFT1 and
28218 LEFT2 arguments comprise the first subsumption pair and the RIGHT1
28219 and RIGHT2 arguments comprise the second. These are all CHECK_CONSTRs. */
28222 comp_subsumption_args (tree left1
, tree left2
, tree right1
, tree right2
)
28224 if (CHECK_CONSTR_CONCEPT (left1
) == CHECK_CONSTR_CONCEPT (right1
))
28225 if (CHECK_CONSTR_CONCEPT (left2
) == CHECK_CONSTR_CONCEPT (right2
))
28226 if (comp_template_args (CHECK_CONSTR_ARGS (left1
),
28227 CHECK_CONSTR_ARGS (right1
)))
28228 return comp_template_args (CHECK_CONSTR_ARGS (left2
),
28229 CHECK_CONSTR_ARGS (right2
));
28233 /* Key/value pair for learning and memoizing subsumption results. This
28234 associates a pair of check constraints (including arguments) with
28235 a boolean value indicating the result. */
28237 struct GTY((for_user
)) subsumption_entry
28244 /* Hashing function and equality for constraint entries. */
28246 struct subsumption_hasher
: ggc_ptr_hash
<subsumption_entry
>
28248 static hashval_t
hash (subsumption_entry
*e
)
28250 return hash_subsumption_args (e
->t1
, e
->t2
);
28253 static bool equal (subsumption_entry
*e1
, subsumption_entry
*e2
)
28255 ++comparing_specializations
;
28256 bool eq
= comp_subsumption_args(e1
->t1
, e1
->t2
, e2
->t1
, e2
->t2
);
28257 --comparing_specializations
;
28262 static GTY (()) hash_table
<subsumption_hasher
> *subsumption_table
;
28264 /* Search for a previously cached subsumption result. */
28267 lookup_subsumption_result (tree t1
, tree t2
)
28269 subsumption_entry elt
= { t1
, t2
, false };
28270 subsumption_entry
* found
= subsumption_table
->find (&elt
);
28272 return &found
->result
;
28277 /* Save a subsumption result. */
28280 save_subsumption_result (tree t1
, tree t2
, bool result
)
28282 subsumption_entry elt
= {t1
, t2
, result
};
28283 subsumption_entry
** slot
= subsumption_table
->find_slot (&elt
, INSERT
);
28284 subsumption_entry
* entry
= ggc_alloc
<subsumption_entry
> ();
28290 /* Set up the hash table for constraint association. */
28293 init_constraint_processing (void)
28295 if (!flag_concepts
)
28298 decl_constraints
= hash_table
<constr_hasher
>::create_ggc(37);
28299 constraint_memos
= hash_table
<constraint_sat_hasher
>::create_ggc(37);
28300 concept_memos
= hash_table
<concept_spec_hasher
>::create_ggc(37);
28301 concept_expansions
= hash_table
<concept_spec_hasher
>::create_ggc(37);
28302 subsumption_table
= hash_table
<subsumption_hasher
>::create_ggc(37);
28305 /* __integer_pack(N) in a pack expansion expands to a sequence of numbers from
28309 declare_integer_pack (void)
28311 tree ipfn
= push_library_fn (get_identifier ("__integer_pack"),
28312 build_function_type_list (integer_type_node
,
28315 NULL_TREE
, ECF_CONST
);
28316 DECL_DECLARED_CONSTEXPR_P (ipfn
) = true;
28317 DECL_BUILT_IN_CLASS (ipfn
) = BUILT_IN_FRONTEND
;
28318 DECL_FUNCTION_CODE (ipfn
)
28319 = (enum built_in_function
) (int) CP_BUILT_IN_INTEGER_PACK
;
28322 /* Set up the hash tables for template instantiations. */
28325 init_template_processing (void)
28327 /* FIXME: enable sanitization (PR87847) */
28328 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37, false);
28329 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37, false);
28331 if (cxx_dialect
>= cxx11
)
28332 declare_integer_pack ();
28335 /* Print stats about the template hash tables for -fstats. */
28338 print_template_statistics (void)
28340 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
28341 "%f collisions\n", (long) decl_specializations
->size (),
28342 (long) decl_specializations
->elements (),
28343 decl_specializations
->collisions ());
28344 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
28345 "%f collisions\n", (long) type_specializations
->size (),
28346 (long) type_specializations
->elements (),
28347 type_specializations
->collisions ());
28352 namespace selftest
{
28354 /* Verify that build_non_dependent_expr () works, for various expressions,
28355 and that location wrappers don't affect the results. */
28358 test_build_non_dependent_expr ()
28360 location_t loc
= BUILTINS_LOCATION
;
28362 /* Verify constants, without and with location wrappers. */
28363 tree int_cst
= build_int_cst (integer_type_node
, 42);
28364 ASSERT_EQ (int_cst
, build_non_dependent_expr (int_cst
));
28366 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
28367 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
28368 ASSERT_EQ (wrapped_int_cst
, build_non_dependent_expr (wrapped_int_cst
));
28370 tree string_lit
= build_string (4, "foo");
28371 TREE_TYPE (string_lit
) = char_array_type_node
;
28372 string_lit
= fix_string_type (string_lit
);
28373 ASSERT_EQ (string_lit
, build_non_dependent_expr (string_lit
));
28375 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
28376 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
28377 ASSERT_EQ (wrapped_string_lit
,
28378 build_non_dependent_expr (wrapped_string_lit
));
28381 /* Verify that type_dependent_expression_p () works correctly, even
28382 in the presence of location wrapper nodes. */
28385 test_type_dependent_expression_p ()
28387 location_t loc
= BUILTINS_LOCATION
;
28389 tree name
= get_identifier ("foo");
28391 /* If no templates are involved, nothing is type-dependent. */
28392 gcc_assert (!processing_template_decl
);
28393 ASSERT_FALSE (type_dependent_expression_p (name
));
28395 ++processing_template_decl
;
28397 /* Within a template, an unresolved name is always type-dependent. */
28398 ASSERT_TRUE (type_dependent_expression_p (name
));
28400 /* Ensure it copes with NULL_TREE and errors. */
28401 ASSERT_FALSE (type_dependent_expression_p (NULL_TREE
));
28402 ASSERT_FALSE (type_dependent_expression_p (error_mark_node
));
28404 /* A USING_DECL in a template should be type-dependent, even if wrapped
28405 with a location wrapper (PR c++/83799). */
28406 tree using_decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
28407 TREE_TYPE (using_decl
) = integer_type_node
;
28408 ASSERT_TRUE (type_dependent_expression_p (using_decl
));
28409 tree wrapped_using_decl
= maybe_wrap_with_location (using_decl
, loc
);
28410 ASSERT_TRUE (location_wrapper_p (wrapped_using_decl
));
28411 ASSERT_TRUE (type_dependent_expression_p (wrapped_using_decl
));
28413 --processing_template_decl
;
28416 /* Run all of the selftests within this file. */
28421 test_build_non_dependent_expr ();
28422 test_type_dependent_expression_p ();
28425 } // namespace selftest
28427 #endif /* #if CHECKING_P */
28429 #include "gt-cp-pt.h"