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"
47 /* The type of functions taking a tree, and some additional data, and
49 typedef int (*tree_fn_t
) (tree
, void*);
51 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
52 instantiations have been deferred, either because their definitions
53 were not yet available, or because we were putting off doing the work. */
54 struct GTY ((chain_next ("%h.next"))) pending_template
56 struct pending_template
*next
;
57 struct tinst_level
*tinst
;
60 static GTY(()) struct pending_template
*pending_templates
;
61 static GTY(()) struct pending_template
*last_pending_template
;
63 int processing_template_parmlist
;
64 static int template_header_count
;
66 static GTY(()) tree saved_trees
;
67 static vec
<int> inline_parm_levels
;
69 static GTY(()) struct tinst_level
*current_tinst_level
;
71 static GTY(()) vec
<tree
, va_gc
> *saved_access_scope
;
73 /* Live only within one (recursive) call to tsubst_expr. We use
74 this to pass the statement expression node from the STMT_EXPR
75 to the EXPR_STMT that is its result. */
76 static tree cur_stmt_expr
;
78 // -------------------------------------------------------------------------- //
79 // Local Specialization Stack
81 // Implementation of the RAII helper for creating new local
83 local_specialization_stack::local_specialization_stack (lss_policy policy
)
84 : saved (local_specializations
)
86 if (policy
== lss_blank
|| !saved
)
87 local_specializations
= new hash_map
<tree
, tree
>;
89 local_specializations
= new hash_map
<tree
, tree
>(*saved
);
92 local_specialization_stack::~local_specialization_stack ()
94 delete local_specializations
;
95 local_specializations
= saved
;
98 /* True if we've recursed into fn_type_unification too many times. */
99 static bool excessive_deduction_depth
;
101 struct GTY((for_user
)) spec_entry
108 struct spec_hasher
: ggc_ptr_hash
<spec_entry
>
110 static hashval_t
hash (spec_entry
*);
111 static bool equal (spec_entry
*, spec_entry
*);
114 static GTY (()) hash_table
<spec_hasher
> *decl_specializations
;
116 static GTY (()) hash_table
<spec_hasher
> *type_specializations
;
118 /* Contains canonical template parameter types. The vector is indexed by
119 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
120 TREE_LIST, whose TREE_VALUEs contain the canonical template
121 parameters of various types and levels. */
122 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
124 #define UNIFY_ALLOW_NONE 0
125 #define UNIFY_ALLOW_MORE_CV_QUAL 1
126 #define UNIFY_ALLOW_LESS_CV_QUAL 2
127 #define UNIFY_ALLOW_DERIVED 4
128 #define UNIFY_ALLOW_INTEGER 8
129 #define UNIFY_ALLOW_OUTER_LEVEL 16
130 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
131 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
133 enum template_base_result
{
135 tbr_ambiguous_baseclass
,
139 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
140 unification_kind_t
, int,
142 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
143 unification_kind_t
, int, bool, bool);
144 static int unify (tree
, tree
, tree
, tree
, int, bool);
145 static void add_pending_template (tree
);
146 static tree
reopen_tinst_level (struct tinst_level
*);
147 static tree
tsubst_initializer_list (tree
, tree
);
148 static tree
get_partial_spec_bindings (tree
, tree
, tree
);
149 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
151 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
153 static void tsubst_enum (tree
, tree
, tree
);
154 static tree
add_to_template_args (tree
, tree
);
155 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
156 static int check_non_deducible_conversion (tree
, tree
, int, int,
157 struct conversion
**, bool);
158 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
160 static int type_unification_real (tree
, tree
, tree
, const tree
*,
161 unsigned int, int, unification_kind_t
,
162 vec
<deferred_access_check
, va_gc
> **,
164 static void note_template_header (int);
165 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
166 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
167 static tree
convert_template_argument (tree
, tree
, tree
,
168 tsubst_flags_t
, int, tree
);
169 static tree
for_each_template_parm (tree
, tree_fn_t
, void*,
170 hash_set
<tree
> *, bool, tree_fn_t
= NULL
);
171 static tree
expand_template_argument_pack (tree
);
172 static tree
build_template_parm_index (int, int, int, tree
, tree
);
173 static bool inline_needs_template_parms (tree
, bool);
174 static void push_inline_template_parms_recursive (tree
, int);
175 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
176 static int mark_template_parm (tree
, void *);
177 static int template_parm_this_level_p (tree
, void *);
178 static tree
tsubst_friend_function (tree
, tree
);
179 static tree
tsubst_friend_class (tree
, tree
);
180 static int can_complete_type_without_circularity (tree
);
181 static tree
get_bindings (tree
, tree
, tree
, bool);
182 static int template_decl_level (tree
);
183 static int check_cv_quals_for_unify (int, tree
, tree
);
184 static int unify_pack_expansion (tree
, tree
, tree
,
185 tree
, unification_kind_t
, bool, bool);
186 static tree
copy_template_args (tree
);
187 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
188 static tree
most_specialized_partial_spec (tree
, tsubst_flags_t
);
189 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
190 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
191 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
192 static bool check_specialization_scope (void);
193 static tree
process_partial_specialization (tree
);
194 static void set_current_access_from_decl (tree
);
195 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
197 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
198 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
200 static bool template_template_parm_bindings_ok_p (tree
, tree
);
201 static void tsubst_default_arguments (tree
, tsubst_flags_t
);
202 static tree
for_each_template_parm_r (tree
*, int *, void *);
203 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
204 static void copy_default_args_to_explicit_spec (tree
);
205 static bool invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
206 static bool dependent_template_arg_p (tree
);
207 static bool any_template_arguments_need_structural_equality_p (tree
);
208 static bool dependent_type_p_r (tree
);
209 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
210 static tree
tsubst_decl (tree
, tree
, tsubst_flags_t
);
211 static void perform_typedefs_access_check (tree tmpl
, tree targs
);
212 static void append_type_to_template_for_access_check_1 (tree
, tree
, tree
,
214 static tree
listify (tree
);
215 static tree
listify_autos (tree
, tree
);
216 static tree
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
217 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
218 static bool complex_alias_template_p (const_tree tmpl
);
219 static tree
get_underlying_template (tree
);
220 static tree
tsubst_attributes (tree
, tree
, tsubst_flags_t
, tree
);
221 static tree
canonicalize_expr_argument (tree
, tsubst_flags_t
);
222 static tree
make_argument_pack (tree
);
223 static void register_parameter_specializations (tree
, tree
);
224 static tree
enclosing_instantiation_of (tree tctx
);
226 /* Make the current scope suitable for access checking when we are
227 processing T. T can be FUNCTION_DECL for instantiated function
228 template, VAR_DECL for static member variable, or TYPE_DECL for
229 alias template (needed by instantiate_decl). */
232 push_access_scope (tree t
)
234 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
235 || TREE_CODE (t
) == TYPE_DECL
);
237 if (DECL_FRIEND_CONTEXT (t
))
238 push_nested_class (DECL_FRIEND_CONTEXT (t
));
239 else if (DECL_CLASS_SCOPE_P (t
))
240 push_nested_class (DECL_CONTEXT (t
));
242 push_to_top_level ();
244 if (TREE_CODE (t
) == FUNCTION_DECL
)
246 vec_safe_push (saved_access_scope
, current_function_decl
);
247 current_function_decl
= t
;
251 /* Restore the scope set up by push_access_scope. T is the node we
255 pop_access_scope (tree t
)
257 if (TREE_CODE (t
) == FUNCTION_DECL
)
258 current_function_decl
= saved_access_scope
->pop();
260 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
263 pop_from_top_level ();
266 /* Do any processing required when DECL (a member template
267 declaration) is finished. Returns the TEMPLATE_DECL corresponding
268 to DECL, unless it is a specialization, in which case the DECL
269 itself is returned. */
272 finish_member_template_decl (tree decl
)
274 if (decl
== error_mark_node
)
275 return error_mark_node
;
277 gcc_assert (DECL_P (decl
));
279 if (TREE_CODE (decl
) == TYPE_DECL
)
283 type
= TREE_TYPE (decl
);
284 if (type
== error_mark_node
)
285 return error_mark_node
;
286 if (MAYBE_CLASS_TYPE_P (type
)
287 && CLASSTYPE_TEMPLATE_INFO (type
)
288 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
290 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
291 check_member_template (tmpl
);
296 else if (TREE_CODE (decl
) == FIELD_DECL
)
297 error_at (DECL_SOURCE_LOCATION (decl
),
298 "data member %qD cannot be a member template", decl
);
299 else if (DECL_TEMPLATE_INFO (decl
))
301 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
303 check_member_template (DECL_TI_TEMPLATE (decl
));
304 return DECL_TI_TEMPLATE (decl
);
310 error_at (DECL_SOURCE_LOCATION (decl
),
311 "invalid member template declaration %qD", decl
);
313 return error_mark_node
;
316 /* Create a template info node. */
319 build_template_info (tree template_decl
, tree template_args
)
321 tree result
= make_node (TEMPLATE_INFO
);
322 TI_TEMPLATE (result
) = template_decl
;
323 TI_ARGS (result
) = template_args
;
327 /* Return the template info node corresponding to T, whatever T is. */
330 get_template_info (const_tree t
)
332 tree tinfo
= NULL_TREE
;
334 if (!t
|| t
== error_mark_node
)
337 if (TREE_CODE (t
) == NAMESPACE_DECL
338 || TREE_CODE (t
) == PARM_DECL
)
341 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
342 tinfo
= DECL_TEMPLATE_INFO (t
);
344 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
347 if (OVERLOAD_TYPE_P (t
))
348 tinfo
= TYPE_TEMPLATE_INFO (t
);
349 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
350 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
355 /* Returns the template nesting level of the indicated class TYPE.
365 A<T>::B<U> has depth two, while A<T> has depth one.
366 Both A<T>::B<int> and A<int>::B<U> have depth one, if
367 they are instantiations, not specializations.
369 This function is guaranteed to return 0 if passed NULL_TREE so
370 that, for example, `template_class_depth (current_class_type)' is
374 template_class_depth (tree type
)
378 for (depth
= 0; type
&& TREE_CODE (type
) != NAMESPACE_DECL
; )
380 tree tinfo
= get_template_info (type
);
382 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
383 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
387 type
= CP_DECL_CONTEXT (type
);
388 else if (LAMBDA_TYPE_P (type
) && LAMBDA_TYPE_EXTRA_SCOPE (type
))
389 type
= LAMBDA_TYPE_EXTRA_SCOPE (type
);
391 type
= CP_TYPE_CONTEXT (type
);
397 /* Return TRUE if NODE instantiates a template that has arguments of
398 its own, be it directly a primary template or indirectly through a
399 partial specializations. */
401 instantiates_primary_template_p (tree node
)
403 tree tinfo
= get_template_info (node
);
407 tree tmpl
= TI_TEMPLATE (tinfo
);
408 if (PRIMARY_TEMPLATE_P (tmpl
))
411 if (!DECL_TEMPLATE_SPECIALIZATION (tmpl
))
414 /* So now we know we have a specialization, but it could be a full
415 or a partial specialization. To tell which, compare the depth of
416 its template arguments with those of its context. */
418 tree ctxt
= DECL_CONTEXT (tmpl
);
419 tree ctinfo
= get_template_info (ctxt
);
423 return (TMPL_ARGS_DEPTH (TI_ARGS (tinfo
))
424 > TMPL_ARGS_DEPTH (TI_ARGS (ctinfo
)));
427 /* Subroutine of maybe_begin_member_template_processing.
428 Returns true if processing DECL needs us to push template parms. */
431 inline_needs_template_parms (tree decl
, bool nsdmi
)
433 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
436 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
437 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
440 /* Subroutine of maybe_begin_member_template_processing.
441 Push the template parms in PARMS, starting from LEVELS steps into the
442 chain, and ending at the beginning, since template parms are listed
446 push_inline_template_parms_recursive (tree parmlist
, int levels
)
448 tree parms
= TREE_VALUE (parmlist
);
452 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
454 ++processing_template_decl
;
455 current_template_parms
456 = tree_cons (size_int (processing_template_decl
),
457 parms
, current_template_parms
);
458 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
460 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
462 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
464 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
466 if (error_operand_p (parm
))
469 gcc_assert (DECL_P (parm
));
471 switch (TREE_CODE (parm
))
479 /* Push the CONST_DECL. */
480 pushdecl (TEMPLATE_PARM_DECL (DECL_INITIAL (parm
)));
489 /* Restore the template parameter context for a member template, a
490 friend template defined in a class definition, or a non-template
491 member of template class. */
494 maybe_begin_member_template_processing (tree decl
)
498 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
502 tree ctx
= DECL_CONTEXT (decl
);
503 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
504 /* Disregard full specializations (c++/60999). */
505 && uses_template_parms (ctx
)
506 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
509 if (inline_needs_template_parms (decl
, nsdmi
))
511 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
512 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
514 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
517 parms
= TREE_CHAIN (parms
);
520 push_inline_template_parms_recursive (parms
, levels
);
523 /* Remember how many levels of template parameters we pushed so that
524 we can pop them later. */
525 inline_parm_levels
.safe_push (levels
);
528 /* Undo the effects of maybe_begin_member_template_processing. */
531 maybe_end_member_template_processing (void)
536 if (inline_parm_levels
.length () == 0)
539 last
= inline_parm_levels
.pop ();
540 for (i
= 0; i
< last
; ++i
)
542 --processing_template_decl
;
543 current_template_parms
= TREE_CHAIN (current_template_parms
);
548 /* Return a new template argument vector which contains all of ARGS,
549 but has as its innermost set of arguments the EXTRA_ARGS. */
552 add_to_template_args (tree args
, tree extra_args
)
559 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
562 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
563 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
565 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
566 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
568 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
569 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
574 /* Like add_to_template_args, but only the outermost ARGS are added to
575 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
576 (EXTRA_ARGS) levels are added. This function is used to combine
577 the template arguments from a partial instantiation with the
578 template arguments used to attain the full instantiation from the
579 partial instantiation. */
582 add_outermost_template_args (tree args
, tree extra_args
)
586 /* If there are more levels of EXTRA_ARGS than there are ARGS,
587 something very fishy is going on. */
588 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
590 /* If *all* the new arguments will be the EXTRA_ARGS, just return
592 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
595 /* For the moment, we make ARGS look like it contains fewer levels. */
596 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
598 new_args
= add_to_template_args (args
, extra_args
);
600 /* Now, we restore ARGS to its full dimensions. */
601 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
606 /* Return the N levels of innermost template arguments from the ARGS. */
609 get_innermost_template_args (tree args
, int n
)
617 /* If N is 1, just return the innermost set of template arguments. */
619 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
621 /* If we're not removing anything, just return the arguments we were
623 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
624 gcc_assert (extra_levels
>= 0);
625 if (extra_levels
== 0)
628 /* Make a new set of arguments, not containing the outer arguments. */
629 new_args
= make_tree_vec (n
);
630 for (i
= 1; i
<= n
; ++i
)
631 SET_TMPL_ARGS_LEVEL (new_args
, i
,
632 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
637 /* The inverse of get_innermost_template_args: Return all but the innermost
638 EXTRA_LEVELS levels of template arguments from the ARGS. */
641 strip_innermost_template_args (tree args
, int extra_levels
)
644 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
649 /* If N is 1, just return the outermost set of template arguments. */
651 return TMPL_ARGS_LEVEL (args
, 1);
653 /* If we're not removing anything, just return the arguments we were
655 gcc_assert (extra_levels
>= 0);
656 if (extra_levels
== 0)
659 /* Make a new set of arguments, not containing the inner arguments. */
660 new_args
= make_tree_vec (n
);
661 for (i
= 1; i
<= n
; ++i
)
662 SET_TMPL_ARGS_LEVEL (new_args
, i
,
663 TMPL_ARGS_LEVEL (args
, i
));
668 /* We've got a template header coming up; push to a new level for storing
672 begin_template_parm_list (void)
674 /* We use a non-tag-transparent scope here, which causes pushtag to
675 put tags in this scope, rather than in the enclosing class or
676 namespace scope. This is the right thing, since we want
677 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
678 global template class, push_template_decl handles putting the
679 TEMPLATE_DECL into top-level scope. For a nested template class,
682 template <class T> struct S1 {
683 template <class T> struct S2 {};
686 pushtag contains special code to insert the TEMPLATE_DECL for S2
687 at the right scope. */
688 begin_scope (sk_template_parms
, NULL
);
689 ++processing_template_decl
;
690 ++processing_template_parmlist
;
691 note_template_header (0);
693 /* Add a dummy parameter level while we process the parameter list. */
694 current_template_parms
695 = tree_cons (size_int (processing_template_decl
),
697 current_template_parms
);
700 /* This routine is called when a specialization is declared. If it is
701 invalid to declare a specialization here, an error is reported and
702 false is returned, otherwise this routine will return true. */
705 check_specialization_scope (void)
707 tree scope
= current_scope ();
711 An explicit specialization shall be declared in the namespace of
712 which the template is a member, or, for member templates, in the
713 namespace of which the enclosing class or enclosing class
714 template is a member. An explicit specialization of a member
715 function, member class or static data member of a class template
716 shall be declared in the namespace of which the class template
718 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
720 error ("explicit specialization in non-namespace scope %qD", scope
);
726 In an explicit specialization declaration for a member of a class
727 template or a member template that appears in namespace scope,
728 the member template and some of its enclosing class templates may
729 remain unspecialized, except that the declaration shall not
730 explicitly specialize a class member template if its enclosing
731 class templates are not explicitly specialized as well. */
732 if (current_template_parms
)
734 error ("enclosing class templates are not explicitly specialized");
741 /* We've just seen template <>. */
744 begin_specialization (void)
746 begin_scope (sk_template_spec
, NULL
);
747 note_template_header (1);
748 return check_specialization_scope ();
751 /* Called at then end of processing a declaration preceded by
755 end_specialization (void)
758 reset_specialization ();
761 /* Any template <>'s that we have seen thus far are not referring to a
762 function specialization. */
765 reset_specialization (void)
767 processing_specialization
= 0;
768 template_header_count
= 0;
771 /* We've just seen a template header. If SPECIALIZATION is nonzero,
772 it was of the form template <>. */
775 note_template_header (int specialization
)
777 processing_specialization
= specialization
;
778 template_header_count
++;
781 /* We're beginning an explicit instantiation. */
784 begin_explicit_instantiation (void)
786 gcc_assert (!processing_explicit_instantiation
);
787 processing_explicit_instantiation
= true;
792 end_explicit_instantiation (void)
794 gcc_assert (processing_explicit_instantiation
);
795 processing_explicit_instantiation
= false;
798 /* An explicit specialization or partial specialization of TMPL is being
799 declared. Check that the namespace in which the specialization is
800 occurring is permissible. Returns false iff it is invalid to
801 specialize TMPL in the current namespace. */
804 check_specialization_namespace (tree tmpl
)
806 tree tpl_ns
= decl_namespace_context (tmpl
);
810 An explicit specialization shall be declared in a namespace enclosing the
811 specialized template. An explicit specialization whose declarator-id is
812 not qualified shall be declared in the nearest enclosing namespace of the
813 template, or, if the namespace is inline (7.3.1), any namespace from its
814 enclosing namespace set. */
815 if (current_scope() != DECL_CONTEXT (tmpl
)
816 && !at_namespace_scope_p ())
818 error ("specialization of %qD must appear at namespace scope", tmpl
);
822 if (is_nested_namespace (current_namespace
, tpl_ns
, cxx_dialect
< cxx11
))
823 /* Same or enclosing namespace. */
827 auto_diagnostic_group d
;
828 if (permerror (input_location
,
829 "specialization of %qD in different namespace", tmpl
))
830 inform (DECL_SOURCE_LOCATION (tmpl
),
831 " from definition of %q#D", tmpl
);
836 /* SPEC is an explicit instantiation. Check that it is valid to
837 perform this explicit instantiation in the current namespace. */
840 check_explicit_instantiation_namespace (tree spec
)
844 /* DR 275: An explicit instantiation shall appear in an enclosing
845 namespace of its template. */
846 ns
= decl_namespace_context (spec
);
847 if (!is_nested_namespace (current_namespace
, ns
))
848 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
849 "(which does not enclose namespace %qD)",
850 spec
, current_namespace
, ns
);
853 /* Returns the type of a template specialization only if that
854 specialization needs to be defined. Otherwise (e.g., if the type has
855 already been defined), the function returns NULL_TREE. */
858 maybe_new_partial_specialization (tree type
)
860 /* An implicit instantiation of an incomplete type implies
861 the definition of a new class template.
869 Here, S<T*> is an implicit instantiation of S whose type
871 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
) && !COMPLETE_TYPE_P (type
))
874 /* It can also be the case that TYPE is a completed specialization.
875 Continuing the previous example, suppose we also declare:
881 Here, S<T*> refers to the specialization S<T*> defined
882 above. However, we need to differentiate definitions because
883 we intend to define a new partial specialization. In this case,
884 we rely on the fact that the constraints are different for
885 this declaration than that above.
887 Note that we also get here for injected class names and
888 late-parsed template definitions. We must ensure that we
889 do not create new type declarations for those cases. */
890 if (flag_concepts
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
892 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
893 tree args
= CLASSTYPE_TI_ARGS (type
);
895 /* If there are no template parameters, this cannot be a new
896 partial template specialization? */
897 if (!current_template_parms
)
900 /* The injected-class-name is not a new partial specialization. */
901 if (DECL_SELF_REFERENCE_P (TYPE_NAME (type
)))
904 /* If the constraints are not the same as those of the primary
905 then, we can probably create a new specialization. */
906 tree type_constr
= current_template_constraints ();
908 if (type
== TREE_TYPE (tmpl
))
910 tree main_constr
= get_constraints (tmpl
);
911 if (equivalent_constraints (type_constr
, main_constr
))
915 /* Also, if there's a pre-existing specialization with matching
916 constraints, then this also isn't new. */
917 tree specs
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
920 tree spec_tmpl
= TREE_VALUE (specs
);
921 tree spec_args
= TREE_PURPOSE (specs
);
922 tree spec_constr
= get_constraints (spec_tmpl
);
923 if (comp_template_args (args
, spec_args
)
924 && equivalent_constraints (type_constr
, spec_constr
))
926 specs
= TREE_CHAIN (specs
);
929 /* Create a new type node (and corresponding type decl)
930 for the newly declared specialization. */
931 tree t
= make_class_type (TREE_CODE (type
));
932 CLASSTYPE_DECLARED_CLASS (t
) = CLASSTYPE_DECLARED_CLASS (type
);
933 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (tmpl
, args
));
935 /* We only need a separate type node for storing the definition of this
936 partial specialization; uses of S<T*> are unconstrained, so all are
937 equivalent. So keep TYPE_CANONICAL the same. */
938 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
940 /* Build the corresponding type decl. */
941 tree d
= create_implicit_typedef (DECL_NAME (tmpl
), t
);
942 DECL_CONTEXT (d
) = TYPE_CONTEXT (t
);
943 DECL_SOURCE_LOCATION (d
) = input_location
;
944 TREE_PRIVATE (d
) = (current_access_specifier
== access_private_node
);
945 TREE_PROTECTED (d
) = (current_access_specifier
== access_protected_node
);
953 /* The TYPE is being declared. If it is a template type, that means it
954 is a partial specialization. Do appropriate error-checking. */
957 maybe_process_partial_specialization (tree type
)
961 if (type
== error_mark_node
)
962 return error_mark_node
;
964 /* A lambda that appears in specialization context is not itself a
966 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
969 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
971 error ("name of class shadows template template parameter %qD",
973 return error_mark_node
;
976 context
= TYPE_CONTEXT (type
);
978 if (TYPE_ALIAS_P (type
))
980 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (type
);
982 if (tinfo
&& DECL_ALIAS_TEMPLATE_P (TI_TEMPLATE (tinfo
)))
983 error ("specialization of alias template %qD",
984 TI_TEMPLATE (tinfo
));
986 error ("explicit specialization of non-template %qT", type
);
987 return error_mark_node
;
989 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
991 /* This is for ordinary explicit specialization and partial
992 specialization of a template class such as:
994 template <> class C<int>;
998 template <class T> class C<T*>;
1000 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
1002 if (tree t
= maybe_new_partial_specialization (type
))
1004 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (t
))
1005 && !at_namespace_scope_p ())
1006 return error_mark_node
;
1007 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t
);
1008 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (t
)) = input_location
;
1009 if (processing_template_decl
)
1011 tree decl
= push_template_decl (TYPE_MAIN_DECL (t
));
1012 if (decl
== error_mark_node
)
1013 return error_mark_node
;
1014 return TREE_TYPE (decl
);
1017 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
1018 error ("specialization of %qT after instantiation", type
);
1019 else if (errorcount
&& !processing_specialization
1020 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
1021 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
1022 /* Trying to define a specialization either without a template<> header
1023 or in an inappropriate place. We've already given an error, so just
1024 bail now so we don't actually define the specialization. */
1025 return error_mark_node
;
1027 else if (CLASS_TYPE_P (type
)
1028 && !CLASSTYPE_USE_TEMPLATE (type
)
1029 && CLASSTYPE_TEMPLATE_INFO (type
)
1030 && context
&& CLASS_TYPE_P (context
)
1031 && CLASSTYPE_TEMPLATE_INFO (context
))
1033 /* This is for an explicit specialization of member class
1034 template according to [temp.expl.spec/18]:
1036 template <> template <class U> class C<int>::D;
1038 The context `C<int>' must be an implicit instantiation.
1039 Otherwise this is just a member class template declared
1042 template <> class C<int> { template <class U> class D; };
1043 template <> template <class U> class C<int>::D;
1045 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1046 while in the second case, `C<int>::D' is a primary template
1047 and `C<T>::D' may not exist. */
1049 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
1050 && !COMPLETE_TYPE_P (type
))
1053 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1055 if (current_namespace
1056 != decl_namespace_context (tmpl
))
1058 if (permerror (input_location
,
1059 "specialization of %qD in different namespace",
1061 inform (DECL_SOURCE_LOCATION (tmpl
),
1062 "from definition of %q#D", tmpl
);
1065 /* Check for invalid specialization after instantiation:
1067 template <> template <> class C<int>::D<int>;
1068 template <> template <class U> class C<int>::D; */
1070 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
1071 t
; t
= TREE_CHAIN (t
))
1073 tree inst
= TREE_VALUE (t
);
1074 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
1075 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
1077 /* We already have a full specialization of this partial
1078 instantiation, or a full specialization has been
1079 looked up but not instantiated. Reassign it to the
1080 new member specialization template. */
1084 elt
.tmpl
= most_general_template (tmpl
);
1085 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
1088 type_specializations
->remove_elt (&elt
);
1091 CLASSTYPE_TI_ARGS (inst
)
1092 = elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
1095 = type_specializations
->find_slot (&elt
, INSERT
);
1096 entry
= ggc_alloc
<spec_entry
> ();
1101 /* But if we've had an implicit instantiation, that's a
1102 problem ([temp.expl.spec]/6). */
1103 error ("specialization %qT after instantiation %qT",
1107 /* Mark TYPE as a specialization. And as a result, we only
1108 have one level of template argument for the innermost
1110 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
1111 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
1112 CLASSTYPE_TI_ARGS (type
)
1113 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
1116 else if (processing_specialization
)
1118 /* Someday C++0x may allow for enum template specialization. */
1119 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
1120 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
1121 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
1122 "of %qD not allowed by ISO C++", type
);
1125 error ("explicit specialization of non-template %qT", type
);
1126 return error_mark_node
;
1133 /* Returns nonzero if we can optimize the retrieval of specializations
1134 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1135 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1138 optimize_specialization_lookup_p (tree tmpl
)
1140 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
1141 && DECL_CLASS_SCOPE_P (tmpl
)
1142 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1144 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
1145 /* The optimized lookup depends on the fact that the
1146 template arguments for the member function template apply
1147 purely to the containing class, which is not true if the
1148 containing class is an explicit or partial
1150 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1151 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1152 && !DECL_CONV_FN_P (tmpl
)
1153 /* It is possible to have a template that is not a member
1154 template and is not a member of a template class:
1156 template <typename T>
1157 struct S { friend A::f(); };
1159 Here, the friend function is a template, but the context does
1160 not have template information. The optimized lookup relies
1161 on having ARGS be the template arguments for both the class
1162 and the function template. */
1163 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1166 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1167 gone through coerce_template_parms by now. */
1170 verify_unstripped_args_1 (tree inner
)
1172 for (int i
= 0; i
< TREE_VEC_LENGTH (inner
); ++i
)
1174 tree arg
= TREE_VEC_ELT (inner
, i
);
1175 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1177 else if (TYPE_P (arg
))
1178 gcc_assert (strip_typedefs (arg
, NULL
) == arg
);
1179 else if (ARGUMENT_PACK_P (arg
))
1180 verify_unstripped_args_1 (ARGUMENT_PACK_ARGS (arg
));
1181 else if (strip_typedefs (TREE_TYPE (arg
), NULL
) != TREE_TYPE (arg
))
1182 /* Allow typedefs on the type of a non-type argument, since a
1183 parameter can have them. */;
1185 gcc_assert (strip_typedefs_expr (arg
, NULL
) == arg
);
1190 verify_unstripped_args (tree args
)
1192 ++processing_template_decl
;
1193 if (!any_dependent_template_arguments_p (args
))
1194 verify_unstripped_args_1 (INNERMOST_TEMPLATE_ARGS (args
));
1195 --processing_template_decl
;
1198 /* Retrieve the specialization (in the sense of [temp.spec] - a
1199 specialization is either an instantiation or an explicit
1200 specialization) of TMPL for the given template ARGS. If there is
1201 no such specialization, return NULL_TREE. The ARGS are a vector of
1202 arguments, or a vector of vectors of arguments, in the case of
1203 templates with more than one level of parameters.
1205 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1206 then we search for a partial specialization matching ARGS. This
1207 parameter is ignored if TMPL is not a class template.
1209 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1210 result is a NONTYPE_ARGUMENT_PACK. */
1213 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1215 if (tmpl
== NULL_TREE
)
1218 if (args
== error_mark_node
)
1221 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1222 || TREE_CODE (tmpl
) == FIELD_DECL
);
1224 /* There should be as many levels of arguments as there are
1225 levels of parameters. */
1226 gcc_assert (TMPL_ARGS_DEPTH (args
)
1227 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1228 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1229 : template_class_depth (DECL_CONTEXT (tmpl
))));
1232 verify_unstripped_args (args
);
1234 /* Lambda functions in templates aren't instantiated normally, but through
1235 tsubst_lambda_expr. */
1236 if (lambda_fn_in_template_p (tmpl
))
1239 if (optimize_specialization_lookup_p (tmpl
))
1241 /* The template arguments actually apply to the containing
1242 class. Find the class specialization with those
1244 tree class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1245 tree class_specialization
1246 = retrieve_specialization (class_template
, args
, 0);
1247 if (!class_specialization
)
1250 /* Find the instance of TMPL. */
1251 tree fns
= get_class_binding (class_specialization
, DECL_NAME (tmpl
));
1252 for (ovl_iterator
iter (fns
); iter
; ++iter
)
1255 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1256 /* using-declarations can add base methods to the method vec,
1257 and we don't want those here. */
1258 && DECL_CONTEXT (fn
) == class_specialization
)
1267 hash_table
<spec_hasher
> *specializations
;
1271 elt
.spec
= NULL_TREE
;
1273 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1274 specializations
= type_specializations
;
1276 specializations
= decl_specializations
;
1279 hash
= spec_hasher::hash (&elt
);
1280 found
= specializations
->find_with_hash (&elt
, hash
);
1288 /* Like retrieve_specialization, but for local declarations. */
1291 retrieve_local_specialization (tree tmpl
)
1293 if (local_specializations
== NULL
)
1296 tree
*slot
= local_specializations
->get (tmpl
);
1297 return slot
? *slot
: NULL_TREE
;
1300 /* Returns nonzero iff DECL is a specialization of TMPL. */
1303 is_specialization_of (tree decl
, tree tmpl
)
1307 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1311 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1317 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1319 for (t
= TREE_TYPE (decl
);
1321 t
= CLASSTYPE_USE_TEMPLATE (t
)
1322 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1323 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1330 /* Returns nonzero iff DECL is a specialization of friend declaration
1331 FRIEND_DECL according to [temp.friend]. */
1334 is_specialization_of_friend (tree decl
, tree friend_decl
)
1336 bool need_template
= true;
1339 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1340 || TREE_CODE (decl
) == TYPE_DECL
);
1342 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1343 of a template class, we want to check if DECL is a specialization
1345 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1346 && DECL_TEMPLATE_INFO (friend_decl
)
1347 && !DECL_USE_TEMPLATE (friend_decl
))
1349 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1350 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1351 need_template
= false;
1353 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1354 && !PRIMARY_TEMPLATE_P (friend_decl
))
1355 need_template
= false;
1357 /* There is nothing to do if this is not a template friend. */
1358 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1361 if (is_specialization_of (decl
, friend_decl
))
1365 A member of a class template may be declared to be a friend of a
1366 non-template class. In this case, the corresponding member of
1367 every specialization of the class template is a friend of the
1368 class granting friendship.
1370 For example, given a template friend declaration
1372 template <class T> friend void A<T>::f();
1374 the member function below is considered a friend
1376 template <> struct A<int> {
1380 For this type of template friend, TEMPLATE_DEPTH below will be
1381 nonzero. To determine if DECL is a friend of FRIEND, we first
1382 check if the enclosing class is a specialization of another. */
1384 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1386 && DECL_CLASS_SCOPE_P (decl
)
1387 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1388 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1390 /* Next, we check the members themselves. In order to handle
1391 a few tricky cases, such as when FRIEND_DECL's are
1393 template <class T> friend void A<T>::g(T t);
1394 template <class T> template <T t> friend void A<T>::h();
1398 void A<int>::g(int);
1399 template <int> void A<int>::h();
1401 we need to figure out ARGS, the template arguments from
1402 the context of DECL. This is required for template substitution
1403 of `T' in the function parameter of `g' and template parameter
1404 of `h' in the above examples. Here ARGS corresponds to `int'. */
1406 tree context
= DECL_CONTEXT (decl
);
1407 tree args
= NULL_TREE
;
1408 int current_depth
= 0;
1410 while (current_depth
< template_depth
)
1412 if (CLASSTYPE_TEMPLATE_INFO (context
))
1414 if (current_depth
== 0)
1415 args
= TYPE_TI_ARGS (context
);
1417 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1420 context
= TYPE_CONTEXT (context
);
1423 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1428 tree friend_args_type
;
1429 tree decl_args_type
;
1431 /* Make sure that both DECL and FRIEND_DECL are templates or
1433 is_template
= DECL_TEMPLATE_INFO (decl
)
1434 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1435 if (need_template
^ is_template
)
1437 else if (is_template
)
1439 /* If both are templates, check template parameter list. */
1441 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1443 if (!comp_template_parms
1444 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1448 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1451 decl_type
= TREE_TYPE (decl
);
1453 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1454 tf_none
, NULL_TREE
);
1455 if (friend_type
== error_mark_node
)
1458 /* Check if return types match. */
1459 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1462 /* Check if function parameter types match, ignoring the
1463 `this' parameter. */
1464 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1465 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1466 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1467 friend_args_type
= TREE_CHAIN (friend_args_type
);
1468 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1469 decl_args_type
= TREE_CHAIN (decl_args_type
);
1471 return compparms (decl_args_type
, friend_args_type
);
1475 /* DECL is a TYPE_DECL */
1477 tree decl_type
= TREE_TYPE (decl
);
1479 /* Make sure that both DECL and FRIEND_DECL are templates or
1482 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1483 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1485 if (need_template
^ is_template
)
1487 else if (is_template
)
1490 /* If both are templates, check the name of the two
1491 TEMPLATE_DECL's first because is_friend didn't. */
1492 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1493 != DECL_NAME (friend_decl
))
1496 /* Now check template parameter list. */
1498 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1500 return comp_template_parms
1501 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1505 return (DECL_NAME (decl
)
1506 == DECL_NAME (friend_decl
));
1512 /* Register the specialization SPEC as a specialization of TMPL with
1513 the indicated ARGS. IS_FRIEND indicates whether the specialization
1514 is actually just a friend declaration. ATTRLIST is the list of
1515 attributes that the specialization is declared with or NULL when
1516 it isn't. Returns SPEC, or an equivalent prior declaration, if
1519 We also store instantiations of field packs in the hash table, even
1520 though they are not themselves templates, to make lookup easier. */
1523 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1527 spec_entry
**slot
= NULL
;
1530 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1531 || (TREE_CODE (tmpl
) == FIELD_DECL
1532 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1534 if (TREE_CODE (spec
) == FUNCTION_DECL
1535 && uses_template_parms (DECL_TI_ARGS (spec
)))
1536 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1537 register it; we want the corresponding TEMPLATE_DECL instead.
1538 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1539 the more obvious `uses_template_parms (spec)' to avoid problems
1540 with default function arguments. In particular, given
1541 something like this:
1543 template <class T> void f(T t1, T t = T())
1545 the default argument expression is not substituted for in an
1546 instantiation unless and until it is actually needed. */
1549 if (optimize_specialization_lookup_p (tmpl
))
1550 /* We don't put these specializations in the hash table, but we might
1551 want to give an error about a mismatch. */
1552 fn
= retrieve_specialization (tmpl
, args
, 0);
1560 hash
= spec_hasher::hash (&elt
);
1563 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1565 fn
= ((spec_entry
*) *slot
)->spec
;
1570 /* We can sometimes try to re-register a specialization that we've
1571 already got. In particular, regenerate_decl_from_template calls
1572 duplicate_decls which will update the specialization list. But,
1573 we'll still get called again here anyhow. It's more convenient
1574 to simply allow this than to try to prevent it. */
1577 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1579 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1581 if (DECL_ODR_USED (fn
)
1582 || DECL_EXPLICIT_INSTANTIATION (fn
))
1584 error ("specialization of %qD after instantiation",
1586 return error_mark_node
;
1591 /* This situation should occur only if the first
1592 specialization is an implicit instantiation, the
1593 second is an explicit specialization, and the
1594 implicit instantiation has not yet been used. That
1595 situation can occur if we have implicitly
1596 instantiated a member function and then specialized
1599 We can also wind up here if a friend declaration that
1600 looked like an instantiation turns out to be a
1603 template <class T> void foo(T);
1604 class S { friend void foo<>(int) };
1605 template <> void foo(int);
1607 We transform the existing DECL in place so that any
1608 pointers to it become pointers to the updated
1611 If there was a definition for the template, but not
1612 for the specialization, we want this to look as if
1613 there were no definition, and vice versa. */
1614 DECL_INITIAL (fn
) = NULL_TREE
;
1615 duplicate_decls (spec
, fn
, is_friend
);
1616 /* The call to duplicate_decls will have applied
1619 An explicit specialization of a function template
1620 is inline only if it is explicitly declared to be,
1621 and independently of whether its function template
1624 to the primary function; now copy the inline bits to
1625 the various clones. */
1626 FOR_EACH_CLONE (clone
, fn
)
1628 DECL_DECLARED_INLINE_P (clone
)
1629 = DECL_DECLARED_INLINE_P (fn
);
1630 DECL_SOURCE_LOCATION (clone
)
1631 = DECL_SOURCE_LOCATION (fn
);
1632 DECL_DELETED_FN (clone
)
1633 = DECL_DELETED_FN (fn
);
1635 check_specialization_namespace (tmpl
);
1640 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1642 tree dd
= duplicate_decls (spec
, fn
, is_friend
);
1643 if (dd
== error_mark_node
)
1644 /* We've already complained in duplicate_decls. */
1645 return error_mark_node
;
1647 if (dd
== NULL_TREE
&& DECL_INITIAL (spec
))
1648 /* Dup decl failed, but this is a new definition. Set the
1649 line number so any errors match this new
1651 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1657 return duplicate_decls (spec
, fn
, is_friend
);
1659 /* A specialization must be declared in the same namespace as the
1660 template it is specializing. */
1661 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1662 && !check_specialization_namespace (tmpl
))
1663 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1665 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1667 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1668 gcc_assert (tmpl
&& args
&& spec
);
1671 if ((TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1672 && PRIMARY_TEMPLATE_P (tmpl
)
1673 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1674 || variable_template_p (tmpl
))
1675 /* If TMPL is a forward declaration of a template function, keep a list
1676 of all specializations in case we need to reassign them to a friend
1677 template later in tsubst_friend_function.
1679 Also keep a list of all variable template instantiations so that
1680 process_partial_specialization can check whether a later partial
1681 specialization would have used it. */
1682 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1683 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1689 /* Returns true iff two spec_entry nodes are equivalent. */
1691 int comparing_specializations
;
1694 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1698 ++comparing_specializations
;
1699 equal
= (e1
->tmpl
== e2
->tmpl
1700 && comp_template_args (e1
->args
, e2
->args
));
1701 if (equal
&& flag_concepts
1702 /* tmpl could be a FIELD_DECL for a capture pack. */
1703 && TREE_CODE (e1
->tmpl
) == TEMPLATE_DECL
1704 && VAR_P (DECL_TEMPLATE_RESULT (e1
->tmpl
))
1705 && uses_template_parms (e1
->args
))
1707 /* Partial specializations of a variable template can be distinguished by
1709 tree c1
= e1
->spec
? get_constraints (e1
->spec
) : NULL_TREE
;
1710 tree c2
= e2
->spec
? get_constraints (e2
->spec
) : NULL_TREE
;
1711 equal
= equivalent_constraints (c1
, c2
);
1713 --comparing_specializations
;
1718 /* Returns a hash for a template TMPL and template arguments ARGS. */
1721 hash_tmpl_and_args (tree tmpl
, tree args
)
1723 hashval_t val
= iterative_hash_object (DECL_UID (tmpl
), 0);
1724 return iterative_hash_template_arg (args
, val
);
1727 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1731 spec_hasher::hash (spec_entry
*e
)
1733 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1736 /* Recursively calculate a hash value for a template argument ARG, for use
1737 in the hash tables of template specializations. */
1740 iterative_hash_template_arg (tree arg
, hashval_t val
)
1742 unsigned HOST_WIDE_INT i
;
1743 enum tree_code code
;
1746 if (arg
== NULL_TREE
)
1747 return iterative_hash_object (arg
, val
);
1752 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1755 code
= TREE_CODE (arg
);
1756 tclass
= TREE_CODE_CLASS (code
);
1758 val
= iterative_hash_object (code
, val
);
1765 case IDENTIFIER_NODE
:
1766 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1770 int i
, len
= TREE_VEC_LENGTH (arg
);
1771 for (i
= 0; i
< len
; ++i
)
1772 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1776 case TYPE_PACK_EXPANSION
:
1777 case EXPR_PACK_EXPANSION
:
1778 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1779 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1781 case TYPE_ARGUMENT_PACK
:
1782 case NONTYPE_ARGUMENT_PACK
:
1783 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1786 for (; arg
; arg
= TREE_CHAIN (arg
))
1787 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1791 for (lkp_iterator
iter (arg
); iter
; ++iter
)
1792 val
= iterative_hash_template_arg (*iter
, val
);
1798 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1799 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1801 val
= iterative_hash_template_arg (field
, val
);
1802 val
= iterative_hash_template_arg (value
, val
);
1808 if (!DECL_ARTIFICIAL (arg
))
1810 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1811 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1813 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1816 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1819 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1820 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1822 case TEMPLATE_PARM_INDEX
:
1823 val
= iterative_hash_template_arg
1824 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1825 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1826 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1829 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1830 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1831 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1834 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1836 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1840 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1841 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1842 val
= iterative_hash_object (code
, val
);
1843 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1846 /* [temp.over.link] Two lambda-expressions are never considered
1849 So just hash the closure type. */
1850 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1853 case IMPLICIT_CONV_EXPR
:
1854 case STATIC_CAST_EXPR
:
1855 case REINTERPRET_CAST_EXPR
:
1856 case CONST_CAST_EXPR
:
1857 case DYNAMIC_CAST_EXPR
:
1859 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1860 /* Now hash operands as usual. */
1865 tree fn
= CALL_EXPR_FN (arg
);
1866 if (tree name
= dependent_name (fn
))
1868 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
1869 val
= iterative_hash_template_arg (TREE_OPERAND (fn
, 1), val
);
1872 val
= iterative_hash_template_arg (fn
, val
);
1873 call_expr_arg_iterator ai
;
1874 for (tree x
= first_call_expr_arg (arg
, &ai
); x
;
1875 x
= next_call_expr_arg (&ai
))
1876 val
= iterative_hash_template_arg (x
, val
);
1887 if (tree ats
= alias_template_specialization_p (arg
, nt_transparent
))
1889 // We want an alias specialization that survived strip_typedefs
1890 // to hash differently from its TYPE_CANONICAL, to avoid hash
1891 // collisions that compare as different in template_args_equal.
1892 // These could be dependent specializations that strip_typedefs
1893 // left alone, or untouched specializations because
1894 // coerce_template_parms returns the unconverted template
1895 // arguments if it sees incomplete argument packs.
1896 tree ti
= TYPE_ALIAS_TEMPLATE_INFO (ats
);
1897 return hash_tmpl_and_args (TI_TEMPLATE (ti
), TI_ARGS (ti
));
1899 if (TYPE_CANONICAL (arg
))
1900 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1902 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1903 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1904 /* Otherwise just compare the types during lookup. */
1907 case tcc_declaration
:
1909 return iterative_hash_expr (arg
, val
);
1912 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1914 unsigned n
= cp_tree_operand_length (arg
);
1915 for (i
= 0; i
< n
; ++i
)
1916 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1924 /* Unregister the specialization SPEC as a specialization of TMPL.
1925 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1926 if the SPEC was listed as a specialization of TMPL.
1928 Note that SPEC has been ggc_freed, so we can't look inside it. */
1931 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1936 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1937 elt
.args
= TI_ARGS (tinfo
);
1938 elt
.spec
= NULL_TREE
;
1940 entry
= decl_specializations
->find (&elt
);
1943 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1944 gcc_assert (new_spec
!= NULL_TREE
);
1945 entry
->spec
= new_spec
;
1952 /* Like register_specialization, but for local declarations. We are
1953 registering SPEC, an instantiation of TMPL. */
1956 register_local_specialization (tree spec
, tree tmpl
)
1958 gcc_assert (tmpl
!= spec
);
1959 local_specializations
->put (tmpl
, spec
);
1962 /* TYPE is a class type. Returns true if TYPE is an explicitly
1963 specialized class. */
1966 explicit_class_specialization_p (tree type
)
1968 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1970 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1973 /* Print the list of functions at FNS, going through all the overloads
1974 for each element of the list. Alternatively, FNS cannot be a
1975 TREE_LIST, in which case it will be printed together with all the
1978 MORE and *STR should respectively be FALSE and NULL when the function
1979 is called from the outside. They are used internally on recursive
1980 calls. print_candidates manages the two parameters and leaves NULL
1981 in *STR when it ends. */
1984 print_candidates_1 (tree fns
, char **str
, bool more
= false)
1986 if (TREE_CODE (fns
) == TREE_LIST
)
1987 for (; fns
; fns
= TREE_CHAIN (fns
))
1988 print_candidates_1 (TREE_VALUE (fns
), str
, more
|| TREE_CHAIN (fns
));
1990 for (lkp_iterator
iter (fns
); iter
;)
1995 const char *pfx
= *str
;
1999 pfx
= _("candidates are:");
2001 pfx
= _("candidate is:");
2002 *str
= get_spaces (pfx
);
2004 inform (DECL_SOURCE_LOCATION (cand
), "%s %#qD", pfx
, cand
);
2008 /* Print the list of candidate FNS in an error message. FNS can also
2009 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
2012 print_candidates (tree fns
)
2015 print_candidates_1 (fns
, &str
);
2019 /* Get a (possibly) constrained template declaration for the
2020 purpose of ordering candidates. */
2022 get_template_for_ordering (tree list
)
2024 gcc_assert (TREE_CODE (list
) == TREE_LIST
);
2025 tree f
= TREE_VALUE (list
);
2026 if (tree ti
= DECL_TEMPLATE_INFO (f
))
2027 return TI_TEMPLATE (ti
);
2031 /* Among candidates having the same signature, return the
2032 most constrained or NULL_TREE if there is no best candidate.
2033 If the signatures of candidates vary (e.g., template
2034 specialization vs. member function), then there can be no
2037 Note that we don't compare constraints on the functions
2038 themselves, but rather those of their templates. */
2040 most_constrained_function (tree candidates
)
2042 // Try to find the best candidate in a first pass.
2043 tree champ
= candidates
;
2044 for (tree c
= TREE_CHAIN (champ
); c
; c
= TREE_CHAIN (c
))
2046 int winner
= more_constrained (get_template_for_ordering (champ
),
2047 get_template_for_ordering (c
));
2049 champ
= c
; // The candidate is more constrained
2050 else if (winner
== 0)
2051 return NULL_TREE
; // Neither is more constrained
2054 // Verify that the champ is better than previous candidates.
2055 for (tree c
= candidates
; c
!= champ
; c
= TREE_CHAIN (c
)) {
2056 if (!more_constrained (get_template_for_ordering (champ
),
2057 get_template_for_ordering (c
)))
2065 /* Returns the template (one of the functions given by TEMPLATE_ID)
2066 which can be specialized to match the indicated DECL with the
2067 explicit template args given in TEMPLATE_ID. The DECL may be
2068 NULL_TREE if none is available. In that case, the functions in
2069 TEMPLATE_ID are non-members.
2071 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2072 specialization of a member template.
2074 The TEMPLATE_COUNT is the number of references to qualifying
2075 template classes that appeared in the name of the function. See
2076 check_explicit_specialization for a more accurate description.
2078 TSK indicates what kind of template declaration (if any) is being
2079 declared. TSK_TEMPLATE indicates that the declaration given by
2080 DECL, though a FUNCTION_DECL, has template parameters, and is
2081 therefore a template function.
2083 The template args (those explicitly specified and those deduced)
2084 are output in a newly created vector *TARGS_OUT.
2086 If it is impossible to determine the result, an error message is
2087 issued. The error_mark_node is returned to indicate failure. */
2090 determine_specialization (tree template_id
,
2093 int need_member_template
,
2099 tree explicit_targs
;
2100 tree candidates
= NULL_TREE
;
2102 /* A TREE_LIST of templates of which DECL may be a specialization.
2103 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2104 corresponding TREE_PURPOSE is the set of template arguments that,
2105 when used to instantiate the template, would produce a function
2106 with the signature of DECL. */
2107 tree templates
= NULL_TREE
;
2109 cp_binding_level
*b
;
2111 *targs_out
= NULL_TREE
;
2113 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
2114 return error_mark_node
;
2116 /* We shouldn't be specializing a member template of an
2117 unspecialized class template; we already gave an error in
2118 check_specialization_scope, now avoid crashing. */
2120 && template_count
&& DECL_CLASS_SCOPE_P (decl
)
2121 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
2123 gcc_assert (errorcount
);
2124 return error_mark_node
;
2127 fns
= TREE_OPERAND (template_id
, 0);
2128 explicit_targs
= TREE_OPERAND (template_id
, 1);
2130 if (fns
== error_mark_node
)
2131 return error_mark_node
;
2133 /* Check for baselinks. */
2134 if (BASELINK_P (fns
))
2135 fns
= BASELINK_FUNCTIONS (fns
);
2137 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
2139 error_at (DECL_SOURCE_LOCATION (decl
),
2140 "%qD is not a function template", fns
);
2141 return error_mark_node
;
2143 else if (VAR_P (decl
) && !variable_template_p (fns
))
2145 error ("%qD is not a variable template", fns
);
2146 return error_mark_node
;
2149 /* Count the number of template headers specified for this
2152 for (b
= current_binding_level
;
2153 b
->kind
== sk_template_parms
;
2157 tree orig_fns
= fns
;
2159 if (variable_template_p (fns
))
2161 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns
));
2162 targs
= coerce_template_parms (parms
, explicit_targs
, fns
,
2163 tf_warning_or_error
,
2164 /*req_all*/true, /*use_defarg*/true);
2165 if (targs
!= error_mark_node
)
2166 templates
= tree_cons (targs
, fns
, templates
);
2168 else for (lkp_iterator
iter (fns
); iter
; ++iter
)
2172 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2174 tree decl_arg_types
;
2178 /* In case of explicit specialization, we need to check if
2179 the number of template headers appearing in the specialization
2180 is correct. This is usually done in check_explicit_specialization,
2181 but the check done there cannot be exhaustive when specializing
2182 member functions. Consider the following code:
2184 template <> void A<int>::f(int);
2185 template <> template <> void A<int>::f(int);
2187 Assuming that A<int> is not itself an explicit specialization
2188 already, the first line specializes "f" which is a non-template
2189 member function, whilst the second line specializes "f" which
2190 is a template member function. So both lines are syntactically
2191 correct, and check_explicit_specialization does not reject
2194 Here, we can do better, as we are matching the specialization
2195 against the declarations. We count the number of template
2196 headers, and we check if they match TEMPLATE_COUNT + 1
2197 (TEMPLATE_COUNT is the number of qualifying template classes,
2198 plus there must be another header for the member template
2201 Notice that if header_count is zero, this is not a
2202 specialization but rather a template instantiation, so there
2203 is no check we can perform here. */
2204 if (header_count
&& header_count
!= template_count
+ 1)
2207 /* Check that the number of template arguments at the
2208 innermost level for DECL is the same as for FN. */
2209 if (current_binding_level
->kind
== sk_template_parms
2210 && !current_binding_level
->explicit_spec_p
2211 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
2212 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
2213 (current_template_parms
))))
2216 /* DECL might be a specialization of FN. */
2217 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2218 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2220 /* For a non-static member function, we need to make sure
2221 that the const qualification is the same. Since
2222 get_bindings does not try to merge the "this" parameter,
2223 we must do the comparison explicitly. */
2224 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
2226 if (!same_type_p (TREE_VALUE (fn_arg_types
),
2227 TREE_VALUE (decl_arg_types
)))
2230 /* And the ref-qualification. */
2231 if (type_memfn_rqual (TREE_TYPE (decl
))
2232 != type_memfn_rqual (TREE_TYPE (fn
)))
2236 /* Skip the "this" parameter and, for constructors of
2237 classes with virtual bases, the VTT parameter. A
2238 full specialization of a constructor will have a VTT
2239 parameter, but a template never will. */
2241 = skip_artificial_parms_for (decl
, decl_arg_types
);
2243 = skip_artificial_parms_for (fn
, fn_arg_types
);
2245 /* Function templates cannot be specializations; there are
2246 no partial specializations of functions. Therefore, if
2247 the type of DECL does not match FN, there is no
2250 Note that it should never be the case that we have both
2251 candidates added here, and for regular member functions
2253 if (tsk
== tsk_template
)
2255 if (compparms (fn_arg_types
, decl_arg_types
))
2256 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2260 /* See whether this function might be a specialization of this
2261 template. Suppress access control because we might be trying
2262 to make this specialization a friend, and we have already done
2263 access control for the declaration of the specialization. */
2264 push_deferring_access_checks (dk_no_check
);
2265 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
2266 pop_deferring_access_checks ();
2269 /* We cannot deduce template arguments that when used to
2270 specialize TMPL will produce DECL. */
2273 if (uses_template_parms (targs
))
2274 /* We deduced something involving 'auto', which isn't a valid
2275 template argument. */
2278 /* Remove, from the set of candidates, all those functions
2279 whose constraints are not satisfied. */
2280 if (flag_concepts
&& !constraints_satisfied_p (fn
, targs
))
2283 // Then, try to form the new function type.
2284 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_fndecl_type
, NULL_TREE
);
2285 if (insttype
== error_mark_node
)
2288 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
2289 if (!compparms (fn_arg_types
, decl_arg_types
))
2292 /* Save this template, and the arguments deduced. */
2293 templates
= tree_cons (targs
, fn
, templates
);
2295 else if (need_member_template
)
2296 /* FN is an ordinary member function, and we need a
2297 specialization of a member template. */
2299 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2300 /* We can get IDENTIFIER_NODEs here in certain erroneous
2303 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2304 /* This is just an ordinary non-member function. Nothing can
2305 be a specialization of that. */
2307 else if (DECL_ARTIFICIAL (fn
))
2308 /* Cannot specialize functions that are created implicitly. */
2312 tree decl_arg_types
;
2314 /* This is an ordinary member function. However, since
2315 we're here, we can assume its enclosing class is a
2316 template class. For example,
2318 template <typename T> struct S { void f(); };
2319 template <> void S<int>::f() {}
2321 Here, S<int>::f is a non-template, but S<int> is a
2322 template class. If FN has the same type as DECL, we
2323 might be in business. */
2325 if (!DECL_TEMPLATE_INFO (fn
))
2326 /* Its enclosing class is an explicit specialization
2327 of a template class. This is not a candidate. */
2330 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2331 TREE_TYPE (TREE_TYPE (fn
))))
2332 /* The return types differ. */
2335 /* Adjust the type of DECL in case FN is a static member. */
2336 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2337 if (DECL_STATIC_FUNCTION_P (fn
)
2338 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2339 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2341 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2345 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2346 && (type_memfn_rqual (TREE_TYPE (decl
))
2347 != type_memfn_rqual (TREE_TYPE (fn
))))
2350 // If the deduced arguments do not satisfy the constraints,
2351 // this is not a candidate.
2352 if (flag_concepts
&& !constraints_satisfied_p (fn
))
2355 // Add the candidate.
2356 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2360 if (templates
&& TREE_CHAIN (templates
))
2366 It is possible for a specialization with a given function
2367 signature to be instantiated from more than one function
2368 template. In such cases, explicit specification of the
2369 template arguments must be used to uniquely identify the
2370 function template specialization being specialized.
2372 Note that here, there's no suggestion that we're supposed to
2373 determine which of the candidate templates is most
2374 specialized. However, we, also have:
2378 Partial ordering of overloaded function template
2379 declarations is used in the following contexts to select
2380 the function template to which a function template
2381 specialization refers:
2383 -- when an explicit specialization refers to a function
2386 So, we do use the partial ordering rules, at least for now.
2387 This extension can only serve to make invalid programs valid,
2388 so it's safe. And, there is strong anecdotal evidence that
2389 the committee intended the partial ordering rules to apply;
2390 the EDG front end has that behavior, and John Spicer claims
2391 that the committee simply forgot to delete the wording in
2392 [temp.expl.spec]. */
2393 tree tmpl
= most_specialized_instantiation (templates
);
2394 if (tmpl
!= error_mark_node
)
2397 TREE_CHAIN (templates
) = NULL_TREE
;
2401 // Concepts allows multiple declarations of member functions
2402 // with the same signature. Like above, we need to rely on
2403 // on the partial ordering of those candidates to determine which
2405 if (flag_concepts
&& candidates
&& TREE_CHAIN (candidates
))
2407 if (tree cand
= most_constrained_function (candidates
))
2410 TREE_CHAIN (cand
) = NULL_TREE
;
2414 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2416 error ("template-id %qD for %q+D does not match any template "
2417 "declaration", template_id
, decl
);
2418 if (header_count
&& header_count
!= template_count
+ 1)
2419 inform (DECL_SOURCE_LOCATION (decl
),
2420 "saw %d %<template<>%>, need %d for "
2421 "specializing a member function template",
2422 header_count
, template_count
+ 1);
2424 print_candidates (orig_fns
);
2425 return error_mark_node
;
2427 else if ((templates
&& TREE_CHAIN (templates
))
2428 || (candidates
&& TREE_CHAIN (candidates
))
2429 || (templates
&& candidates
))
2431 error ("ambiguous template specialization %qD for %q+D",
2433 candidates
= chainon (candidates
, templates
);
2434 print_candidates (candidates
);
2435 return error_mark_node
;
2438 /* We have one, and exactly one, match. */
2441 tree fn
= TREE_VALUE (candidates
);
2442 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2444 /* Propagate the candidate's constraints to the declaration. */
2445 set_constraints (decl
, get_constraints (fn
));
2447 /* DECL is a re-declaration or partial instantiation of a template
2449 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2451 /* It was a specialization of an ordinary member function in a
2453 return DECL_TI_TEMPLATE (fn
);
2456 /* It was a specialization of a template. */
2457 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2458 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2460 *targs_out
= copy_node (targs
);
2461 SET_TMPL_ARGS_LEVEL (*targs_out
,
2462 TMPL_ARGS_DEPTH (*targs_out
),
2463 TREE_PURPOSE (templates
));
2466 *targs_out
= TREE_PURPOSE (templates
);
2467 return TREE_VALUE (templates
);
2470 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2471 but with the default argument values filled in from those in the
2475 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2478 tree new_spec_types
;
2483 if (spec_types
== void_list_node
)
2484 return void_list_node
;
2486 /* Substitute into the rest of the list. */
2488 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2489 TREE_CHAIN (tmpl_types
));
2491 /* Add the default argument for this parameter. */
2492 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2493 TREE_VALUE (spec_types
),
2497 /* DECL is an explicit specialization. Replicate default arguments
2498 from the template it specializes. (That way, code like:
2500 template <class T> void f(T = 3);
2501 template <> void f(double);
2504 works, as required.) An alternative approach would be to look up
2505 the correct default arguments at the call-site, but this approach
2506 is consistent with how implicit instantiations are handled. */
2509 copy_default_args_to_explicit_spec (tree decl
)
2514 tree new_spec_types
;
2518 tree object_type
= NULL_TREE
;
2519 tree in_charge
= NULL_TREE
;
2520 tree vtt
= NULL_TREE
;
2522 /* See if there's anything we need to do. */
2523 tmpl
= DECL_TI_TEMPLATE (decl
);
2524 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2525 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2526 if (TREE_PURPOSE (t
))
2531 old_type
= TREE_TYPE (decl
);
2532 spec_types
= TYPE_ARG_TYPES (old_type
);
2534 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2536 /* Remove the this pointer, but remember the object's type for
2538 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2539 spec_types
= TREE_CHAIN (spec_types
);
2540 tmpl_types
= TREE_CHAIN (tmpl_types
);
2542 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2544 /* DECL may contain more parameters than TMPL due to the extra
2545 in-charge parameter in constructors and destructors. */
2546 in_charge
= spec_types
;
2547 spec_types
= TREE_CHAIN (spec_types
);
2549 if (DECL_HAS_VTT_PARM_P (decl
))
2552 spec_types
= TREE_CHAIN (spec_types
);
2556 /* Compute the merged default arguments. */
2558 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2560 /* Compute the new FUNCTION_TYPE. */
2564 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2569 /* Put the in-charge parameter back. */
2570 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2571 TREE_VALUE (in_charge
),
2574 new_type
= build_method_type_directly (object_type
,
2575 TREE_TYPE (old_type
),
2579 new_type
= build_function_type (TREE_TYPE (old_type
),
2581 new_type
= cp_build_type_attribute_variant (new_type
,
2582 TYPE_ATTRIBUTES (old_type
));
2583 new_type
= cxx_copy_lang_qualifiers (new_type
, old_type
);
2585 TREE_TYPE (decl
) = new_type
;
2588 /* Return the number of template headers we expect to see for a definition
2589 or specialization of CTYPE or one of its non-template members. */
2592 num_template_headers_for_class (tree ctype
)
2594 int num_templates
= 0;
2596 while (ctype
&& CLASS_TYPE_P (ctype
))
2598 /* You're supposed to have one `template <...>' for every
2599 template class, but you don't need one for a full
2600 specialization. For example:
2602 template <class T> struct S{};
2603 template <> struct S<int> { void f(); };
2604 void S<int>::f () {}
2606 is correct; there shouldn't be a `template <>' for the
2607 definition of `S<int>::f'. */
2608 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2609 /* If CTYPE does not have template information of any
2610 kind, then it is not a template, nor is it nested
2611 within a template. */
2613 if (explicit_class_specialization_p (ctype
))
2615 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2618 ctype
= TYPE_CONTEXT (ctype
);
2621 return num_templates
;
2624 /* Do a simple sanity check on the template headers that precede the
2625 variable declaration DECL. */
2628 check_template_variable (tree decl
)
2630 tree ctx
= CP_DECL_CONTEXT (decl
);
2631 int wanted
= num_template_headers_for_class (ctx
);
2632 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2633 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2635 if (cxx_dialect
< cxx14
)
2636 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2637 "variable templates only available with "
2638 "%<-std=c++14%> or %<-std=gnu++14%>");
2640 // Namespace-scope variable templates should have a template header.
2643 if (template_header_count
> wanted
)
2645 auto_diagnostic_group d
;
2646 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2647 "too many template headers for %qD "
2650 if (warned
&& CLASS_TYPE_P (ctx
)
2651 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2652 inform (DECL_SOURCE_LOCATION (decl
),
2653 "members of an explicitly specialized class are defined "
2654 "without a template header");
2658 /* An explicit specialization whose declarator-id or class-head-name is not
2659 qualified shall be declared in the nearest enclosing namespace of the
2660 template, or, if the namespace is inline (7.3.1), any namespace from its
2661 enclosing namespace set.
2663 If the name declared in the explicit instantiation is an unqualified name,
2664 the explicit instantiation shall appear in the namespace where its template
2665 is declared or, if that namespace is inline (7.3.1), any namespace from its
2666 enclosing namespace set. */
2669 check_unqualified_spec_or_inst (tree t
, location_t loc
)
2671 tree tmpl
= most_general_template (t
);
2672 if (DECL_NAMESPACE_SCOPE_P (tmpl
)
2673 && !is_nested_namespace (current_namespace
,
2674 CP_DECL_CONTEXT (tmpl
), true))
2676 if (processing_specialization
)
2677 permerror (loc
, "explicit specialization of %qD outside its "
2678 "namespace must use a nested-name-specifier", tmpl
);
2679 else if (processing_explicit_instantiation
2680 && cxx_dialect
>= cxx11
)
2681 /* This was allowed in C++98, so only pedwarn. */
2682 pedwarn (loc
, OPT_Wpedantic
, "explicit instantiation of %qD "
2683 "outside its namespace must use a nested-name-"
2688 /* Warn for a template specialization SPEC that is missing some of a set
2689 of function or type attributes that the template TEMPL is declared with.
2690 ATTRLIST is a list of additional attributes that SPEC should be taken
2691 to ultimately be declared with. */
2694 warn_spec_missing_attributes (tree tmpl
, tree spec
, tree attrlist
)
2696 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
2697 tmpl
= DECL_TEMPLATE_RESULT (tmpl
);
2699 /* Avoid warning if the difference between the primary and
2700 the specialization is not in one of the attributes below. */
2701 const char* const blacklist
[] = {
2702 "alloc_align", "alloc_size", "assume_aligned", "format",
2703 "format_arg", "malloc", "nonnull", NULL
2706 /* Put together a list of the black listed attributes that the primary
2707 template is declared with that the specialization is not, in case
2708 it's not apparent from the most recent declaration of the primary. */
2710 unsigned nattrs
= decls_mismatched_attributes (tmpl
, spec
, attrlist
,
2716 auto_diagnostic_group d
;
2717 if (warning_at (DECL_SOURCE_LOCATION (spec
), OPT_Wmissing_attributes
,
2718 "explicit specialization %q#D may be missing attributes",
2720 inform (DECL_SOURCE_LOCATION (tmpl
),
2722 ? G_("missing primary template attributes %s")
2723 : G_("missing primary template attribute %s"),
2724 pp_formatted_text (&str
));
2727 /* Check to see if the function just declared, as indicated in
2728 DECLARATOR, and in DECL, is a specialization of a function
2729 template. We may also discover that the declaration is an explicit
2730 instantiation at this point.
2732 Returns DECL, or an equivalent declaration that should be used
2733 instead if all goes well. Issues an error message if something is
2734 amiss. Returns error_mark_node if the error is not easily
2737 FLAGS is a bitmask consisting of the following flags:
2739 2: The function has a definition.
2740 4: The function is a friend.
2742 The TEMPLATE_COUNT is the number of references to qualifying
2743 template classes that appeared in the name of the function. For
2746 template <class T> struct S { void f(); };
2749 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2750 classes are not counted in the TEMPLATE_COUNT, so that in
2752 template <class T> struct S {};
2753 template <> struct S<int> { void f(); }
2754 template <> void S<int>::f();
2756 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2757 invalid; there should be no template <>.)
2759 If the function is a specialization, it is marked as such via
2760 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2761 is set up correctly, and it is added to the list of specializations
2762 for that template. */
2765 check_explicit_specialization (tree declarator
,
2771 int have_def
= flags
& 2;
2772 int is_friend
= flags
& 4;
2773 bool is_concept
= flags
& 8;
2774 int specialization
= 0;
2775 int explicit_instantiation
= 0;
2776 int member_specialization
= 0;
2777 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2778 tree dname
= DECL_NAME (decl
);
2783 if (!processing_specialization
)
2786 tsk
= tsk_excessive_parms
;
2789 tsk
= current_tmpl_spec_kind (template_count
);
2794 if (processing_specialization
&& !VAR_P (decl
))
2797 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2799 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2802 /* This could be something like:
2804 template <class T> void f(T);
2805 class S { friend void f<>(int); } */
2809 /* This case handles bogus declarations like template <>
2810 template <class T> void f<int>(); */
2812 error_at (cp_expr_loc_or_input_loc (declarator
),
2813 "template-id %qE 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_at (cp_expr_loc_or_input_loc (declarator
),
2873 "template-id %qE in declaration of primary template",
2875 else if (variable_template_p (TREE_OPERAND (declarator
, 0)))
2877 /* Partial specialization of variable template. */
2878 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2882 else if (cxx_dialect
< cxx14
)
2883 error_at (cp_expr_loc_or_input_loc (declarator
),
2884 "non-type partial specialization %qE "
2885 "is not allowed", declarator
);
2887 error_at (cp_expr_loc_or_input_loc (declarator
),
2888 "non-class, non-variable partial specialization %qE "
2889 "is not allowed", declarator
);
2894 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2895 /* This is a specialization of a member template, without
2896 specialization the containing class. Something like:
2898 template <class T> struct S {
2899 template <class U> void f (U);
2901 template <> template <class U> void S<int>::f(U) {}
2903 That's a specialization -- but of the entire template. */
2911 if ((specialization
|| member_specialization
)
2912 /* This doesn't apply to variable templates. */
2913 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (decl
)))
2915 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2916 for (; t
; t
= TREE_CHAIN (t
))
2917 if (TREE_PURPOSE (t
))
2919 permerror (input_location
,
2920 "default argument specified in explicit specialization");
2925 if (specialization
|| member_specialization
|| explicit_instantiation
)
2927 tree tmpl
= NULL_TREE
;
2928 tree targs
= NULL_TREE
;
2929 bool was_template_id
= (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
);
2931 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2932 if (!was_template_id
)
2936 gcc_assert (identifier_p (declarator
));
2941 /* If there is no class context, the explicit instantiation
2942 must be at namespace scope. */
2943 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2945 /* Find the namespace binding, using the declaration
2947 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2949 if (fns
== error_mark_node
)
2950 /* If lookup fails, look for a friend declaration so we can
2951 give a better diagnostic. */
2952 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2953 /*type*/false, /*complain*/true,
2956 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2958 error ("%qD is not a template function", dname
);
2959 fns
= error_mark_node
;
2963 declarator
= lookup_template_function (fns
, NULL_TREE
);
2966 if (declarator
== error_mark_node
)
2967 return error_mark_node
;
2969 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2971 if (!explicit_instantiation
)
2972 /* A specialization in class scope. This is invalid,
2973 but the error will already have been flagged by
2974 check_specialization_scope. */
2975 return error_mark_node
;
2978 /* It's not valid to write an explicit instantiation in
2981 class C { template void f(); }
2983 This case is caught by the parser. However, on
2986 template class C { void f(); };
2988 (which is invalid) we can get here. The error will be
2995 else if (ctype
!= NULL_TREE
2996 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2998 // We'll match variable templates in start_decl.
3002 /* Find the list of functions in ctype that have the same
3003 name as the declared function. */
3004 tree name
= TREE_OPERAND (declarator
, 0);
3006 if (constructor_name_p (name
, ctype
))
3008 if (DECL_CONSTRUCTOR_P (decl
)
3009 ? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
3010 : !CLASSTYPE_DESTRUCTOR (ctype
))
3012 /* From [temp.expl.spec]:
3014 If such an explicit specialization for the member
3015 of a class template names an implicitly-declared
3016 special member function (clause _special_), the
3017 program is ill-formed.
3019 Similar language is found in [temp.explicit]. */
3020 error ("specialization of implicitly-declared special member function");
3021 return error_mark_node
;
3024 name
= DECL_NAME (decl
);
3027 /* For a type-conversion operator, We might be looking for
3028 `operator int' which will be a specialization of
3029 `operator T'. Grab all the conversion operators, and
3030 then select from them. */
3031 tree fns
= get_class_binding (ctype
, IDENTIFIER_CONV_OP_P (name
)
3032 ? conv_op_identifier
: name
);
3034 if (fns
== NULL_TREE
)
3036 error ("no member function %qD declared in %qT", name
, ctype
);
3037 return error_mark_node
;
3040 TREE_OPERAND (declarator
, 0) = fns
;
3043 /* Figure out what exactly is being specialized at this point.
3044 Note that for an explicit instantiation, even one for a
3045 member function, we cannot tell a priori whether the
3046 instantiation is for a member template, or just a member
3047 function of a template class. Even if a member template is
3048 being instantiated, the member template arguments may be
3049 elided if they can be deduced from the rest of the
3051 tmpl
= determine_specialization (declarator
, decl
,
3053 member_specialization
,
3057 if (!tmpl
|| tmpl
== error_mark_node
)
3058 /* We couldn't figure out what this declaration was
3060 return error_mark_node
;
3063 if (TREE_CODE (decl
) == FUNCTION_DECL
3064 && DECL_HIDDEN_FRIEND_P (tmpl
))
3066 auto_diagnostic_group d
;
3067 if (pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
3068 "friend declaration %qD is not visible to "
3069 "explicit specialization", tmpl
))
3070 inform (DECL_SOURCE_LOCATION (tmpl
),
3071 "friend declaration here");
3073 else if (!ctype
&& !is_friend
3074 && CP_DECL_CONTEXT (decl
) == current_namespace
)
3075 check_unqualified_spec_or_inst (tmpl
, DECL_SOURCE_LOCATION (decl
));
3077 tree gen_tmpl
= most_general_template (tmpl
);
3079 if (explicit_instantiation
)
3081 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
3082 is done by do_decl_instantiation later. */
3084 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
3085 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
3087 if (arg_depth
> parm_depth
)
3089 /* If TMPL is not the most general template (for
3090 example, if TMPL is a friend template that is
3091 injected into namespace scope), then there will
3092 be too many levels of TARGS. Remove some of them
3097 new_targs
= make_tree_vec (parm_depth
);
3098 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
3099 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
3100 = TREE_VEC_ELT (targs
, i
);
3104 return instantiate_template (tmpl
, targs
, tf_error
);
3107 /* If we thought that the DECL was a member function, but it
3108 turns out to be specializing a static member function,
3109 make DECL a static member function as well. */
3110 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
3111 && DECL_STATIC_FUNCTION_P (tmpl
)
3112 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
3113 revert_static_member_fn (decl
);
3115 /* If this is a specialization of a member template of a
3116 template class, we want to return the TEMPLATE_DECL, not
3117 the specialization of it. */
3118 if (tsk
== tsk_template
&& !was_template_id
)
3120 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
3121 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
3122 DECL_INITIAL (result
) = NULL_TREE
;
3126 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
3127 DECL_SOURCE_LOCATION (result
)
3128 = DECL_SOURCE_LOCATION (decl
);
3129 /* We want to use the argument list specified in the
3130 definition, not in the original declaration. */
3131 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
3132 for (parm
= DECL_ARGUMENTS (result
); parm
;
3133 parm
= DECL_CHAIN (parm
))
3134 DECL_CONTEXT (parm
) = result
;
3136 return register_specialization (tmpl
, gen_tmpl
, targs
,
3140 /* Set up the DECL_TEMPLATE_INFO for DECL. */
3141 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
3143 if (was_template_id
)
3144 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
)) = true;
3146 /* Inherit default function arguments from the template
3147 DECL is specializing. */
3148 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
3149 copy_default_args_to_explicit_spec (decl
);
3151 /* This specialization has the same protection as the
3152 template it specializes. */
3153 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
3154 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
3156 /* 7.1.1-1 [dcl.stc]
3158 A storage-class-specifier shall not be specified in an
3159 explicit specialization...
3161 The parser rejects these, so unless action is taken here,
3162 explicit function specializations will always appear with
3165 The action recommended by the C++ CWG in response to C++
3166 defect report 605 is to make the storage class and linkage
3167 of the explicit specialization match the templated function:
3169 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3171 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
3173 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
3174 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
3176 /* A concept cannot be specialized. */
3177 if (DECL_DECLARED_CONCEPT_P (tmpl_func
))
3179 error ("explicit specialization of function concept %qD",
3181 return error_mark_node
;
3184 /* This specialization has the same linkage and visibility as
3185 the function template it specializes. */
3186 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
3187 if (! TREE_PUBLIC (decl
))
3189 DECL_INTERFACE_KNOWN (decl
) = 1;
3190 DECL_NOT_REALLY_EXTERN (decl
) = 1;
3192 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
3193 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
3195 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3196 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
3200 /* If DECL is a friend declaration, declared using an
3201 unqualified name, the namespace associated with DECL may
3202 have been set incorrectly. For example, in:
3204 template <typename T> void f(T);
3206 struct S { friend void f<int>(int); }
3209 we will have set the DECL_CONTEXT for the friend
3210 declaration to N, rather than to the global namespace. */
3211 if (DECL_NAMESPACE_SCOPE_P (decl
))
3212 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
3214 if (is_friend
&& !have_def
)
3215 /* This is not really a declaration of a specialization.
3216 It's just the name of an instantiation. But, it's not
3217 a request for an instantiation, either. */
3218 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
3219 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3220 /* A specialization is not necessarily COMDAT. */
3221 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
3222 && DECL_DECLARED_INLINE_P (decl
));
3223 else if (VAR_P (decl
))
3224 DECL_COMDAT (decl
) = false;
3226 /* If this is a full specialization, register it so that we can find
3227 it again. Partial specializations will be registered in
3228 process_partial_specialization. */
3229 if (!processing_template_decl
)
3231 warn_spec_missing_attributes (gen_tmpl
, decl
, attrlist
);
3233 decl
= register_specialization (decl
, gen_tmpl
, targs
,
3238 /* A 'structor should already have clones. */
3239 gcc_assert (decl
== error_mark_node
3240 || variable_template_p (tmpl
)
3241 || !(DECL_CONSTRUCTOR_P (decl
)
3242 || DECL_DESTRUCTOR_P (decl
))
3243 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
3250 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3251 parameters. These are represented in the same format used for
3252 DECL_TEMPLATE_PARMS. */
3255 comp_template_parms (const_tree parms1
, const_tree parms2
)
3260 if (parms1
== parms2
)
3263 for (p1
= parms1
, p2
= parms2
;
3264 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
3265 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
3267 tree t1
= TREE_VALUE (p1
);
3268 tree t2
= TREE_VALUE (p2
);
3271 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
3272 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
3274 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3277 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
3279 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
3280 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
3282 /* If either of the template parameters are invalid, assume
3283 they match for the sake of error recovery. */
3284 if (error_operand_p (parm1
) || error_operand_p (parm2
))
3287 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
3290 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
3291 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
3292 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
3294 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
3299 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
3300 /* One set of parameters has more parameters lists than the
3307 /* Returns true if two template parameters are declared with
3308 equivalent constraints. */
3311 template_parameter_constraints_equivalent_p (const_tree parm1
, const_tree parm2
)
3313 tree req1
= TREE_TYPE (parm1
);
3314 tree req2
= TREE_TYPE (parm2
);
3318 return cp_tree_equal (req1
, req2
);
3322 /* Returns true when two template parameters are equivalent. */
3325 template_parameters_equivalent_p (const_tree parm1
, const_tree parm2
)
3327 tree decl1
= TREE_VALUE (parm1
);
3328 tree decl2
= TREE_VALUE (parm2
);
3330 /* If either of the template parameters are invalid, assume
3331 they match for the sake of error recovery. */
3332 if (error_operand_p (decl1
) || error_operand_p (decl2
))
3335 /* ... they declare parameters of the same kind. */
3336 if (TREE_CODE (decl1
) != TREE_CODE (decl2
))
3339 /* ... one parameter was introduced by a parameter declaration, then
3340 both are. This case arises as a result of eagerly rewriting declarations
3342 if (DECL_VIRTUAL_P (decl1
) != DECL_VIRTUAL_P (decl2
))
3345 /* ... if either declares a pack, they both do. */
3346 if (template_parameter_pack_p (decl1
) != template_parameter_pack_p (decl2
))
3349 if (TREE_CODE (decl1
) == PARM_DECL
)
3351 /* ... if they declare non-type parameters, the types are equivalent. */
3352 if (!same_type_p (TREE_TYPE (decl1
), TREE_TYPE (decl2
)))
3355 else if (TREE_CODE (decl2
) == TEMPLATE_DECL
)
3357 /* ... if they declare template template parameters, their template
3358 parameter lists are equivalent. */
3359 if (!template_heads_equivalent_p (decl1
, decl2
))
3363 /* ... if they are declared with a qualified-concept name, they both
3364 are, and those names are equivalent. */
3365 return template_parameter_constraints_equivalent_p (parm1
, parm2
);
3368 /* Returns true if two template parameters lists are equivalent.
3369 Two template parameter lists are equivalent if they have the
3370 same length and their corresponding parameters are equivalent.
3372 PARMS1 and PARMS2 are TREE_LISTs containing TREE_VECs: the
3373 data structure returned by DECL_TEMPLATE_PARMS.
3375 This is generally the same implementation as comp_template_parms
3376 except that it also the concept names and arguments used to
3377 introduce parameters. */
3380 template_parameter_lists_equivalent_p (const_tree parms1
, const_tree parms2
)
3382 if (parms1
== parms2
)
3385 const_tree p1
= parms1
;
3386 const_tree p2
= parms2
;
3387 while (p1
!= NULL_TREE
&& p2
!= NULL_TREE
)
3389 tree list1
= TREE_VALUE (p1
);
3390 tree list2
= TREE_VALUE (p2
);
3392 if (TREE_VEC_LENGTH (list1
) != TREE_VEC_LENGTH (list2
))
3395 for (int i
= 0; i
< TREE_VEC_LENGTH (list2
); ++i
)
3397 tree parm1
= TREE_VEC_ELT (list1
, i
);
3398 tree parm2
= TREE_VEC_ELT (list2
, i
);
3399 if (!template_parameters_equivalent_p (parm1
, parm2
))
3403 p1
= TREE_CHAIN (p1
);
3404 p2
= TREE_CHAIN (p2
);
3407 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
3413 /* Return true if the requires-clause of the template parameter lists are
3414 equivalent and false otherwise. */
3416 template_requirements_equivalent_p (const_tree parms1
, const_tree parms2
)
3418 tree req1
= TEMPLATE_PARMS_CONSTRAINTS (parms1
);
3419 tree req2
= TEMPLATE_PARMS_CONSTRAINTS (parms2
);
3420 if ((req1
!= NULL_TREE
) != (req2
!= NULL_TREE
))
3422 if (!cp_tree_equal (req1
, req2
))
3427 /* Returns true if two template heads are equivalent. 17.6.6.1p6:
3428 Two template heads are equivalent if their template parameter
3429 lists are equivalent and their requires clauses are equivalent.
3431 In pre-C++20, this is equivalent to calling comp_template_parms
3432 for the template parameters of TMPL1 and TMPL2. */
3435 template_heads_equivalent_p (const_tree tmpl1
, const_tree tmpl2
)
3437 tree parms1
= DECL_TEMPLATE_PARMS (tmpl1
);
3438 tree parms2
= DECL_TEMPLATE_PARMS (tmpl2
);
3440 /* Don't change the matching rules for pre-C++20. */
3441 if (cxx_dialect
< cxx2a
)
3442 return comp_template_parms (parms1
, parms2
);
3444 /* ... have the same number of template parameters, and their
3445 corresponding parameters are equivalent. */
3446 if (!template_parameter_lists_equivalent_p (parms1
, parms2
))
3449 /* ... if either has a requires-clause, they both do and their
3450 corresponding constraint-expressions are equivalent. */
3451 return template_requirements_equivalent_p (parms1
, parms2
);
3454 /* Determine whether PARM is a parameter pack. */
3457 template_parameter_pack_p (const_tree parm
)
3459 /* Determine if we have a non-type template parameter pack. */
3460 if (TREE_CODE (parm
) == PARM_DECL
)
3461 return (DECL_TEMPLATE_PARM_P (parm
)
3462 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
3463 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
3464 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
3466 /* If this is a list of template parameters, we could get a
3467 TYPE_DECL or a TEMPLATE_DECL. */
3468 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
3469 parm
= TREE_TYPE (parm
);
3471 /* Otherwise it must be a type template parameter. */
3472 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
3473 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
3474 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
3477 /* Determine if T is a function parameter pack. */
3480 function_parameter_pack_p (const_tree t
)
3482 if (t
&& TREE_CODE (t
) == PARM_DECL
)
3483 return DECL_PACK_P (t
);
3487 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3488 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3491 get_function_template_decl (const_tree primary_func_tmpl_inst
)
3493 if (! primary_func_tmpl_inst
3494 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
3495 || ! primary_template_specialization_p (primary_func_tmpl_inst
))
3498 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
3501 /* Return true iff the function parameter PARAM_DECL was expanded
3502 from the function parameter pack PACK. */
3505 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
3507 if (DECL_ARTIFICIAL (param_decl
)
3508 || !function_parameter_pack_p (pack
))
3511 /* The parameter pack and its pack arguments have the same
3513 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
3516 /* Determine whether ARGS describes a variadic template args list,
3517 i.e., one that is terminated by a template argument pack. */
3520 template_args_variadic_p (tree args
)
3525 if (args
== NULL_TREE
)
3528 args
= INNERMOST_TEMPLATE_ARGS (args
);
3529 nargs
= TREE_VEC_LENGTH (args
);
3534 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
3536 return ARGUMENT_PACK_P (last_parm
);
3539 /* Generate a new name for the parameter pack name NAME (an
3540 IDENTIFIER_NODE) that incorporates its */
3543 make_ith_pack_parameter_name (tree name
, int i
)
3545 /* Munge the name to include the parameter index. */
3546 #define NUMBUF_LEN 128
3547 char numbuf
[NUMBUF_LEN
];
3551 if (name
== NULL_TREE
)
3553 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
3554 newname_len
= IDENTIFIER_LENGTH (name
)
3555 + strlen (numbuf
) + 2;
3556 newname
= (char*)alloca (newname_len
);
3557 snprintf (newname
, newname_len
,
3558 "%s#%i", IDENTIFIER_POINTER (name
), i
);
3559 return get_identifier (newname
);
3562 /* Return true if T is a primary function, class or alias template
3563 specialization, not including the template pattern. */
3566 primary_template_specialization_p (const_tree t
)
3571 if (TREE_CODE (t
) == FUNCTION_DECL
|| VAR_P (t
))
3572 return (DECL_LANG_SPECIFIC (t
)
3573 && DECL_USE_TEMPLATE (t
)
3574 && DECL_TEMPLATE_INFO (t
)
3575 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)));
3576 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3577 return (CLASSTYPE_TEMPLATE_INFO (t
)
3578 && CLASSTYPE_USE_TEMPLATE (t
)
3579 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
3580 else if (alias_template_specialization_p (t
, nt_transparent
))
3585 /* Return true if PARM is a template template parameter. */
3588 template_template_parameter_p (const_tree parm
)
3590 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3593 /* Return true iff PARM is a DECL representing a type template
3597 template_type_parameter_p (const_tree parm
)
3600 && (TREE_CODE (parm
) == TYPE_DECL
3601 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3602 && DECL_TEMPLATE_PARM_P (parm
));
3605 /* Return the template parameters of T if T is a
3606 primary template instantiation, NULL otherwise. */
3609 get_primary_template_innermost_parameters (const_tree t
)
3611 tree parms
= NULL
, template_info
= NULL
;
3613 if ((template_info
= get_template_info (t
))
3614 && primary_template_specialization_p (t
))
3615 parms
= INNERMOST_TEMPLATE_PARMS
3616 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3621 /* Return the template parameters of the LEVELth level from the full list
3622 of template parameters PARMS. */
3625 get_template_parms_at_level (tree parms
, int level
)
3629 || TREE_CODE (parms
) != TREE_LIST
3630 || level
> TMPL_PARMS_DEPTH (parms
))
3633 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3634 if (TMPL_PARMS_DEPTH (p
) == level
)
3640 /* Returns the template arguments of T if T is a template instantiation,
3644 get_template_innermost_arguments (const_tree t
)
3646 tree args
= NULL
, template_info
= NULL
;
3648 if ((template_info
= get_template_info (t
))
3649 && TI_ARGS (template_info
))
3650 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3655 /* Return the argument pack elements of T if T is a template argument pack,
3659 get_template_argument_pack_elems (const_tree t
)
3661 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3662 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3665 return ARGUMENT_PACK_ARGS (t
);
3668 /* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the
3669 ARGUMENT_PACK_SELECT represents. */
3672 argument_pack_select_arg (tree t
)
3674 tree args
= ARGUMENT_PACK_ARGS (ARGUMENT_PACK_SELECT_FROM_PACK (t
));
3675 tree arg
= TREE_VEC_ELT (args
, ARGUMENT_PACK_SELECT_INDEX (t
));
3677 /* If the selected argument is an expansion E, that most likely means we were
3678 called from gen_elem_of_pack_expansion_instantiation during the
3679 substituting of an argument pack (of which the Ith element is a pack
3680 expansion, where I is ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
3681 In this case, the Ith element resulting from this substituting is going to
3682 be a pack expansion, which pattern is the pattern of E. Let's return the
3683 pattern of E, and gen_elem_of_pack_expansion_instantiation will build the
3684 resulting pack expansion from it. */
3685 if (PACK_EXPANSION_P (arg
))
3687 /* Make sure we aren't throwing away arg info. */
3688 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
3689 arg
= PACK_EXPANSION_PATTERN (arg
);
3696 /* True iff FN is a function representing a built-in variadic parameter
3700 builtin_pack_fn_p (tree fn
)
3703 || TREE_CODE (fn
) != FUNCTION_DECL
3704 || !DECL_IS_BUILTIN (fn
))
3707 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3713 /* True iff CALL is a call to a function representing a built-in variadic
3717 builtin_pack_call_p (tree call
)
3719 if (TREE_CODE (call
) != CALL_EXPR
)
3721 return builtin_pack_fn_p (CALL_EXPR_FN (call
));
3724 /* Return a TREE_VEC for the expansion of __integer_pack(HI). */
3727 expand_integer_pack (tree call
, tree args
, tsubst_flags_t complain
,
3730 tree ohi
= CALL_EXPR_ARG (call
, 0);
3731 tree hi
= tsubst_copy_and_build (ohi
, args
, complain
, in_decl
,
3732 false/*fn*/, true/*int_cst*/);
3734 if (value_dependent_expression_p (hi
))
3738 call
= copy_node (call
);
3739 CALL_EXPR_ARG (call
, 0) = hi
;
3741 tree ex
= make_pack_expansion (call
, complain
);
3742 tree vec
= make_tree_vec (1);
3743 TREE_VEC_ELT (vec
, 0) = ex
;
3748 hi
= cxx_constant_value (hi
);
3749 int len
= valid_constant_size_p (hi
) ? tree_to_shwi (hi
) : -1;
3751 /* Calculate the largest value of len that won't make the size of the vec
3752 overflow an int. The compiler will exceed resource limits long before
3753 this, but it seems a decent place to diagnose. */
3754 int max
= ((INT_MAX
- sizeof (tree_vec
)) / sizeof (tree
)) + 1;
3756 if (len
< 0 || len
> max
)
3758 if ((complain
& tf_error
)
3759 && hi
!= error_mark_node
)
3760 error ("argument to %<__integer_pack%> must be between 0 and %d",
3762 return error_mark_node
;
3765 tree vec
= make_tree_vec (len
);
3767 for (int i
= 0; i
< len
; ++i
)
3768 TREE_VEC_ELT (vec
, i
) = size_int (i
);
3774 /* Return a TREE_VEC for the expansion of built-in template parameter pack
3778 expand_builtin_pack_call (tree call
, tree args
, tsubst_flags_t complain
,
3781 if (!builtin_pack_call_p (call
))
3784 tree fn
= CALL_EXPR_FN (call
);
3786 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3787 return expand_integer_pack (call
, args
, complain
, in_decl
);
3792 /* Structure used to track the progress of find_parameter_packs_r. */
3793 struct find_parameter_pack_data
3795 /* TREE_LIST that will contain all of the parameter packs found by
3797 tree
* parameter_packs
;
3799 /* Set of AST nodes that have been visited by the traversal. */
3800 hash_set
<tree
> *visited
;
3802 /* True iff we're making a type pack expansion. */
3803 bool type_pack_expansion_p
;
3806 /* Identifies all of the argument packs that occur in a template
3807 argument and appends them to the TREE_LIST inside DATA, which is a
3808 find_parameter_pack_data structure. This is a subroutine of
3809 make_pack_expansion and uses_parameter_packs. */
3811 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3814 struct find_parameter_pack_data
* ppd
=
3815 (struct find_parameter_pack_data
*)data
;
3816 bool parameter_pack_p
= false;
3818 /* Handle type aliases/typedefs. */
3819 if (TYPE_ALIAS_P (t
))
3821 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
3822 cp_walk_tree (&TI_ARGS (tinfo
),
3823 &find_parameter_packs_r
,
3829 /* Identify whether this is a parameter pack or not. */
3830 switch (TREE_CODE (t
))
3832 case TEMPLATE_PARM_INDEX
:
3833 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3834 parameter_pack_p
= true;
3837 case TEMPLATE_TYPE_PARM
:
3838 t
= TYPE_MAIN_VARIANT (t
);
3840 case TEMPLATE_TEMPLATE_PARM
:
3841 /* If the placeholder appears in the decl-specifier-seq of a function
3842 parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3843 is a pack expansion, the invented template parameter is a template
3845 if (ppd
->type_pack_expansion_p
&& is_auto (t
))
3846 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
3847 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3848 parameter_pack_p
= true;
3853 if (DECL_PACK_P (t
))
3855 /* We don't want to walk into the type of a PARM_DECL,
3856 because we don't want to see the type parameter pack. */
3858 parameter_pack_p
= true;
3863 if (DECL_PACK_P (t
))
3865 /* We don't want to walk into the type of a variadic capture proxy,
3866 because we don't want to see the type parameter pack. */
3868 parameter_pack_p
= true;
3870 else if (variable_template_specialization_p (t
))
3872 cp_walk_tree (&DECL_TI_ARGS (t
),
3873 find_parameter_packs_r
,
3880 if (builtin_pack_call_p (t
))
3881 parameter_pack_p
= true;
3885 parameter_pack_p
= true;
3888 /* Not a parameter pack. */
3892 if (parameter_pack_p
)
3894 /* Add this parameter pack to the list. */
3895 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3899 cp_walk_tree (&TYPE_CONTEXT (t
),
3900 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3902 /* This switch statement will return immediately if we don't find a
3904 switch (TREE_CODE (t
))
3906 case TEMPLATE_PARM_INDEX
:
3909 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3910 /* Check the template itself. */
3911 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3912 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3913 /* Check the template arguments. */
3914 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3919 case TEMPLATE_TYPE_PARM
:
3920 case TEMPLATE_TEMPLATE_PARM
:
3927 /* Ignore the declaration of a capture proxy for a parameter pack. */
3928 if (is_capture_proxy (DECL_EXPR_DECL (t
)))
3933 if (TYPE_PTRMEMFUNC_P (t
))
3939 if (TYPE_TEMPLATE_INFO (t
))
3940 cp_walk_tree (&TYPE_TI_ARGS (t
),
3941 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3947 if (!DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
3952 cp_walk_tree (&TREE_TYPE (t
),
3953 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3957 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3962 case TYPE_PACK_EXPANSION
:
3963 case EXPR_PACK_EXPANSION
:
3968 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3973 case IDENTIFIER_NODE
:
3974 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3981 /* Look at explicit captures. */
3982 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
);
3983 cap
; cap
= TREE_CHAIN (cap
))
3984 cp_walk_tree (&TREE_VALUE (cap
), &find_parameter_packs_r
, ppd
,
3986 /* Since we defer implicit capture, look in the parms and body. */
3987 tree fn
= lambda_function (t
);
3988 cp_walk_tree (&TREE_TYPE (fn
), &find_parameter_packs_r
, ppd
,
3990 cp_walk_tree (&DECL_SAVED_TREE (fn
), &find_parameter_packs_r
, ppd
,
3998 /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
3999 type_pack_expansion_p to false so that any placeholders
4000 within the expression don't get marked as parameter packs. */
4001 bool type_pack_expansion_p
= ppd
->type_pack_expansion_p
;
4002 ppd
->type_pack_expansion_p
= false;
4003 cp_walk_tree (&DECLTYPE_TYPE_EXPR (t
), &find_parameter_packs_r
,
4005 ppd
->type_pack_expansion_p
= type_pack_expansion_p
;
4011 cp_walk_tree (&IF_COND (t
), &find_parameter_packs_r
,
4013 cp_walk_tree (&THEN_CLAUSE (t
), &find_parameter_packs_r
,
4015 cp_walk_tree (&ELSE_CLAUSE (t
), &find_parameter_packs_r
,
4017 /* Don't walk into IF_STMT_EXTRA_ARGS. */
4028 /* Determines if the expression or type T uses any parameter packs. */
4030 uses_parameter_packs (tree t
)
4032 tree parameter_packs
= NULL_TREE
;
4033 struct find_parameter_pack_data ppd
;
4034 ppd
.parameter_packs
= ¶meter_packs
;
4035 ppd
.visited
= new hash_set
<tree
>;
4036 ppd
.type_pack_expansion_p
= false;
4037 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
4039 return parameter_packs
;
4042 /* Turn ARG, which may be an expression, type, or a TREE_LIST
4043 representation a base-class initializer into a parameter pack
4044 expansion. If all goes well, the resulting node will be an
4045 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
4048 make_pack_expansion (tree arg
, tsubst_flags_t complain
)
4051 tree parameter_packs
= NULL_TREE
;
4052 bool for_types
= false;
4053 struct find_parameter_pack_data ppd
;
4055 if (!arg
|| arg
== error_mark_node
)
4058 if (TREE_CODE (arg
) == TREE_LIST
&& TREE_PURPOSE (arg
))
4060 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
4061 class initializer. In this case, the TREE_PURPOSE will be a
4062 _TYPE node (representing the base class expansion we're
4063 initializing) and the TREE_VALUE will be a TREE_LIST
4064 containing the initialization arguments.
4066 The resulting expansion looks somewhat different from most
4067 expansions. Rather than returning just one _EXPANSION, we
4068 return a TREE_LIST whose TREE_PURPOSE is a
4069 TYPE_PACK_EXPANSION containing the bases that will be
4070 initialized. The TREE_VALUE will be identical to the
4071 original TREE_VALUE, which is a list of arguments that will
4072 be passed to each base. We do not introduce any new pack
4073 expansion nodes into the TREE_VALUE (although it is possible
4074 that some already exist), because the TREE_PURPOSE and
4075 TREE_VALUE all need to be expanded together with the same
4076 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
4077 resulting TREE_PURPOSE will mention the parameter packs in
4078 both the bases and the arguments to the bases. */
4081 tree parameter_packs
= NULL_TREE
;
4083 /* Determine which parameter packs will be used by the base
4085 ppd
.visited
= new hash_set
<tree
>;
4086 ppd
.parameter_packs
= ¶meter_packs
;
4087 ppd
.type_pack_expansion_p
= false;
4088 gcc_assert (TYPE_P (TREE_PURPOSE (arg
)));
4089 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
4092 if (parameter_packs
== NULL_TREE
)
4094 if (complain
& tf_error
)
4095 error ("base initializer expansion %qT contains no parameter packs",
4098 return error_mark_node
;
4101 if (TREE_VALUE (arg
) != void_type_node
)
4103 /* Collect the sets of parameter packs used in each of the
4104 initialization arguments. */
4105 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
4107 /* Determine which parameter packs will be expanded in this
4109 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
4116 /* Create the pack expansion type for the base type. */
4117 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
4118 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
4119 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
4120 PACK_EXPANSION_LOCAL_P (purpose
) = at_function_scope_p ();
4122 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
4123 they will rarely be compared to anything. */
4124 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
4126 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
4129 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
4132 /* Build the PACK_EXPANSION_* node. */
4134 ? cxx_make_type (TYPE_PACK_EXPANSION
)
4135 : make_node (EXPR_PACK_EXPANSION
);
4136 SET_PACK_EXPANSION_PATTERN (result
, arg
);
4137 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
4139 /* Propagate type and const-expression information. */
4140 TREE_TYPE (result
) = TREE_TYPE (arg
);
4141 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
4142 /* Mark this read now, since the expansion might be length 0. */
4143 mark_exp_read (arg
);
4146 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
4147 they will rarely be compared to anything. */
4148 SET_TYPE_STRUCTURAL_EQUALITY (result
);
4150 /* Determine which parameter packs will be expanded. */
4151 ppd
.parameter_packs
= ¶meter_packs
;
4152 ppd
.visited
= new hash_set
<tree
>;
4153 ppd
.type_pack_expansion_p
= TYPE_P (arg
);
4154 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
4157 /* Make sure we found some parameter packs. */
4158 if (parameter_packs
== NULL_TREE
)
4160 if (complain
& tf_error
)
4163 error ("expansion pattern %qT contains no parameter packs", arg
);
4165 error ("expansion pattern %qE contains no parameter packs", arg
);
4167 return error_mark_node
;
4169 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
4171 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
4176 /* Checks T for any "bare" parameter packs, which have not yet been
4177 expanded, and issues an error if any are found. This operation can
4178 only be done on full expressions or types (e.g., an expression
4179 statement, "if" condition, etc.), because we could have expressions like:
4181 foo(f(g(h(args)))...)
4183 where "args" is a parameter pack. check_for_bare_parameter_packs
4184 should not be called for the subexpressions args, h(args),
4185 g(h(args)), or f(g(h(args))), because we would produce erroneous
4188 Returns TRUE and emits an error if there were bare parameter packs,
4189 returns FALSE otherwise. */
4191 check_for_bare_parameter_packs (tree t
, location_t loc
/* = UNKNOWN_LOCATION */)
4193 tree parameter_packs
= NULL_TREE
;
4194 struct find_parameter_pack_data ppd
;
4196 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
4199 /* A lambda might use a parameter pack from the containing context. */
4200 if (current_class_type
&& LAMBDA_TYPE_P (current_class_type
)
4201 && CLASSTYPE_TEMPLATE_INFO (current_class_type
))
4204 if (TREE_CODE (t
) == TYPE_DECL
)
4207 ppd
.parameter_packs
= ¶meter_packs
;
4208 ppd
.visited
= new hash_set
<tree
>;
4209 ppd
.type_pack_expansion_p
= false;
4210 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
4213 if (parameter_packs
)
4215 if (loc
== UNKNOWN_LOCATION
)
4216 loc
= cp_expr_loc_or_input_loc (t
);
4217 error_at (loc
, "parameter packs not expanded with %<...%>:");
4218 while (parameter_packs
)
4220 tree pack
= TREE_VALUE (parameter_packs
);
4221 tree name
= NULL_TREE
;
4223 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
4224 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
4225 name
= TYPE_NAME (pack
);
4226 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
4227 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
4228 else if (TREE_CODE (pack
) == CALL_EXPR
)
4229 name
= DECL_NAME (CALL_EXPR_FN (pack
));
4231 name
= DECL_NAME (pack
);
4234 inform (loc
, " %qD", name
);
4236 inform (loc
, " %s", "<anonymous>");
4238 parameter_packs
= TREE_CHAIN (parameter_packs
);
4247 /* Expand any parameter packs that occur in the template arguments in
4250 expand_template_argument_pack (tree args
)
4252 if (args
== error_mark_node
)
4253 return error_mark_node
;
4255 tree result_args
= NULL_TREE
;
4256 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
4257 int num_result_args
= -1;
4258 int non_default_args_count
= -1;
4260 /* First, determine if we need to expand anything, and the number of
4261 slots we'll need. */
4262 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
4264 tree arg
= TREE_VEC_ELT (args
, in_arg
);
4265 if (arg
== NULL_TREE
)
4267 if (ARGUMENT_PACK_P (arg
))
4269 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
4270 if (num_result_args
< 0)
4271 num_result_args
= in_arg
+ num_packed
;
4273 num_result_args
+= num_packed
;
4277 if (num_result_args
>= 0)
4282 /* If no expansion is necessary, we're done. */
4283 if (num_result_args
< 0)
4286 /* Expand arguments. */
4287 result_args
= make_tree_vec (num_result_args
);
4288 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
4289 non_default_args_count
=
4290 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
4291 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
4293 tree arg
= TREE_VEC_ELT (args
, in_arg
);
4294 if (ARGUMENT_PACK_P (arg
))
4296 tree packed
= ARGUMENT_PACK_ARGS (arg
);
4297 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
4298 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
4299 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
4300 if (non_default_args_count
> 0)
4301 non_default_args_count
+= num_packed
- 1;
4305 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
4309 if (non_default_args_count
>= 0)
4310 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
4314 /* Checks if DECL shadows a template parameter.
4316 [temp.local]: A template-parameter shall not be redeclared within its
4317 scope (including nested scopes).
4319 Emits an error and returns TRUE if the DECL shadows a parameter,
4320 returns FALSE otherwise. */
4323 check_template_shadow (tree decl
)
4327 /* If we're not in a template, we can't possibly shadow a template
4329 if (!current_template_parms
)
4332 /* Figure out what we're shadowing. */
4333 decl
= OVL_FIRST (decl
);
4334 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
4336 /* If there's no previous binding for this name, we're not shadowing
4337 anything, let alone a template parameter. */
4341 /* If we're not shadowing a template parameter, we're done. Note
4342 that OLDDECL might be an OVERLOAD (or perhaps even an
4343 ERROR_MARK), so we can't just blithely assume it to be a _DECL
4345 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
4348 /* We check for decl != olddecl to avoid bogus errors for using a
4349 name inside a class. We check TPFI to avoid duplicate errors for
4350 inline member templates. */
4352 || (DECL_TEMPLATE_PARM_P (decl
)
4353 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
4356 /* Don't complain about the injected class name, as we've already
4357 complained about the class itself. */
4358 if (DECL_SELF_REFERENCE_P (decl
))
4361 if (DECL_TEMPLATE_PARM_P (decl
))
4362 error ("declaration of template parameter %q+D shadows "
4363 "template parameter", decl
);
4365 error ("declaration of %q+#D shadows template parameter", decl
);
4366 inform (DECL_SOURCE_LOCATION (olddecl
),
4367 "template parameter %qD declared here", olddecl
);
4371 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
4372 ORIG_LEVEL, DECL, and TYPE. */
4375 build_template_parm_index (int index
,
4381 tree t
= make_node (TEMPLATE_PARM_INDEX
);
4382 TEMPLATE_PARM_IDX (t
) = index
;
4383 TEMPLATE_PARM_LEVEL (t
) = level
;
4384 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
4385 TEMPLATE_PARM_DECL (t
) = decl
;
4386 TREE_TYPE (t
) = type
;
4387 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
4388 TREE_READONLY (t
) = TREE_READONLY (decl
);
4393 /* Find the canonical type parameter for the given template type
4394 parameter. Returns the canonical type parameter, which may be TYPE
4395 if no such parameter existed. */
4398 canonical_type_parameter (tree type
)
4401 int idx
= TEMPLATE_TYPE_IDX (type
);
4402 if (!canonical_template_parms
)
4403 vec_alloc (canonical_template_parms
, idx
+ 1);
4405 if (canonical_template_parms
->length () <= (unsigned) idx
)
4406 vec_safe_grow_cleared (canonical_template_parms
, idx
+ 1);
4408 list
= (*canonical_template_parms
)[idx
];
4409 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
4410 list
= TREE_CHAIN (list
);
4413 return TREE_VALUE (list
);
4416 (*canonical_template_parms
)[idx
]
4417 = tree_cons (NULL_TREE
, type
, (*canonical_template_parms
)[idx
]);
4422 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
4423 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
4424 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
4425 new one is created. */
4428 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
4429 tsubst_flags_t complain
)
4431 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
4432 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
4433 != TEMPLATE_PARM_LEVEL (index
) - levels
)
4434 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
4436 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
4438 tree decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
4439 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
),
4441 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
4442 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
4443 DECL_ARTIFICIAL (decl
) = 1;
4444 SET_DECL_TEMPLATE_PARM_P (decl
);
4446 tree tpi
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
4447 TEMPLATE_PARM_LEVEL (index
) - levels
,
4448 TEMPLATE_PARM_ORIG_LEVEL (index
),
4450 TEMPLATE_PARM_DESCENDANTS (index
) = tpi
;
4451 TEMPLATE_PARM_PARAMETER_PACK (tpi
)
4452 = TEMPLATE_PARM_PARAMETER_PACK (index
);
4454 /* Template template parameters need this. */
4456 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4458 inner
= build_decl (DECL_SOURCE_LOCATION (decl
),
4459 TYPE_DECL
, DECL_NAME (decl
), type
);
4460 DECL_TEMPLATE_RESULT (decl
) = inner
;
4461 DECL_ARTIFICIAL (inner
) = true;
4462 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
4463 (DECL_TEMPLATE_PARMS (orig_decl
), args
, complain
);
4466 /* Attach the TPI to the decl. */
4467 if (TREE_CODE (inner
) == TYPE_DECL
)
4468 TEMPLATE_TYPE_PARM_INDEX (type
) = tpi
;
4470 DECL_INITIAL (decl
) = tpi
;
4473 return TEMPLATE_PARM_DESCENDANTS (index
);
4476 /* Process information from new template parameter PARM and append it
4477 to the LIST being built. This new parameter is a non-type
4478 parameter iff IS_NON_TYPE is true. This new parameter is a
4479 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4483 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
4484 bool is_non_type
, bool is_parameter_pack
)
4489 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
4490 tree defval
= TREE_PURPOSE (parm
);
4491 tree constr
= TREE_TYPE (parm
);
4495 tree p
= tree_last (list
);
4497 if (p
&& TREE_VALUE (p
) != error_mark_node
)
4500 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
4501 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
4503 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
4511 parm
= TREE_VALUE (parm
);
4513 SET_DECL_TEMPLATE_PARM_P (parm
);
4515 if (TREE_TYPE (parm
) != error_mark_node
)
4519 The top-level cv-qualifiers on the template-parameter are
4520 ignored when determining its type. */
4521 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
4522 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
4523 TREE_TYPE (parm
) = error_mark_node
;
4524 else if (uses_parameter_packs (TREE_TYPE (parm
))
4525 && !is_parameter_pack
4526 /* If we're in a nested template parameter list, the template
4527 template parameter could be a parameter pack. */
4528 && processing_template_parmlist
== 1)
4530 /* This template parameter is not a parameter pack, but it
4531 should be. Complain about "bare" parameter packs. */
4532 check_for_bare_parameter_packs (TREE_TYPE (parm
));
4534 /* Recover by calling this a parameter pack. */
4535 is_parameter_pack
= true;
4539 /* A template parameter is not modifiable. */
4540 TREE_CONSTANT (parm
) = 1;
4541 TREE_READONLY (parm
) = 1;
4542 decl
= build_decl (parm_loc
,
4543 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
4544 TREE_CONSTANT (decl
) = 1;
4545 TREE_READONLY (decl
) = 1;
4546 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
4547 = build_template_parm_index (idx
, processing_template_decl
,
4548 processing_template_decl
,
4549 decl
, TREE_TYPE (parm
));
4551 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
4552 = is_parameter_pack
;
4557 parm
= TREE_VALUE (TREE_VALUE (parm
));
4559 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
4561 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
4562 /* This is for distinguishing between real templates and template
4563 template parameters */
4564 TREE_TYPE (parm
) = t
;
4565 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
4570 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
4571 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4572 decl
= build_decl (parm_loc
,
4573 TYPE_DECL
, parm
, t
);
4576 TYPE_NAME (t
) = decl
;
4577 TYPE_STUB_DECL (t
) = decl
;
4579 TEMPLATE_TYPE_PARM_INDEX (t
)
4580 = build_template_parm_index (idx
, processing_template_decl
,
4581 processing_template_decl
,
4582 decl
, TREE_TYPE (parm
));
4583 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
4584 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
4586 DECL_ARTIFICIAL (decl
) = 1;
4587 SET_DECL_TEMPLATE_PARM_P (decl
);
4589 /* Build requirements for the type/template parameter.
4590 This must be done after SET_DECL_TEMPLATE_PARM_P or
4591 process_template_parm could fail. */
4592 tree reqs
= finish_shorthand_constraint (parm
, constr
);
4594 decl
= pushdecl (decl
);
4598 /* Build the parameter node linking the parameter declaration,
4599 its default argument (if any), and its constraints (if any). */
4600 parm
= build_tree_list (defval
, parm
);
4601 TEMPLATE_PARM_CONSTRAINTS (parm
) = reqs
;
4603 return chainon (list
, parm
);
4606 /* The end of a template parameter list has been reached. Process the
4607 tree list into a parameter vector, converting each parameter into a more
4608 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4612 end_template_parm_list (tree parms
)
4616 tree saved_parmlist
= make_tree_vec (list_length (parms
));
4618 /* Pop the dummy parameter level and add the real one. */
4619 current_template_parms
= TREE_CHAIN (current_template_parms
);
4621 current_template_parms
4622 = tree_cons (size_int (processing_template_decl
),
4623 saved_parmlist
, current_template_parms
);
4625 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
4627 next
= TREE_CHAIN (parm
);
4628 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
4629 TREE_CHAIN (parm
) = NULL_TREE
;
4632 --processing_template_parmlist
;
4634 return saved_parmlist
;
4637 // Explicitly indicate the end of the template parameter list. We assume
4638 // that the current template parameters have been constructed and/or
4639 // managed explicitly, as when creating new template template parameters
4640 // from a shorthand constraint.
4642 end_template_parm_list ()
4644 --processing_template_parmlist
;
4647 /* end_template_decl is called after a template declaration is seen. */
4650 end_template_decl (void)
4652 reset_specialization ();
4654 if (! processing_template_decl
)
4657 /* This matches the pushlevel in begin_template_parm_list. */
4660 --processing_template_decl
;
4661 current_template_parms
= TREE_CHAIN (current_template_parms
);
4664 /* Takes a TREE_LIST representing a template parameter and convert it
4665 into an argument suitable to be passed to the type substitution
4666 functions. Note that If the TREE_LIST contains an error_mark
4667 node, the returned argument is error_mark_node. */
4670 template_parm_to_arg (tree t
)
4674 || TREE_CODE (t
) != TREE_LIST
)
4677 if (error_operand_p (TREE_VALUE (t
)))
4678 return error_mark_node
;
4682 if (TREE_CODE (t
) == TYPE_DECL
4683 || TREE_CODE (t
) == TEMPLATE_DECL
)
4687 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
4689 /* Turn this argument into a TYPE_ARGUMENT_PACK
4690 with a single element, which expands T. */
4691 tree vec
= make_tree_vec (1);
4693 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4695 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4697 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
4698 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4703 t
= DECL_INITIAL (t
);
4705 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
4707 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4708 with a single element, which expands T. */
4709 tree vec
= make_tree_vec (1);
4711 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4713 t
= convert_from_reference (t
);
4714 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4716 t
= make_node (NONTYPE_ARGUMENT_PACK
);
4717 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4720 t
= convert_from_reference (t
);
4725 /* Given a single level of template parameters (a TREE_VEC), return it
4726 as a set of template arguments. */
4729 template_parms_level_to_args (tree parms
)
4731 tree a
= copy_node (parms
);
4732 TREE_TYPE (a
) = NULL_TREE
;
4733 for (int i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
4734 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
4737 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
4742 /* Given a set of template parameters, return them as a set of template
4743 arguments. The template parameters are represented as a TREE_VEC, in
4744 the form documented in cp-tree.h for template arguments. */
4747 template_parms_to_args (tree parms
)
4750 tree args
= NULL_TREE
;
4751 int length
= TMPL_PARMS_DEPTH (parms
);
4754 /* If there is only one level of template parameters, we do not
4755 create a TREE_VEC of TREE_VECs. Instead, we return a single
4756 TREE_VEC containing the arguments. */
4758 args
= make_tree_vec (length
);
4760 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
4762 tree a
= template_parms_level_to_args (TREE_VALUE (header
));
4765 TREE_VEC_ELT (args
, --l
) = a
;
4773 /* Within the declaration of a template, return the currently active
4774 template parameters as an argument TREE_VEC. */
4777 current_template_args (void)
4779 return template_parms_to_args (current_template_parms
);
4782 /* Return the fully generic arguments for of TMPL, i.e. what
4783 current_template_args would be while parsing it. */
4786 generic_targs_for (tree tmpl
)
4788 if (tmpl
== NULL_TREE
)
4790 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
4791 || DECL_TEMPLATE_SPECIALIZATION (tmpl
))
4792 /* DECL_TEMPLATE_RESULT doesn't have the arguments we want. For a template
4793 template parameter, it has no TEMPLATE_INFO; for a partial
4794 specialization, it has the arguments for the primary template, and we
4795 want the arguments for the partial specialization. */;
4796 else if (tree result
= DECL_TEMPLATE_RESULT (tmpl
))
4797 if (tree ti
= get_template_info (result
))
4798 return TI_ARGS (ti
);
4799 return template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
));
4802 /* Update the declared TYPE by doing any lookups which were thought to be
4803 dependent, but are not now that we know the SCOPE of the declarator. */
4806 maybe_update_decl_type (tree orig_type
, tree scope
)
4808 tree type
= orig_type
;
4810 if (type
== NULL_TREE
)
4813 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4814 type
= TREE_TYPE (type
);
4816 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
4817 && dependent_type_p (type
)
4818 /* Don't bother building up the args in this case. */
4819 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
4821 /* tsubst in the args corresponding to the template parameters,
4822 including auto if present. Most things will be unchanged, but
4823 make_typename_type and tsubst_qualified_id will resolve
4824 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4825 tree args
= current_template_args ();
4826 tree auto_node
= type_uses_auto (type
);
4830 tree auto_vec
= make_tree_vec (1);
4831 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4832 args
= add_to_template_args (args
, auto_vec
);
4834 pushed
= push_scope (scope
);
4835 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4840 if (type
== error_mark_node
)
4843 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4845 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4848 type
= TYPE_NAME (type
);
4853 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4854 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4855 the new template is a member template. */
4858 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4860 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4861 SET_DECL_LANGUAGE (tmpl
, DECL_LANGUAGE (decl
));
4862 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4863 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4864 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4865 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4870 struct template_parm_data
4872 /* The level of the template parameters we are currently
4876 /* The index of the specialization argument we are currently
4880 /* An array whose size is the number of template parameters. The
4881 elements are nonzero if the parameter has been used in any one
4882 of the arguments processed so far. */
4885 /* An array whose size is the number of template arguments. The
4886 elements are nonzero if the argument makes use of template
4887 parameters of this level. */
4888 int* arg_uses_template_parms
;
4891 /* Subroutine of push_template_decl used to see if each template
4892 parameter in a partial specialization is used in the explicit
4893 argument list. If T is of the LEVEL given in DATA (which is
4894 treated as a template_parm_data*), then DATA->PARMS is marked
4898 mark_template_parm (tree t
, void* data
)
4902 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4904 template_parm_level_and_index (t
, &level
, &idx
);
4906 if (level
== tpd
->level
)
4908 tpd
->parms
[idx
] = 1;
4909 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4912 /* In C++17 the type of a non-type argument is a deduced context. */
4913 if (cxx_dialect
>= cxx17
4914 && TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4915 for_each_template_parm (TREE_TYPE (t
),
4916 &mark_template_parm
,
4919 /*include_nondeduced_p=*/false);
4921 /* Return zero so that for_each_template_parm will continue the
4922 traversal of the tree; we want to mark *every* template parm. */
4926 /* Process the partial specialization DECL. */
4929 process_partial_specialization (tree decl
)
4931 tree type
= TREE_TYPE (decl
);
4932 tree tinfo
= get_template_info (decl
);
4933 tree maintmpl
= TI_TEMPLATE (tinfo
);
4934 tree specargs
= TI_ARGS (tinfo
);
4935 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4936 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4939 int nargs
= TREE_VEC_LENGTH (inner_args
);
4942 bool did_error_intro
= false;
4943 struct template_parm_data tpd
;
4944 struct template_parm_data tpd2
;
4946 gcc_assert (current_template_parms
);
4948 /* A concept cannot be specialized. */
4949 if (flag_concepts
&& variable_concept_p (maintmpl
))
4951 error ("specialization of variable concept %q#D", maintmpl
);
4952 return error_mark_node
;
4955 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4956 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4958 /* We check that each of the template parameters given in the
4959 partial specialization is used in the argument list to the
4960 specialization. For example:
4962 template <class T> struct S;
4963 template <class T> struct S<T*>;
4965 The second declaration is OK because `T*' uses the template
4966 parameter T, whereas
4968 template <class T> struct S<int>;
4970 is no good. Even trickier is:
4981 The S2<T> declaration is actually invalid; it is a
4982 full-specialization. Of course,
4985 struct S2<T (*)(U)>;
4987 or some such would have been OK. */
4988 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4989 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4990 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4992 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4993 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4994 for (i
= 0; i
< nargs
; ++i
)
4996 tpd
.current_arg
= i
;
4997 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4998 &mark_template_parm
,
5001 /*include_nondeduced_p=*/false);
5003 for (i
= 0; i
< ntparms
; ++i
)
5004 if (tpd
.parms
[i
] == 0)
5006 /* One of the template parms was not used in a deduced context in the
5008 if (!did_error_intro
)
5010 error ("template parameters not deducible in "
5011 "partial specialization:");
5012 did_error_intro
= true;
5015 inform (input_location
, " %qD",
5016 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
5019 if (did_error_intro
)
5020 return error_mark_node
;
5022 /* [temp.class.spec]
5024 The argument list of the specialization shall not be identical to
5025 the implicit argument list of the primary template. */
5027 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl
)));
5028 if (comp_template_args (inner_args
, INNERMOST_TEMPLATE_ARGS (main_args
))
5030 || !strictly_subsumes (current_template_constraints (),
5031 inner_args
, maintmpl
)))
5034 error ("partial specialization %q+D does not specialize "
5035 "any template arguments; to define the primary template, "
5036 "remove the template argument list", decl
);
5038 error ("partial specialization %q+D does not specialize any "
5039 "template arguments and is not more constrained than "
5040 "the primary template; to define the primary template, "
5041 "remove the template argument list", decl
);
5042 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
5045 /* A partial specialization that replaces multiple parameters of the
5046 primary template with a pack expansion is less specialized for those
5048 if (nargs
< DECL_NTPARMS (maintmpl
))
5050 error ("partial specialization is not more specialized than the "
5051 "primary template because it replaces multiple parameters "
5052 "with a pack expansion");
5053 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
5054 /* Avoid crash in process_partial_specialization. */
5058 /* If we aren't in a dependent class, we can actually try deduction. */
5059 else if (tpd
.level
== 1
5060 /* FIXME we should be able to handle a partial specialization of a
5061 partial instantiation, but currently we can't (c++/41727). */
5062 && TMPL_ARGS_DEPTH (specargs
) == 1
5063 && !get_partial_spec_bindings (maintmpl
, maintmpl
, specargs
))
5065 auto_diagnostic_group d
;
5066 if (permerror (input_location
, "partial specialization %qD is not "
5067 "more specialized than", decl
))
5068 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template %qD",
5072 /* [temp.class.spec]
5074 A partially specialized non-type argument expression shall not
5075 involve template parameters of the partial specialization except
5076 when the argument expression is a simple identifier.
5078 The type of a template parameter corresponding to a specialized
5079 non-type argument shall not be dependent on a parameter of the
5082 Also, we verify that pack expansions only occur at the
5083 end of the argument list. */
5084 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
5086 for (i
= 0; i
< nargs
; ++i
)
5088 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
5089 tree arg
= TREE_VEC_ELT (inner_args
, i
);
5090 tree packed_args
= NULL_TREE
;
5093 if (ARGUMENT_PACK_P (arg
))
5095 /* Extract the arguments from the argument pack. We'll be
5096 iterating over these in the following loop. */
5097 packed_args
= ARGUMENT_PACK_ARGS (arg
);
5098 len
= TREE_VEC_LENGTH (packed_args
);
5101 for (j
= 0; j
< len
; j
++)
5104 /* Get the Jth argument in the parameter pack. */
5105 arg
= TREE_VEC_ELT (packed_args
, j
);
5107 if (PACK_EXPANSION_P (arg
))
5109 /* Pack expansions must come at the end of the
5111 if ((packed_args
&& j
< len
- 1)
5112 || (!packed_args
&& i
< nargs
- 1))
5114 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
5115 error ("parameter pack argument %qE must be at the "
5116 "end of the template argument list", arg
);
5118 error ("parameter pack argument %qT must be at the "
5119 "end of the template argument list", arg
);
5123 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
5124 /* We only care about the pattern. */
5125 arg
= PACK_EXPANSION_PATTERN (arg
);
5127 if (/* These first two lines are the `non-type' bit. */
5129 && TREE_CODE (arg
) != TEMPLATE_DECL
5130 /* This next two lines are the `argument expression is not just a
5131 simple identifier' condition and also the `specialized
5132 non-type argument' bit. */
5133 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
5134 && !((REFERENCE_REF_P (arg
)
5135 || TREE_CODE (arg
) == VIEW_CONVERT_EXPR
)
5136 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
5138 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
5139 || (packed_args
&& uses_template_parms (arg
)))
5140 error_at (cp_expr_loc_or_input_loc (arg
),
5141 "template argument %qE involves template "
5142 "parameter(s)", arg
);
5145 /* Look at the corresponding template parameter,
5146 marking which template parameters its type depends
5148 tree type
= TREE_TYPE (parm
);
5152 /* We haven't yet initialized TPD2. Do so now. */
5153 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
5154 /* The number of parameters here is the number in the
5155 main template, which, as checked in the assertion
5157 tpd2
.parms
= XALLOCAVEC (int, nargs
);
5159 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
5162 /* Mark the template parameters. But this time, we're
5163 looking for the template parameters of the main
5164 template, not in the specialization. */
5165 tpd2
.current_arg
= i
;
5166 tpd2
.arg_uses_template_parms
[i
] = 0;
5167 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
5168 for_each_template_parm (type
,
5169 &mark_template_parm
,
5172 /*include_nondeduced_p=*/false);
5174 if (tpd2
.arg_uses_template_parms
[i
])
5176 /* The type depended on some template parameters.
5177 If they are fully specialized in the
5178 specialization, that's OK. */
5181 for (j
= 0; j
< nargs
; ++j
)
5182 if (tpd2
.parms
[j
] != 0
5183 && tpd
.arg_uses_template_parms
[j
])
5186 error_n (input_location
, count
,
5187 "type %qT of template argument %qE depends "
5188 "on a template parameter",
5189 "type %qT of template argument %qE depends "
5190 "on template parameters",
5199 /* We should only get here once. */
5200 if (TREE_CODE (decl
) == TYPE_DECL
)
5201 gcc_assert (!COMPLETE_TYPE_P (type
));
5203 // Build the template decl.
5204 tree tmpl
= build_template_decl (decl
, current_template_parms
,
5205 DECL_MEMBER_TEMPLATE_P (maintmpl
));
5206 TREE_TYPE (tmpl
) = type
;
5207 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5208 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5209 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
5210 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
5212 /* Give template template parms a DECL_CONTEXT of the template
5213 for which they are a parameter. */
5214 for (i
= 0; i
< ntparms
; ++i
)
5216 tree parm
= TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
));
5217 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5218 DECL_CONTEXT (parm
) = tmpl
;
5222 /* We didn't register this in check_explicit_specialization so we could
5223 wait until the constraints were set. */
5224 decl
= register_specialization (decl
, maintmpl
, specargs
, false, 0);
5226 associate_classtype_constraints (type
);
5228 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
5229 = tree_cons (specargs
, tmpl
,
5230 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
5231 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
5233 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
5234 inst
= TREE_CHAIN (inst
))
5236 tree instance
= TREE_VALUE (inst
);
5237 if (TYPE_P (instance
)
5238 ? (COMPLETE_TYPE_P (instance
)
5239 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance
))
5240 : DECL_TEMPLATE_INSTANTIATION (instance
))
5242 tree spec
= most_specialized_partial_spec (instance
, tf_none
);
5243 tree inst_decl
= (DECL_P (instance
)
5244 ? instance
: TYPE_NAME (instance
));
5247 else if (spec
== error_mark_node
)
5248 permerror (input_location
,
5249 "declaration of %qD ambiguates earlier template "
5250 "instantiation for %qD", decl
, inst_decl
);
5251 else if (TREE_VALUE (spec
) == tmpl
)
5252 permerror (input_location
,
5253 "partial specialization of %qD after instantiation "
5254 "of %qD", decl
, inst_decl
);
5261 /* PARM is a template parameter of some form; return the corresponding
5262 TEMPLATE_PARM_INDEX. */
5265 get_template_parm_index (tree parm
)
5267 if (TREE_CODE (parm
) == PARM_DECL
5268 || TREE_CODE (parm
) == CONST_DECL
)
5269 parm
= DECL_INITIAL (parm
);
5270 else if (TREE_CODE (parm
) == TYPE_DECL
5271 || TREE_CODE (parm
) == TEMPLATE_DECL
)
5272 parm
= TREE_TYPE (parm
);
5273 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
5274 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
5275 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
5276 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
5277 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
5281 /* Subroutine of fixed_parameter_pack_p below. Look for any template
5282 parameter packs used by the template parameter PARM. */
5285 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
5287 /* A type parm can't refer to another parm. */
5288 if (TREE_CODE (parm
) == TYPE_DECL
|| parm
== error_mark_node
)
5290 else if (TREE_CODE (parm
) == PARM_DECL
)
5292 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
5297 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
5299 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
5300 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
5302 tree p
= TREE_VALUE (TREE_VEC_ELT (vec
, i
));
5303 if (template_parameter_pack_p (p
))
5304 /* Any packs in the type are expanded by this parameter. */;
5306 fixed_parameter_pack_p_1 (p
, ppd
);
5310 /* PARM is a template parameter pack. Return any parameter packs used in
5311 its type or the type of any of its template parameters. If there are
5312 any such packs, it will be instantiated into a fixed template parameter
5313 list by partial instantiation rather than be fully deduced. */
5316 fixed_parameter_pack_p (tree parm
)
5318 /* This can only be true in a member template. */
5319 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
5321 /* This can only be true for a parameter pack. */
5322 if (!template_parameter_pack_p (parm
))
5324 /* A type parm can't refer to another parm. */
5325 if (TREE_CODE (parm
) == TYPE_DECL
)
5328 tree parameter_packs
= NULL_TREE
;
5329 struct find_parameter_pack_data ppd
;
5330 ppd
.parameter_packs
= ¶meter_packs
;
5331 ppd
.visited
= new hash_set
<tree
>;
5332 ppd
.type_pack_expansion_p
= false;
5334 fixed_parameter_pack_p_1 (parm
, &ppd
);
5337 return parameter_packs
;
5340 /* Check that a template declaration's use of default arguments and
5341 parameter packs is not invalid. Here, PARMS are the template
5342 parameters. IS_PRIMARY is true if DECL is the thing declared by
5343 a primary template. IS_PARTIAL is true if DECL is a partial
5346 IS_FRIEND_DECL is nonzero if DECL is either a non-defining friend
5347 function template declaration or a friend class template
5348 declaration. In the function case, 1 indicates a declaration, 2
5349 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
5350 emitted for extraneous default arguments.
5352 Returns TRUE if there were no errors found, FALSE otherwise. */
5355 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
5356 bool is_partial
, int is_friend_decl
)
5359 int last_level_to_check
;
5361 bool no_errors
= true;
5365 A default template-argument shall not be specified in a
5366 function template declaration or a function template definition, nor
5367 in the template-parameter-list of the definition of a member of a
5370 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
5371 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
5372 /* You can't have a function template declaration in a local
5373 scope, nor you can you define a member of a class template in a
5377 if ((TREE_CODE (decl
) == TYPE_DECL
5379 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5380 || (TREE_CODE (decl
) == FUNCTION_DECL
5381 && LAMBDA_FUNCTION_P (decl
)))
5382 /* A lambda doesn't have an explicit declaration; don't complain
5383 about the parms of the enclosing class. */
5386 if (current_class_type
5387 && !TYPE_BEING_DEFINED (current_class_type
)
5388 && DECL_LANG_SPECIFIC (decl
)
5389 && DECL_DECLARES_FUNCTION_P (decl
)
5390 /* If this is either a friend defined in the scope of the class
5391 or a member function. */
5392 && (DECL_FUNCTION_MEMBER_P (decl
)
5393 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
5394 : DECL_FRIEND_CONTEXT (decl
)
5395 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
5397 /* And, if it was a member function, it really was defined in
5398 the scope of the class. */
5399 && (!DECL_FUNCTION_MEMBER_P (decl
)
5400 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
5401 /* We already checked these parameters when the template was
5402 declared, so there's no need to do it again now. This function
5403 was defined in class scope, but we're processing its body now
5404 that the class is complete. */
5407 /* Core issue 226 (C++0x only): the following only applies to class
5410 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
5414 If a template-parameter has a default template-argument, all
5415 subsequent template-parameters shall have a default
5416 template-argument supplied. */
5417 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
5419 tree inner_parms
= TREE_VALUE (parm_level
);
5420 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
5421 int seen_def_arg_p
= 0;
5424 for (i
= 0; i
< ntparms
; ++i
)
5426 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
5428 if (parm
== error_mark_node
)
5431 if (TREE_PURPOSE (parm
))
5433 else if (seen_def_arg_p
5434 && !template_parameter_pack_p (TREE_VALUE (parm
)))
5436 error ("no default argument for %qD", TREE_VALUE (parm
));
5437 /* For better subsequent error-recovery, we indicate that
5438 there should have been a default argument. */
5439 TREE_PURPOSE (parm
) = error_mark_node
;
5442 else if (!is_partial
5444 /* Don't complain about an enclosing partial
5446 && parm_level
== parms
5447 && TREE_CODE (decl
) == TYPE_DECL
5449 && template_parameter_pack_p (TREE_VALUE (parm
))
5450 /* A fixed parameter pack will be partially
5451 instantiated into a fixed length list. */
5452 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
5454 /* A primary class template can only have one
5455 parameter pack, at the end of the template
5458 error ("parameter pack %q+D must be at the end of the"
5459 " template parameter list", TREE_VALUE (parm
));
5461 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
5469 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
5473 /* For an ordinary class template, default template arguments are
5474 allowed at the innermost level, e.g.:
5475 template <class T = int>
5477 but, in a partial specialization, they're not allowed even
5478 there, as we have in [temp.class.spec]:
5480 The template parameter list of a specialization shall not
5481 contain default template argument values.
5483 So, for a partial specialization, or for a function template
5484 (in C++98/C++03), we look at all of them. */
5487 /* But, for a primary class template that is not a partial
5488 specialization we look at all template parameters except the
5490 parms
= TREE_CHAIN (parms
);
5492 /* Figure out what error message to issue. */
5493 if (is_friend_decl
== 2)
5494 msg
= G_("default template arguments may not be used in function template "
5495 "friend re-declaration");
5496 else if (is_friend_decl
)
5497 msg
= G_("default template arguments may not be used in template "
5498 "friend declarations");
5499 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
5500 msg
= G_("default template arguments may not be used in function templates "
5501 "without %<-std=c++11%> or %<-std=gnu++11%>");
5502 else if (is_partial
)
5503 msg
= G_("default template arguments may not be used in "
5504 "partial specializations");
5505 else if (current_class_type
&& CLASSTYPE_IS_TEMPLATE (current_class_type
))
5506 msg
= G_("default argument for template parameter for class enclosing %qD");
5508 /* Per [temp.param]/9, "A default template-argument shall not be
5509 specified in the template-parameter-lists of the definition of
5510 a member of a class template that appears outside of the member's
5511 class.", thus if we aren't handling a member of a class template
5512 there is no need to examine the parameters. */
5515 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
5516 /* If we're inside a class definition, there's no need to
5517 examine the parameters to the class itself. On the one
5518 hand, they will be checked when the class is defined, and,
5519 on the other, default arguments are valid in things like:
5520 template <class T = double>
5521 struct S { template <class U> void f(U); };
5522 Here the default argument for `S' has no bearing on the
5523 declaration of `f'. */
5524 last_level_to_check
= template_class_depth (current_class_type
) + 1;
5526 /* Check everything. */
5527 last_level_to_check
= 0;
5529 for (parm_level
= parms
;
5530 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
5531 parm_level
= TREE_CHAIN (parm_level
))
5533 tree inner_parms
= TREE_VALUE (parm_level
);
5537 ntparms
= TREE_VEC_LENGTH (inner_parms
);
5538 for (i
= 0; i
< ntparms
; ++i
)
5540 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
5543 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
5548 if (is_friend_decl
== 2)
5555 /* Clear out the default argument so that we are not
5557 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
5561 /* At this point, if we're still interested in issuing messages,
5562 they must apply to classes surrounding the object declared. */
5564 msg
= G_("default argument for template parameter for class "
5571 /* Worker for push_template_decl_real, called via
5572 for_each_template_parm. DATA is really an int, indicating the
5573 level of the parameters we are interested in. If T is a template
5574 parameter of that level, return nonzero. */
5577 template_parm_this_level_p (tree t
, void* data
)
5579 int this_level
= *(int *)data
;
5582 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5583 level
= TEMPLATE_PARM_LEVEL (t
);
5585 level
= TEMPLATE_TYPE_LEVEL (t
);
5586 return level
== this_level
;
5589 /* Worker for uses_outer_template_parms, called via for_each_template_parm.
5590 DATA is really an int, indicating the innermost outer level of parameters.
5591 If T is a template parameter of that level or further out, return
5595 template_parm_outer_level (tree t
, void *data
)
5597 int this_level
= *(int *)data
;
5600 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5601 level
= TEMPLATE_PARM_LEVEL (t
);
5603 level
= TEMPLATE_TYPE_LEVEL (t
);
5604 return level
<= this_level
;
5607 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5608 parameters given by current_template_args, or reuses a
5609 previously existing one, if appropriate. Returns the DECL, or an
5610 equivalent one, if it is replaced via a call to duplicate_decls.
5612 If IS_FRIEND is true, DECL is a friend declaration. */
5615 push_template_decl_real (tree decl
, bool is_friend
)
5623 int new_template_p
= 0;
5624 /* True if the template is a member template, in the sense of
5626 bool member_template_p
= false;
5628 if (decl
== error_mark_node
|| !current_template_parms
)
5629 return error_mark_node
;
5631 /* See if this is a partial specialization. */
5632 is_partial
= ((DECL_IMPLICIT_TYPEDEF_P (decl
)
5633 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
5634 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
5636 && DECL_LANG_SPECIFIC (decl
)
5637 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5638 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
))));
5640 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
5644 /* For a friend, we want the context of the friend, not
5645 the type of which it is a friend. */
5646 ctx
= CP_DECL_CONTEXT (decl
);
5647 else if (CP_DECL_CONTEXT (decl
)
5648 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
5649 /* In the case of a virtual function, we want the class in which
5651 ctx
= CP_DECL_CONTEXT (decl
);
5653 /* Otherwise, if we're currently defining some class, the DECL
5654 is assumed to be a member of the class. */
5655 ctx
= current_scope ();
5657 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5660 if (!DECL_CONTEXT (decl
))
5661 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
5663 /* See if this is a primary template. */
5664 if (is_friend
&& ctx
5665 && uses_template_parms_level (ctx
, processing_template_decl
))
5666 /* A friend template that specifies a class context, i.e.
5667 template <typename T> friend void A<T>::f();
5670 else if (TREE_CODE (decl
) == TYPE_DECL
5671 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5674 is_primary
= template_parm_scope_p ();
5678 warning (OPT_Wtemplates
, "template %qD declared", decl
);
5680 if (DECL_CLASS_SCOPE_P (decl
))
5681 member_template_p
= true;
5682 if (TREE_CODE (decl
) == TYPE_DECL
5683 && IDENTIFIER_ANON_P (DECL_NAME (decl
)))
5685 error ("template class without a name");
5686 return error_mark_node
;
5688 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
5690 if (member_template_p
)
5692 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
5693 error ("member template %qD may not have virt-specifiers", decl
);
5695 if (DECL_DESTRUCTOR_P (decl
))
5699 A destructor shall not be a member template. */
5700 error_at (DECL_SOURCE_LOCATION (decl
),
5701 "destructor %qD declared as member template", decl
);
5702 return error_mark_node
;
5704 if (IDENTIFIER_NEWDEL_OP_P (DECL_NAME (decl
))
5705 && (!prototype_p (TREE_TYPE (decl
))
5706 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
5707 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5708 || (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5709 == void_list_node
)))
5711 /* [basic.stc.dynamic.allocation]
5713 An allocation function can be a function
5714 template. ... Template allocation functions shall
5715 have two or more parameters. */
5716 error ("invalid template declaration of %qD", decl
);
5717 return error_mark_node
;
5720 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5721 && CLASS_TYPE_P (TREE_TYPE (decl
)))
5723 /* Class template, set TEMPLATE_TYPE_PARM_FOR_CLASS. */
5724 tree parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
5725 for (int i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
5727 tree t
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5728 if (TREE_CODE (t
) == TYPE_DECL
)
5730 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
5731 TEMPLATE_TYPE_PARM_FOR_CLASS (t
) = true;
5734 else if (TREE_CODE (decl
) == TYPE_DECL
5735 && TYPE_DECL_ALIAS_P (decl
))
5736 /* alias-declaration */
5737 gcc_assert (!DECL_ARTIFICIAL (decl
));
5738 else if (VAR_P (decl
))
5739 /* C++14 variable template. */;
5740 else if (TREE_CODE (decl
) == CONCEPT_DECL
)
5741 /* C++2a concept definitions. */;
5744 error ("template declaration of %q#D", decl
);
5745 return error_mark_node
;
5749 /* Check to see that the rules regarding the use of default
5750 arguments are not being violated. We check args for a friend
5751 functions when we know whether it's a definition, introducing
5752 declaration or re-declaration. */
5753 if (!is_friend
|| TREE_CODE (decl
) != FUNCTION_DECL
)
5754 check_default_tmpl_args (decl
, current_template_parms
,
5755 is_primary
, is_partial
, is_friend
);
5757 /* Ensure that there are no parameter packs in the type of this
5758 declaration that have not been expanded. */
5759 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5761 /* Check each of the arguments individually to see if there are
5762 any bare parameter packs. */
5763 tree type
= TREE_TYPE (decl
);
5764 tree arg
= DECL_ARGUMENTS (decl
);
5765 tree argtype
= TYPE_ARG_TYPES (type
);
5767 while (arg
&& argtype
)
5769 if (!DECL_PACK_P (arg
)
5770 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
5772 /* This is a PARM_DECL that contains unexpanded parameter
5773 packs. We have already complained about this in the
5774 check_for_bare_parameter_packs call, so just replace
5775 these types with ERROR_MARK_NODE. */
5776 TREE_TYPE (arg
) = error_mark_node
;
5777 TREE_VALUE (argtype
) = error_mark_node
;
5780 arg
= DECL_CHAIN (arg
);
5781 argtype
= TREE_CHAIN (argtype
);
5784 /* Check for bare parameter packs in the return type and the
5785 exception specifiers. */
5786 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
5787 /* Errors were already issued, set return type to int
5788 as the frontend doesn't expect error_mark_node as
5790 TREE_TYPE (type
) = integer_type_node
;
5791 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
5792 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
5794 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
5795 && TYPE_DECL_ALIAS_P (decl
))
5796 ? DECL_ORIGINAL_TYPE (decl
)
5797 : TREE_TYPE (decl
)))
5799 TREE_TYPE (decl
) = error_mark_node
;
5800 return error_mark_node
;
5804 return process_partial_specialization (decl
);
5806 args
= current_template_args ();
5809 || TREE_CODE (ctx
) == FUNCTION_DECL
5810 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
5811 || (TREE_CODE (decl
) == TYPE_DECL
5812 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5813 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
5815 if (DECL_LANG_SPECIFIC (decl
)
5816 && DECL_TEMPLATE_INFO (decl
)
5817 && DECL_TI_TEMPLATE (decl
))
5818 tmpl
= DECL_TI_TEMPLATE (decl
);
5819 /* If DECL is a TYPE_DECL for a class-template, then there won't
5820 be DECL_LANG_SPECIFIC. The information equivalent to
5821 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5822 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5823 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
5824 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
5826 /* Since a template declaration already existed for this
5827 class-type, we must be redeclaring it here. Make sure
5828 that the redeclaration is valid. */
5829 redeclare_class_template (TREE_TYPE (decl
),
5830 current_template_parms
,
5831 current_template_constraints ());
5832 /* We don't need to create a new TEMPLATE_DECL; just use the
5833 one we already had. */
5834 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
5838 tmpl
= build_template_decl (decl
, current_template_parms
,
5842 if (DECL_LANG_SPECIFIC (decl
)
5843 && DECL_TEMPLATE_SPECIALIZATION (decl
))
5845 /* A specialization of a member template of a template
5847 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5848 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
5849 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
5855 tree a
, t
, current
, parms
;
5857 tree tinfo
= get_template_info (decl
);
5861 error ("template definition of non-template %q#D", decl
);
5862 return error_mark_node
;
5865 tmpl
= TI_TEMPLATE (tinfo
);
5867 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
5868 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
5869 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5870 && DECL_MEMBER_TEMPLATE_P (tmpl
))
5874 /* The declaration is a specialization of a member
5875 template, declared outside the class. Therefore, the
5876 innermost template arguments will be NULL, so we
5877 replace them with the arguments determined by the
5878 earlier call to check_explicit_specialization. */
5879 args
= DECL_TI_ARGS (decl
);
5882 = build_template_decl (decl
, current_template_parms
,
5884 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
5885 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
5886 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
5887 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
5888 DECL_TEMPLATE_INFO (new_tmpl
)
5889 = build_template_info (tmpl
, args
);
5891 register_specialization (new_tmpl
,
5892 most_general_template (tmpl
),
5898 /* Make sure the template headers we got make sense. */
5900 parms
= DECL_TEMPLATE_PARMS (tmpl
);
5901 i
= TMPL_PARMS_DEPTH (parms
);
5902 if (TMPL_ARGS_DEPTH (args
) != i
)
5904 error ("expected %d levels of template parms for %q#D, got %d",
5905 i
, decl
, TMPL_ARGS_DEPTH (args
));
5906 DECL_INTERFACE_KNOWN (decl
) = 1;
5907 return error_mark_node
;
5910 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
5912 a
= TMPL_ARGS_LEVEL (args
, i
);
5913 t
= INNERMOST_TEMPLATE_PARMS (parms
);
5915 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
5917 if (current
== decl
)
5918 error ("got %d template parameters for %q#D",
5919 TREE_VEC_LENGTH (a
), decl
);
5921 error ("got %d template parameters for %q#T",
5922 TREE_VEC_LENGTH (a
), current
);
5923 error (" but %d required", TREE_VEC_LENGTH (t
));
5924 /* Avoid crash in import_export_decl. */
5925 DECL_INTERFACE_KNOWN (decl
) = 1;
5926 return error_mark_node
;
5929 if (current
== decl
)
5931 else if (current
== NULL_TREE
)
5932 /* Can happen in erroneous input. */
5935 current
= get_containing_scope (current
);
5938 /* Check that the parms are used in the appropriate qualifying scopes
5939 in the declarator. */
5940 if (!comp_template_args
5942 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
5944 error ("template arguments to %qD do not match original "
5945 "template %qD", decl
, DECL_TEMPLATE_RESULT (tmpl
));
5946 if (!uses_template_parms (TI_ARGS (tinfo
)))
5947 inform (input_location
, "use %<template<>%> for"
5948 " an explicit specialization");
5949 /* Avoid crash in import_export_decl. */
5950 DECL_INTERFACE_KNOWN (decl
) = 1;
5951 return error_mark_node
;
5955 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5956 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5958 /* Push template declarations for global functions and types. Note
5959 that we do not try to push a global template friend declared in a
5960 template class; such a thing may well depend on the template
5961 parameters of the class. */
5962 if (new_template_p
&& !ctx
5963 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5965 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5966 if (tmpl
== error_mark_node
)
5967 return error_mark_node
;
5969 /* Hide template friend classes that haven't been declared yet. */
5970 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5972 DECL_ANTICIPATED (tmpl
) = 1;
5973 DECL_FRIEND_P (tmpl
) = 1;
5979 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5981 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5983 /* Give template template parms a DECL_CONTEXT of the template
5984 for which they are a parameter. */
5985 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5986 for (int i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5988 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5989 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5990 DECL_CONTEXT (parm
) = tmpl
;
5993 if (TREE_CODE (decl
) == TYPE_DECL
5994 && TYPE_DECL_ALIAS_P (decl
))
5997 = TEMPLATE_PARMS_CONSTRAINTS (DECL_TEMPLATE_PARMS (tmpl
)))
5999 /* ??? Why don't we do this here for all templates? */
6000 constr
= build_constraints (constr
, NULL_TREE
);
6001 set_constraints (decl
, constr
);
6003 if (complex_alias_template_p (tmpl
))
6004 TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl
) = true;
6008 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
6009 back to its most general template. If TMPL is a specialization,
6010 ARGS may only have the innermost set of arguments. Add the missing
6011 argument levels if necessary. */
6012 if (DECL_TEMPLATE_INFO (tmpl
))
6013 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
6015 info
= build_template_info (tmpl
, args
);
6017 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
6018 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
6022 retrofit_lang_decl (decl
);
6023 if (DECL_LANG_SPECIFIC (decl
))
6024 DECL_TEMPLATE_INFO (decl
) = info
;
6027 if (flag_implicit_templates
6029 && TREE_PUBLIC (decl
)
6030 && VAR_OR_FUNCTION_DECL_P (decl
))
6031 /* Set DECL_COMDAT on template instantiations; if we force
6032 them to be emitted by explicit instantiation,
6033 mark_needed will tell cgraph to do the right thing. */
6034 DECL_COMDAT (decl
) = true;
6036 return DECL_TEMPLATE_RESULT (tmpl
);
6040 push_template_decl (tree decl
)
6042 return push_template_decl_real (decl
, false);
6045 /* FN is an inheriting constructor that inherits from the constructor
6046 template INHERITED; turn FN into a constructor template with a matching
6050 add_inherited_template_parms (tree fn
, tree inherited
)
6053 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
6054 inner_parms
= copy_node (inner_parms
);
6056 = tree_cons (size_int (processing_template_decl
+ 1),
6057 inner_parms
, current_template_parms
);
6058 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
6059 tree args
= template_parms_to_args (parms
);
6060 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
6061 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
6062 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
6063 DECL_ARTIFICIAL (tmpl
) = true;
6064 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
6068 /* Called when a class template TYPE is redeclared with the indicated
6069 template PARMS, e.g.:
6071 template <class T> struct S;
6072 template <class T> struct S {}; */
6075 redeclare_class_template (tree type
, tree parms
, tree cons
)
6081 if (!TYPE_TEMPLATE_INFO (type
))
6083 error ("%qT is not a template type", type
);
6087 tmpl
= TYPE_TI_TEMPLATE (type
);
6088 if (!PRIMARY_TEMPLATE_P (tmpl
))
6089 /* The type is nested in some template class. Nothing to worry
6090 about here; there are no new template parameters for the nested
6096 error ("template specifiers not specified in declaration of %qD",
6101 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
6102 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
6104 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
6106 error_n (input_location
, TREE_VEC_LENGTH (parms
),
6107 "redeclared with %d template parameter",
6108 "redeclared with %d template parameters",
6109 TREE_VEC_LENGTH (parms
));
6110 inform_n (DECL_SOURCE_LOCATION (tmpl
), TREE_VEC_LENGTH (tmpl_parms
),
6111 "previous declaration %qD used %d template parameter",
6112 "previous declaration %qD used %d template parameters",
6113 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
6117 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
6124 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
6125 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
6128 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
6129 if (error_operand_p (tmpl_parm
))
6132 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
6133 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
6134 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
6136 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
6138 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
6139 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
6140 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
6141 || (TREE_CODE (tmpl_parm
) != PARM_DECL
6142 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
6143 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
6144 || (TREE_CODE (tmpl_parm
) == PARM_DECL
6145 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
6146 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
6148 error ("template parameter %q+#D", tmpl_parm
);
6149 error ("redeclared here as %q#D", parm
);
6153 /* The parameters can be declared to introduce different
6155 tree p1
= TREE_VEC_ELT (tmpl_parms
, i
);
6156 tree p2
= TREE_VEC_ELT (parms
, i
);
6157 if (!template_parameter_constraints_equivalent_p (p1
, p2
))
6159 error ("declaration of template parameter %q+#D with different "
6160 "constraints", parm
);
6161 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
6162 "original declaration appeared here");
6166 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
6168 /* We have in [temp.param]:
6170 A template-parameter may not be given default arguments
6171 by two different declarations in the same scope. */
6172 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
6173 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
6174 "original definition appeared here");
6178 if (parm_default
!= NULL_TREE
)
6179 /* Update the previous template parameters (which are the ones
6180 that will really count) with the new default value. */
6181 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
6182 else if (tmpl_default
!= NULL_TREE
)
6183 /* Update the new parameters, too; they'll be used as the
6184 parameters for any members. */
6185 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
6187 /* Give each template template parm in this redeclaration a
6188 DECL_CONTEXT of the template for which they are a parameter. */
6189 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
6191 gcc_assert (DECL_CONTEXT (parm
) == NULL_TREE
);
6192 DECL_CONTEXT (parm
) = tmpl
;
6195 if (TREE_CODE (parm
) == TYPE_DECL
)
6196 TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (parm
)) = true;
6199 tree ci
= get_constraints (tmpl
);
6200 tree req1
= ci
? CI_TEMPLATE_REQS (ci
) : NULL_TREE
;
6201 tree req2
= cons
? CI_TEMPLATE_REQS (cons
) : NULL_TREE
;
6203 /* Two classes with different constraints declare different entities. */
6204 if (!cp_tree_equal (req1
, req2
))
6206 error_at (input_location
, "redeclaration %q#D with different "
6207 "constraints", tmpl
);
6208 inform (DECL_SOURCE_LOCATION (tmpl
),
6209 "original declaration appeared here");
6216 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
6217 to be used when the caller has already checked
6218 (processing_template_decl
6219 && !instantiation_dependent_expression_p (expr)
6220 && potential_constant_expression (expr))
6221 and cleared processing_template_decl. */
6224 instantiate_non_dependent_expr_internal (tree expr
, tsubst_flags_t complain
)
6226 return tsubst_copy_and_build (expr
,
6229 /*in_decl=*/NULL_TREE
,
6230 /*function_p=*/false,
6231 /*integral_constant_expression_p=*/true);
6234 /* Simplify EXPR if it is a non-dependent expression. Returns the
6235 (possibly simplified) expression. */
6238 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
6240 if (expr
== NULL_TREE
)
6243 /* If we're in a template, but EXPR isn't value dependent, simplify
6244 it. We're supposed to treat:
6246 template <typename T> void f(T[1 + 1]);
6247 template <typename T> void f(T[2]);
6249 as two declarations of the same function, for example. */
6250 if (processing_template_decl
6251 && is_nondependent_constant_expression (expr
))
6253 processing_template_decl_sentinel s
;
6254 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6260 instantiate_non_dependent_expr (tree expr
)
6262 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
6265 /* Like instantiate_non_dependent_expr, but return NULL_TREE rather than
6266 an uninstantiated expression. */
6269 instantiate_non_dependent_or_null (tree expr
)
6271 if (expr
== NULL_TREE
)
6273 if (processing_template_decl
)
6275 if (!is_nondependent_constant_expression (expr
))
6279 processing_template_decl_sentinel s
;
6280 expr
= instantiate_non_dependent_expr_internal (expr
, tf_error
);
6286 /* True iff T is a specialization of a variable template. */
6289 variable_template_specialization_p (tree t
)
6291 if (!VAR_P (t
) || !DECL_LANG_SPECIFIC (t
) || !DECL_TEMPLATE_INFO (t
))
6293 tree tmpl
= DECL_TI_TEMPLATE (t
);
6294 return variable_template_p (tmpl
);
6297 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
6298 template declaration, or a TYPE_DECL for an alias declaration. */
6301 alias_type_or_template_p (tree t
)
6305 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
6308 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
6309 || DECL_ALIAS_TEMPLATE_P (t
));
6312 /* If T is a specialization of an alias template, return it; otherwise return
6313 NULL_TREE. If TRANSPARENT_TYPEDEFS is true, look through other aliases. */
6316 alias_template_specialization_p (const_tree t
,
6317 bool transparent_typedefs
)
6322 /* It's an alias template specialization if it's an alias and its
6323 TYPE_NAME is a specialization of a primary template. */
6324 if (typedef_variant_p (t
))
6326 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
6327 if (PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
)))
6328 return CONST_CAST_TREE (t
);
6329 if (transparent_typedefs
)
6330 return alias_template_specialization_p (DECL_ORIGINAL_TYPE
6332 transparent_typedefs
);
6338 /* An alias template is complex from a SFINAE perspective if a template-id
6339 using that alias can be ill-formed when the expansion is not, as with
6340 the void_t template. We determine this by checking whether the
6341 expansion for the alias template uses all its template parameters. */
6343 struct uses_all_template_parms_data
6350 uses_all_template_parms_r (tree t
, void *data_
)
6352 struct uses_all_template_parms_data
&data
6353 = *(struct uses_all_template_parms_data
*)data_
;
6354 tree idx
= get_template_parm_index (t
);
6356 if (TEMPLATE_PARM_LEVEL (idx
) == data
.level
)
6357 data
.seen
[TEMPLATE_PARM_IDX (idx
)] = true;
6362 complex_alias_template_p (const_tree tmpl
)
6364 /* A renaming alias isn't complex. */
6365 if (get_underlying_template (CONST_CAST_TREE (tmpl
)) != tmpl
)
6368 /* Any other constrained alias is complex. */
6369 if (get_constraints (tmpl
))
6372 struct uses_all_template_parms_data data
;
6373 tree pat
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
6374 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
6375 data
.level
= TMPL_PARMS_DEPTH (parms
);
6376 int len
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms
));
6377 data
.seen
= XALLOCAVEC (bool, len
);
6378 for (int i
= 0; i
< len
; ++i
)
6379 data
.seen
[i
] = false;
6381 for_each_template_parm (pat
, uses_all_template_parms_r
, &data
, NULL
, true);
6382 for (int i
= 0; i
< len
; ++i
)
6388 /* If T is a specialization of a complex alias template with dependent
6389 template-arguments, return it; otherwise return NULL_TREE. If T is a
6390 typedef to such a specialization, return the specialization. */
6393 dependent_alias_template_spec_p (const_tree t
, bool transparent_typedefs
)
6395 if (!TYPE_P (t
) || !typedef_variant_p (t
))
6398 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
);
6400 && TEMPLATE_DECL_COMPLEX_ALIAS_P (TI_TEMPLATE (tinfo
))
6401 && (any_dependent_template_arguments_p
6402 (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
)))))
6403 return CONST_CAST_TREE (t
);
6405 if (transparent_typedefs
)
6407 tree utype
= DECL_ORIGINAL_TYPE (TYPE_NAME (t
));
6408 return dependent_alias_template_spec_p (utype
, transparent_typedefs
);
6414 /* Return the number of innermost template parameters in TMPL. */
6417 num_innermost_template_parms (const_tree tmpl
)
6419 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
6420 return TREE_VEC_LENGTH (parms
);
6423 /* Return either TMPL or another template that it is equivalent to under DR
6424 1286: An alias that just changes the name of a template is equivalent to
6425 the other template. */
6428 get_underlying_template (tree tmpl
)
6430 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
6431 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
6433 /* Determine if the alias is equivalent to an underlying template. */
6434 tree orig_type
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
6435 /* The underlying type may have been ill-formed. Don't proceed. */
6438 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (orig_type
);
6442 tree underlying
= TI_TEMPLATE (tinfo
);
6443 if (!PRIMARY_TEMPLATE_P (underlying
)
6444 || (num_innermost_template_parms (tmpl
)
6445 != num_innermost_template_parms (underlying
)))
6448 tree alias_args
= INNERMOST_TEMPLATE_ARGS (generic_targs_for (tmpl
));
6449 if (!comp_template_args (TI_ARGS (tinfo
), alias_args
))
6452 /* If TMPL adds or changes any constraints, it isn't equivalent. I think
6453 it's appropriate to treat a less-constrained alias as equivalent. */
6454 if (!at_least_as_constrained (underlying
, tmpl
))
6457 /* Alias is equivalent. Strip it and repeat. */
6464 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
6465 must be a reference-to-function or a pointer-to-function type, as specified
6466 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
6467 and check that the resulting function has external linkage. */
6470 convert_nontype_argument_function (tree type
, tree expr
,
6471 tsubst_flags_t complain
)
6475 linkage_kind linkage
;
6477 fn
= instantiate_type (type
, fns
, tf_none
);
6478 if (fn
== error_mark_node
)
6479 return error_mark_node
;
6481 if (value_dependent_expression_p (fn
))
6484 fn_no_ptr
= strip_fnptr_conv (fn
);
6485 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
6486 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
6487 if (BASELINK_P (fn_no_ptr
))
6488 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
6490 /* [temp.arg.nontype]/1
6492 A template-argument for a non-type, non-template template-parameter
6495 -- the address of an object or function with external [C++11: or
6496 internal] linkage. */
6498 STRIP_ANY_LOCATION_WRAPPER (fn_no_ptr
);
6499 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
6501 if (complain
& tf_error
)
6503 location_t loc
= cp_expr_loc_or_input_loc (expr
);
6504 error_at (loc
, "%qE is not a valid template argument for type %qT",
6506 if (TYPE_PTR_P (type
))
6507 inform (loc
, "it must be the address of a function "
6508 "with external linkage");
6510 inform (loc
, "it must be the name of a function with "
6511 "external linkage");
6516 linkage
= decl_linkage (fn_no_ptr
);
6517 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
6519 if (complain
& tf_error
)
6521 location_t loc
= cp_expr_loc_or_input_loc (expr
);
6522 if (cxx_dialect
>= cxx11
)
6523 error_at (loc
, "%qE is not a valid template argument for type "
6524 "%qT because %qD has no linkage",
6525 expr
, type
, fn_no_ptr
);
6527 error_at (loc
, "%qE is not a valid template argument for type "
6528 "%qT because %qD does not have external linkage",
6529 expr
, type
, fn_no_ptr
);
6535 if (TYPE_REF_P (type
))
6537 if (REFERENCE_REF_P (fn
))
6538 fn
= TREE_OPERAND (fn
, 0);
6540 fn
= build_address (fn
);
6542 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (fn
)))
6543 fn
= build_nop (type
, fn
);
6548 /* Subroutine of convert_nontype_argument.
6549 Check if EXPR of type TYPE is a valid pointer-to-member constant.
6550 Emit an error otherwise. */
6553 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
6554 tsubst_flags_t complain
)
6556 tree orig_expr
= expr
;
6558 if (null_ptr_cst_p (expr
))
6560 if (TREE_CODE (expr
) == PTRMEM_CST
6561 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
6562 PTRMEM_CST_CLASS (expr
)))
6564 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
6566 if (processing_template_decl
6567 && TREE_CODE (expr
) == ADDR_EXPR
6568 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
6570 if (complain
& tf_error
)
6572 location_t loc
= cp_expr_loc_or_input_loc (orig_expr
);
6573 error_at (loc
, "%qE is not a valid template argument for type %qT",
6575 if (TREE_CODE (expr
) != PTRMEM_CST
)
6576 inform (loc
, "it must be a pointer-to-member of the form %<&X::Y%>");
6578 inform (loc
, "because it is a member of %qT", PTRMEM_CST_CLASS (expr
));
6583 /* Returns TRUE iff the address of OP is value-dependent.
6585 14.6.2.4 [temp.dep.temp]:
6586 A non-integral non-type template-argument is dependent if its type is
6587 dependent or it has either of the following forms
6590 and contains a nested-name-specifier which specifies a class-name that
6591 names a dependent type.
6593 We generalize this to just say that the address of a member of a
6594 dependent class is value-dependent; the above doesn't cover the
6595 address of a static data member named with an unqualified-id. */
6598 has_value_dependent_address (tree op
)
6600 STRIP_ANY_LOCATION_WRAPPER (op
);
6602 /* We could use get_inner_reference here, but there's no need;
6603 this is only relevant for template non-type arguments, which
6604 can only be expressed as &id-expression. */
6607 tree ctx
= CP_DECL_CONTEXT (op
);
6608 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
6615 /* The next set of functions are used for providing helpful explanatory
6616 diagnostics for failed overload resolution. Their messages should be
6617 indented by two spaces for consistency with the messages in
6621 unify_success (bool /*explain_p*/)
6626 /* Other failure functions should call this one, to provide a single function
6627 for setting a breakpoint on. */
6630 unify_invalid (bool /*explain_p*/)
6636 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
6639 inform (input_location
,
6640 " couldn%'t deduce template parameter %qD", parm
);
6641 return unify_invalid (explain_p
);
6645 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
6648 inform (input_location
,
6649 " types %qT and %qT have incompatible cv-qualifiers",
6651 return unify_invalid (explain_p
);
6655 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
6658 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
6659 return unify_invalid (explain_p
);
6663 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
6666 inform (input_location
,
6667 " template parameter %qD is not a parameter pack, but "
6670 return unify_invalid (explain_p
);
6674 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
6677 inform (input_location
,
6678 " template argument %qE does not match "
6679 "pointer-to-member constant %qE",
6681 return unify_invalid (explain_p
);
6685 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
6688 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
6689 return unify_invalid (explain_p
);
6693 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
6696 inform (input_location
,
6697 " inconsistent parameter pack deduction with %qT and %qT",
6699 return unify_invalid (explain_p
);
6703 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
6708 inform (input_location
,
6709 " deduced conflicting types for parameter %qT (%qT and %qT)",
6710 parm
, first
, second
);
6712 inform (input_location
,
6713 " deduced conflicting values for non-type parameter "
6714 "%qE (%qE and %qE)", parm
, first
, second
);
6716 return unify_invalid (explain_p
);
6720 unify_vla_arg (bool explain_p
, tree arg
)
6723 inform (input_location
,
6724 " variable-sized array type %qT is not "
6725 "a valid template argument",
6727 return unify_invalid (explain_p
);
6731 unify_method_type_error (bool explain_p
, tree arg
)
6734 inform (input_location
,
6735 " member function type %qT is not a valid template argument",
6737 return unify_invalid (explain_p
);
6741 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
6746 inform_n (input_location
, wanted
,
6747 " candidate expects at least %d argument, %d provided",
6748 " candidate expects at least %d arguments, %d provided",
6751 inform_n (input_location
, wanted
,
6752 " candidate expects %d argument, %d provided",
6753 " candidate expects %d arguments, %d provided",
6756 return unify_invalid (explain_p
);
6760 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
6762 return unify_arity (explain_p
, have
, wanted
);
6766 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
6767 bool least_p
= false)
6769 return unify_arity (explain_p
, have
, wanted
, least_p
);
6773 unify_arg_conversion (bool explain_p
, tree to_type
,
6774 tree from_type
, tree arg
)
6777 inform (cp_expr_loc_or_input_loc (arg
),
6778 " cannot convert %qE (type %qT) to type %qT",
6779 arg
, from_type
, to_type
);
6780 return unify_invalid (explain_p
);
6784 unify_no_common_base (bool explain_p
, enum template_base_result r
,
6785 tree parm
, tree arg
)
6790 case tbr_ambiguous_baseclass
:
6791 inform (input_location
, " %qT is an ambiguous base class of %qT",
6795 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
6798 return unify_invalid (explain_p
);
6802 unify_inconsistent_template_template_parameters (bool explain_p
)
6805 inform (input_location
,
6806 " template parameters of a template template argument are "
6807 "inconsistent with other deduced template arguments");
6808 return unify_invalid (explain_p
);
6812 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
6815 inform (input_location
,
6816 " cannot deduce a template for %qT from non-template type %qT",
6818 return unify_invalid (explain_p
);
6822 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
6825 inform (input_location
,
6826 " template argument %qE does not match %qE", arg
, parm
);
6827 return unify_invalid (explain_p
);
6830 /* True if T is a C++20 template parameter object to store the argument for a
6831 template parameter of class type. */
6834 template_parm_object_p (const_tree t
)
6836 return (TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
) && DECL_NAME (t
)
6837 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (t
)), "_ZTA", 4));
6840 /* Subroutine of convert_nontype_argument, to check whether EXPR, as an
6841 argument for TYPE, points to an unsuitable object. */
6844 invalid_tparm_referent_p (tree type
, tree expr
, tsubst_flags_t complain
)
6846 switch (TREE_CODE (expr
))
6849 return invalid_tparm_referent_p (type
, TREE_OPERAND (expr
, 0),
6853 return invalid_tparm_referent_p (type
, TARGET_EXPR_INITIAL (expr
),
6858 unsigned i
; tree elt
;
6859 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), i
, elt
)
6860 if (invalid_tparm_referent_p (TREE_TYPE (elt
), elt
, complain
))
6867 tree decl
= TREE_OPERAND (expr
, 0);
6871 if (complain
& tf_error
)
6872 error_at (cp_expr_loc_or_input_loc (expr
),
6873 "%qE is not a valid template argument of type %qT "
6874 "because %qE is not a variable", expr
, type
, decl
);
6877 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
6879 if (complain
& tf_error
)
6880 error_at (cp_expr_loc_or_input_loc (expr
),
6881 "%qE is not a valid template argument of type %qT "
6882 "in C++98 because %qD does not have external linkage",
6886 else if ((cxx_dialect
>= cxx11
&& cxx_dialect
< cxx17
)
6887 && decl_linkage (decl
) == lk_none
)
6889 if (complain
& tf_error
)
6890 error_at (cp_expr_loc_or_input_loc (expr
),
6891 "%qE is not a valid template argument of type %qT "
6892 "because %qD has no linkage", expr
, type
, decl
);
6895 /* C++17: For a non-type template-parameter of reference or pointer
6896 type, the value of the constant expression shall not refer to (or
6897 for a pointer type, shall not be the address of):
6898 * a subobject (4.5),
6899 * a temporary object (15.2),
6900 * a string literal (5.13.5),
6901 * the result of a typeid expression (8.2.8), or
6902 * a predefined __func__ variable (11.4.1). */
6903 else if (DECL_ARTIFICIAL (decl
))
6905 if (complain
& tf_error
)
6906 error ("the address of %qD is not a valid template argument",
6910 else if (!same_type_ignoring_top_level_qualifiers_p
6911 (strip_array_types (TREE_TYPE (type
)),
6912 strip_array_types (TREE_TYPE (decl
))))
6914 if (complain
& tf_error
)
6915 error ("the address of the %qT subobject of %qD is not a "
6916 "valid template argument", TREE_TYPE (type
), decl
);
6919 else if (!TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
6921 if (complain
& tf_error
)
6922 error ("the address of %qD is not a valid template argument "
6923 "because it does not have static storage duration",
6931 if (!INDIRECT_TYPE_P (type
))
6932 /* We're only concerned about pointers and references here. */;
6933 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6934 /* Null pointer values are OK in C++11. */;
6939 if (complain
& tf_error
)
6940 error ("%qD is not a valid template argument "
6941 "because %qD is a variable, not the address of "
6942 "a variable", expr
, expr
);
6947 if (complain
& tf_error
)
6948 error ("%qE is not a valid template argument for %qT "
6949 "because it is not the address of a variable",
6959 /* Return a VAR_DECL for the C++20 template parameter object corresponding to
6960 template argument EXPR. */
6963 get_template_parm_object (tree expr
, tsubst_flags_t complain
)
6965 if (TREE_CODE (expr
) == TARGET_EXPR
)
6966 expr
= TARGET_EXPR_INITIAL (expr
);
6968 if (!TREE_CONSTANT (expr
))
6970 if ((complain
& tf_error
)
6971 && require_rvalue_constant_expression (expr
))
6972 cxx_constant_value (expr
);
6973 return error_mark_node
;
6975 if (invalid_tparm_referent_p (TREE_TYPE (expr
), expr
, complain
))
6976 return error_mark_node
;
6978 tree name
= mangle_template_parm_object (expr
);
6979 tree decl
= get_global_binding (name
);
6983 tree type
= cp_build_qualified_type (TREE_TYPE (expr
), TYPE_QUAL_CONST
);
6984 decl
= create_temporary_var (type
);
6985 TREE_STATIC (decl
) = true;
6986 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
6987 TREE_READONLY (decl
) = true;
6988 DECL_NAME (decl
) = name
;
6989 SET_DECL_ASSEMBLER_NAME (decl
, name
);
6990 DECL_CONTEXT (decl
) = global_namespace
;
6991 comdat_linkage (decl
);
6992 pushdecl_top_level_and_finish (decl
, expr
);
6996 /* Attempt to convert the non-type template parameter EXPR to the
6997 indicated TYPE. If the conversion is successful, return the
6998 converted value. If the conversion is unsuccessful, return
6999 NULL_TREE if we issued an error message, or error_mark_node if we
7000 did not. We issue error messages for out-and-out bad template
7001 parameters, but not simply because the conversion failed, since we
7002 might be just trying to do argument deduction. Both TYPE and EXPR
7003 must be non-dependent.
7005 The conversion follows the special rules described in
7006 [temp.arg.nontype], and it is much more strict than an implicit
7009 This function is called twice for each template argument (see
7010 lookup_template_class for a more accurate description of this
7011 problem). This means that we need to handle expressions which
7012 are not valid in a C++ source, but can be created from the
7013 first call (for instance, casts to perform conversions). These
7014 hacks can go away after we fix the double coercion problem. */
7017 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
7020 location_t loc
= cp_expr_loc_or_input_loc (expr
);
7022 /* Detect immediately string literals as invalid non-type argument.
7023 This special-case is not needed for correctness (we would easily
7024 catch this later), but only to provide better diagnostic for this
7025 common user mistake. As suggested by DR 100, we do not mention
7026 linkage issues in the diagnostic as this is not the point. */
7027 if (TREE_CODE (expr
) == STRING_CST
&& !CLASS_TYPE_P (type
))
7029 if (complain
& tf_error
)
7030 error ("%qE is not a valid template argument for type %qT "
7031 "because string literals can never be used in this context",
7036 /* Add the ADDR_EXPR now for the benefit of
7037 value_dependent_expression_p. */
7038 if (TYPE_PTROBV_P (type
)
7039 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
7041 expr
= decay_conversion (expr
, complain
);
7042 if (expr
== error_mark_node
)
7043 return error_mark_node
;
7046 /* If we are in a template, EXPR may be non-dependent, but still
7047 have a syntactic, rather than semantic, form. For example, EXPR
7048 might be a SCOPE_REF, rather than the VAR_DECL to which the
7049 SCOPE_REF refers. Preserving the qualifying scope is necessary
7050 so that access checking can be performed when the template is
7051 instantiated -- but here we need the resolved form so that we can
7052 convert the argument. */
7053 bool non_dep
= false;
7054 if (TYPE_REF_OBJ_P (type
)
7055 && has_value_dependent_address (expr
))
7056 /* If we want the address and it's value-dependent, don't fold. */;
7057 else if (processing_template_decl
7058 && is_nondependent_constant_expression (expr
))
7060 if (error_operand_p (expr
))
7061 return error_mark_node
;
7062 expr_type
= TREE_TYPE (expr
);
7064 /* If the argument is non-dependent, perform any conversions in
7065 non-dependent context as well. */
7066 processing_template_decl_sentinel
s (non_dep
);
7068 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
7070 if (value_dependent_expression_p (expr
))
7071 expr
= canonicalize_expr_argument (expr
, complain
);
7073 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
7074 to a non-type argument of "nullptr". */
7075 if (NULLPTR_TYPE_P (expr_type
) && TYPE_PTR_OR_PTRMEM_P (type
))
7076 expr
= fold_simple (convert (type
, expr
));
7078 /* In C++11, integral or enumeration non-type template arguments can be
7079 arbitrary constant expressions. Pointer and pointer to
7080 member arguments can be general constant expressions that evaluate
7081 to a null value, but otherwise still need to be of a specific form. */
7082 if (cxx_dialect
>= cxx11
)
7084 if (TREE_CODE (expr
) == PTRMEM_CST
&& TYPE_PTRMEM_P (type
))
7085 /* A PTRMEM_CST is already constant, and a valid template
7086 argument for a parameter of pointer to member type, we just want
7087 to leave it in that form rather than lower it to a
7089 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
7090 || cxx_dialect
>= cxx17
)
7092 /* Calling build_converted_constant_expr might create a call to
7093 a conversion function with a value-dependent argument, which
7094 could invoke taking the address of a temporary representing
7095 the result of the conversion. */
7096 if (COMPOUND_LITERAL_P (expr
)
7097 && CONSTRUCTOR_IS_DEPENDENT (expr
)
7098 && MAYBE_CLASS_TYPE_P (expr_type
)
7099 && TYPE_HAS_CONVERSION (expr_type
))
7101 expr
= build1 (IMPLICIT_CONV_EXPR
, type
, expr
);
7102 IMPLICIT_CONV_EXPR_NONTYPE_ARG (expr
) = true;
7105 /* C++17: A template-argument for a non-type template-parameter shall
7106 be a converted constant expression (8.20) of the type of the
7107 template-parameter. */
7108 expr
= build_converted_constant_expr (type
, expr
, complain
);
7109 if (expr
== error_mark_node
)
7110 /* Make sure we return NULL_TREE only if we have really issued
7111 an error, as described above. */
7112 return (complain
& tf_error
) ? NULL_TREE
: error_mark_node
;
7113 expr
= maybe_constant_value (expr
, NULL_TREE
,
7114 /*manifestly_const_eval=*/true);
7115 expr
= convert_from_reference (expr
);
7117 else if (TYPE_PTR_OR_PTRMEM_P (type
))
7119 tree folded
= maybe_constant_value (expr
, NULL_TREE
,
7120 /*manifestly_const_eval=*/true);
7121 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
7122 : null_member_pointer_value_p (folded
))
7127 if (TYPE_REF_P (type
))
7128 expr
= mark_lvalue_use (expr
);
7130 expr
= mark_rvalue_use (expr
);
7132 /* HACK: Due to double coercion, we can get a
7133 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
7134 which is the tree that we built on the first call (see
7135 below when coercing to reference to object or to reference to
7136 function). We just strip everything and get to the arg.
7137 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
7139 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
7141 tree probe_type
, probe
= expr
;
7142 if (REFERENCE_REF_P (probe
))
7143 probe
= TREE_OPERAND (probe
, 0);
7144 probe_type
= TREE_TYPE (probe
);
7145 if (TREE_CODE (probe
) == NOP_EXPR
)
7147 /* ??? Maybe we could use convert_from_reference here, but we
7148 would need to relax its constraints because the NOP_EXPR
7149 could actually change the type to something more cv-qualified,
7150 and this is not folded by convert_from_reference. */
7151 tree addr
= TREE_OPERAND (probe
, 0);
7152 if (TYPE_REF_P (probe_type
)
7153 && TREE_CODE (addr
) == ADDR_EXPR
7154 && TYPE_PTR_P (TREE_TYPE (addr
))
7155 && (same_type_ignoring_top_level_qualifiers_p
7156 (TREE_TYPE (probe_type
),
7157 TREE_TYPE (TREE_TYPE (addr
)))))
7159 expr
= TREE_OPERAND (addr
, 0);
7160 expr_type
= TREE_TYPE (probe_type
);
7165 /* [temp.arg.nontype]/5, bullet 1
7167 For a non-type template-parameter of integral or enumeration type,
7168 integral promotions (_conv.prom_) and integral conversions
7169 (_conv.integral_) are applied. */
7170 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
7172 if (cxx_dialect
< cxx11
)
7174 tree t
= build_converted_constant_expr (type
, expr
, complain
);
7175 t
= maybe_constant_value (t
);
7176 if (t
!= error_mark_node
)
7180 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
7181 return error_mark_node
;
7183 /* Notice that there are constant expressions like '4 % 0' which
7184 do not fold into integer constants. */
7185 if (TREE_CODE (expr
) != INTEGER_CST
7186 && !value_dependent_expression_p (expr
))
7188 if (complain
& tf_error
)
7190 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
7191 if (!require_potential_constant_expression (expr
))
7192 expr
= error_mark_node
;
7194 expr
= cxx_constant_value (expr
);
7195 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
7196 inform (loc
, "in template argument for type %qT", type
);
7197 if (expr
== error_mark_node
)
7199 /* else cxx_constant_value complained but gave us
7200 a real constant, so go ahead. */
7201 if (TREE_CODE (expr
) != INTEGER_CST
)
7203 /* Some assemble time constant expressions like
7204 (intptr_t)&&lab1 - (intptr_t)&&lab2 or
7205 4 + (intptr_t)&&var satisfy reduced_constant_expression_p
7206 as we can emit them into .rodata initializers of
7207 variables, yet they can't fold into an INTEGER_CST at
7208 compile time. Refuse them here. */
7209 gcc_checking_assert (reduced_constant_expression_p (expr
));
7210 error_at (loc
, "template argument %qE for type %qT not "
7211 "a constant integer", expr
, type
);
7219 /* Avoid typedef problems. */
7220 if (TREE_TYPE (expr
) != type
)
7221 expr
= fold_convert (type
, expr
);
7223 /* [temp.arg.nontype]/5, bullet 2
7225 For a non-type template-parameter of type pointer to object,
7226 qualification conversions (_conv.qual_) and the array-to-pointer
7227 conversion (_conv.array_) are applied. */
7228 else if (TYPE_PTROBV_P (type
))
7230 tree decayed
= expr
;
7232 /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
7233 decay_conversion or an explicit cast. If it's a problematic cast,
7234 we'll complain about it below. */
7235 if (TREE_CODE (expr
) == NOP_EXPR
)
7239 if (TREE_CODE (probe
) == ADDR_EXPR
7240 && TYPE_PTR_P (TREE_TYPE (probe
)))
7243 expr_type
= TREE_TYPE (expr
);
7247 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
7249 A template-argument for a non-type, non-template template-parameter
7250 shall be one of: [...]
7252 -- the name of a non-type template-parameter;
7253 -- the address of an object or function with external linkage, [...]
7254 expressed as "& id-expression" where the & is optional if the name
7255 refers to a function or array, or if the corresponding
7256 template-parameter is a reference.
7258 Here, we do not care about functions, as they are invalid anyway
7259 for a parameter of type pointer-to-object. */
7261 if (value_dependent_expression_p (expr
))
7262 /* Non-type template parameters are OK. */
7264 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
7265 /* Null pointer values are OK in C++11. */;
7266 else if (TREE_CODE (expr
) != ADDR_EXPR
7267 && !INDIRECT_TYPE_P (expr_type
))
7268 /* Other values, like integer constants, might be valid
7269 non-type arguments of some other type. */
7270 return error_mark_node
;
7271 else if (invalid_tparm_referent_p (type
, expr
, complain
))
7276 expr
= perform_qualification_conversions (type
, expr
);
7277 if (expr
== error_mark_node
)
7278 return error_mark_node
;
7280 /* [temp.arg.nontype]/5, bullet 3
7282 For a non-type template-parameter of type reference to object, no
7283 conversions apply. The type referred to by the reference may be more
7284 cv-qualified than the (otherwise identical) type of the
7285 template-argument. The template-parameter is bound directly to the
7286 template-argument, which must be an lvalue. */
7287 else if (TYPE_REF_OBJ_P (type
))
7289 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
7291 return error_mark_node
;
7293 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
7295 if (complain
& tf_error
)
7296 error ("%qE is not a valid template argument for type %qT "
7297 "because of conflicts in cv-qualification", expr
, type
);
7301 if (!lvalue_p (expr
))
7303 if (complain
& tf_error
)
7304 error ("%qE is not a valid template argument for type %qT "
7305 "because it is not an lvalue", expr
, type
);
7309 /* [temp.arg.nontype]/1
7311 A template-argument for a non-type, non-template template-parameter
7312 shall be one of: [...]
7314 -- the address of an object or function with external linkage. */
7315 if (INDIRECT_REF_P (expr
)
7316 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
7318 expr
= TREE_OPERAND (expr
, 0);
7321 if (complain
& tf_error
)
7322 error ("%q#D is not a valid template argument for type %qT "
7323 "because a reference variable does not have a constant "
7324 "address", expr
, type
);
7329 if (TYPE_REF_OBJ_P (TREE_TYPE (expr
))
7330 && value_dependent_expression_p (expr
))
7331 /* OK, dependent reference. We don't want to ask whether a DECL is
7332 itself value-dependent, since what we want here is its address. */;
7335 expr
= build_address (expr
);
7337 if (invalid_tparm_referent_p (type
, expr
, complain
))
7341 if (!same_type_p (type
, TREE_TYPE (expr
)))
7342 expr
= build_nop (type
, expr
);
7344 /* [temp.arg.nontype]/5, bullet 4
7346 For a non-type template-parameter of type pointer to function, only
7347 the function-to-pointer conversion (_conv.func_) is applied. If the
7348 template-argument represents a set of overloaded functions (or a
7349 pointer to such), the matching function is selected from the set
7351 else if (TYPE_PTRFN_P (type
))
7353 /* If the argument is a template-id, we might not have enough
7354 context information to decay the pointer. */
7355 if (!type_unknown_p (expr_type
))
7357 expr
= decay_conversion (expr
, complain
);
7358 if (expr
== error_mark_node
)
7359 return error_mark_node
;
7362 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
7363 /* Null pointer values are OK in C++11. */
7364 return perform_qualification_conversions (type
, expr
);
7366 expr
= convert_nontype_argument_function (type
, expr
, complain
);
7367 if (!expr
|| expr
== error_mark_node
)
7370 /* [temp.arg.nontype]/5, bullet 5
7372 For a non-type template-parameter of type reference to function, no
7373 conversions apply. If the template-argument represents a set of
7374 overloaded functions, the matching function is selected from the set
7376 else if (TYPE_REFFN_P (type
))
7378 if (TREE_CODE (expr
) == ADDR_EXPR
)
7380 if (complain
& tf_error
)
7382 error ("%qE is not a valid template argument for type %qT "
7383 "because it is a pointer", expr
, type
);
7384 inform (input_location
, "try using %qE instead",
7385 TREE_OPERAND (expr
, 0));
7390 expr
= convert_nontype_argument_function (type
, expr
, complain
);
7391 if (!expr
|| expr
== error_mark_node
)
7394 /* [temp.arg.nontype]/5, bullet 6
7396 For a non-type template-parameter of type pointer to member function,
7397 no conversions apply. If the template-argument represents a set of
7398 overloaded member functions, the matching member function is selected
7399 from the set (_over.over_). */
7400 else if (TYPE_PTRMEMFUNC_P (type
))
7402 expr
= instantiate_type (type
, expr
, tf_none
);
7403 if (expr
== error_mark_node
)
7404 return error_mark_node
;
7406 /* [temp.arg.nontype] bullet 1 says the pointer to member
7407 expression must be a pointer-to-member constant. */
7408 if (!value_dependent_expression_p (expr
)
7409 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
7412 /* Repeated conversion can't deal with a conversion that turns PTRMEM_CST
7413 into a CONSTRUCTOR, so build up a new PTRMEM_CST instead. */
7414 if (fnptr_conv_p (type
, TREE_TYPE (expr
)))
7415 expr
= make_ptrmem_cst (type
, PTRMEM_CST_MEMBER (expr
));
7417 /* [temp.arg.nontype]/5, bullet 7
7419 For a non-type template-parameter of type pointer to data member,
7420 qualification conversions (_conv.qual_) are applied. */
7421 else if (TYPE_PTRDATAMEM_P (type
))
7423 /* [temp.arg.nontype] bullet 1 says the pointer to member
7424 expression must be a pointer-to-member constant. */
7425 if (!value_dependent_expression_p (expr
)
7426 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
7429 expr
= perform_qualification_conversions (type
, expr
);
7430 if (expr
== error_mark_node
)
7433 else if (NULLPTR_TYPE_P (type
))
7435 if (!NULLPTR_TYPE_P (TREE_TYPE (expr
)))
7437 if (complain
& tf_error
)
7438 error ("%qE is not a valid template argument for type %qT "
7439 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
7444 else if (CLASS_TYPE_P (type
))
7446 /* Replace the argument with a reference to the corresponding template
7447 parameter object. */
7448 if (!value_dependent_expression_p (expr
))
7449 expr
= get_template_parm_object (expr
, complain
);
7450 if (expr
== error_mark_node
)
7453 /* A template non-type parameter must be one of the above. */
7457 /* Sanity check: did we actually convert the argument to the
7459 gcc_assert (same_type_ignoring_top_level_qualifiers_p
7460 (type
, TREE_TYPE (expr
)));
7461 return convert_from_reference (expr
);
7464 /* Subroutine of coerce_template_template_parms, which returns 1 if
7465 PARM_PARM and ARG_PARM match using the rule for the template
7466 parameters of template template parameters. Both PARM and ARG are
7467 template parameters; the rest of the arguments are the same as for
7468 coerce_template_template_parms.
7471 coerce_template_template_parm (tree parm
,
7473 tsubst_flags_t complain
,
7477 if (arg
== NULL_TREE
|| error_operand_p (arg
)
7478 || parm
== NULL_TREE
|| error_operand_p (parm
))
7481 if (TREE_CODE (arg
) != TREE_CODE (parm
))
7484 switch (TREE_CODE (parm
))
7487 /* We encounter instantiations of templates like
7488 template <template <template <class> class> class TT>
7491 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
7492 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
7494 if (!coerce_template_template_parms
7495 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
7501 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
7502 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
7503 /* Argument is a parameter pack but parameter is not. */
7508 /* The tsubst call is used to handle cases such as
7510 template <int> class C {};
7511 template <class T, template <T> class TT> class D {};
7514 i.e. the parameter list of TT depends on earlier parameters. */
7515 if (!uses_template_parms (TREE_TYPE (arg
)))
7517 tree t
= tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
);
7518 if (!uses_template_parms (t
)
7519 && !same_type_p (t
, TREE_TYPE (arg
)))
7523 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
7524 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
7525 /* Argument is a parameter pack but parameter is not. */
7537 /* Coerce template argument list ARGLIST for use with template
7538 template-parameter TEMPL. */
7541 coerce_template_args_for_ttp (tree templ
, tree arglist
,
7542 tsubst_flags_t complain
)
7544 /* Consider an example where a template template parameter declared as
7546 template <class T, class U = std::allocator<T> > class TT
7548 The template parameter level of T and U are one level larger than
7549 of TT. To proper process the default argument of U, say when an
7550 instantiation `TT<int>' is seen, we need to build the full
7551 arguments containing {int} as the innermost level. Outer levels,
7552 available when not appearing as default template argument, can be
7553 obtained from the arguments of the enclosing template.
7555 Suppose that TT is later substituted with std::vector. The above
7556 instantiation is `TT<int, std::allocator<T> >' with TT at
7557 level 1, and T at level 2, while the template arguments at level 1
7558 becomes {std::vector} and the inner level 2 is {int}. */
7560 tree outer
= DECL_CONTEXT (templ
);
7562 outer
= generic_targs_for (outer
);
7563 else if (current_template_parms
)
7565 /* This is an argument of the current template, so we haven't set
7566 DECL_CONTEXT yet. */
7567 tree relevant_template_parms
;
7569 /* Parameter levels that are greater than the level of the given
7570 template template parm are irrelevant. */
7571 relevant_template_parms
= current_template_parms
;
7572 while (TMPL_PARMS_DEPTH (relevant_template_parms
)
7573 != TEMPLATE_TYPE_LEVEL (TREE_TYPE (templ
)))
7574 relevant_template_parms
= TREE_CHAIN (relevant_template_parms
);
7576 outer
= template_parms_to_args (relevant_template_parms
);
7580 arglist
= add_to_template_args (outer
, arglist
);
7582 tree parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7583 return coerce_template_parms (parmlist
, arglist
, templ
,
7585 /*require_all_args=*/true,
7586 /*use_default_args=*/true);
7589 /* A cache of template template parameters with match-all default
7591 static GTY((deletable
)) hash_map
<tree
,tree
> *defaulted_ttp_cache
;
7593 /* T is a bound template template-parameter. Copy its arguments into default
7594 arguments of the template template-parameter's template parameters. */
7597 add_defaults_to_ttp (tree otmpl
)
7599 if (tree
*c
= hash_map_safe_get (defaulted_ttp_cache
, otmpl
))
7602 tree ntmpl
= copy_node (otmpl
);
7604 tree ntype
= copy_node (TREE_TYPE (otmpl
));
7605 TYPE_STUB_DECL (ntype
) = TYPE_NAME (ntype
) = ntmpl
;
7606 TYPE_MAIN_VARIANT (ntype
) = ntype
;
7607 TYPE_POINTER_TO (ntype
) = TYPE_REFERENCE_TO (ntype
) = NULL_TREE
;
7608 TYPE_NAME (ntype
) = ntmpl
;
7609 SET_TYPE_STRUCTURAL_EQUALITY (ntype
);
7611 tree idx
= TEMPLATE_TYPE_PARM_INDEX (ntype
)
7612 = copy_node (TEMPLATE_TYPE_PARM_INDEX (ntype
));
7613 TEMPLATE_PARM_DECL (idx
) = ntmpl
;
7614 TREE_TYPE (ntmpl
) = TREE_TYPE (idx
) = ntype
;
7616 tree oparms
= DECL_TEMPLATE_PARMS (otmpl
);
7617 tree parms
= DECL_TEMPLATE_PARMS (ntmpl
) = copy_node (oparms
);
7618 TREE_CHAIN (parms
) = TREE_CHAIN (oparms
);
7619 tree vec
= TREE_VALUE (parms
) = copy_node (TREE_VALUE (parms
));
7620 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
7622 tree o
= TREE_VEC_ELT (vec
, i
);
7623 if (!template_parameter_pack_p (TREE_VALUE (o
)))
7625 tree n
= TREE_VEC_ELT (vec
, i
) = copy_node (o
);
7626 TREE_PURPOSE (n
) = any_targ_node
;
7630 hash_map_safe_put
<hm_ggc
> (defaulted_ttp_cache
, otmpl
, ntmpl
);
7634 /* ARG is a bound potential template template-argument, and PARGS is a list
7635 of arguments for the corresponding template template-parameter. Adjust
7636 PARGS as appropriate for application to ARG's template, and if ARG is a
7637 BOUND_TEMPLATE_TEMPLATE_PARM, possibly adjust it to add default template
7638 arguments to the template template parameter. */
7641 coerce_ttp_args_for_tta (tree
& arg
, tree pargs
, tsubst_flags_t complain
)
7643 ++processing_template_decl
;
7644 tree arg_tmpl
= TYPE_TI_TEMPLATE (arg
);
7645 if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg_tmpl
))
7647 /* When comparing two template template-parameters in partial ordering,
7648 rewrite the one currently being used as an argument to have default
7649 arguments for all parameters. */
7650 arg_tmpl
= add_defaults_to_ttp (arg_tmpl
);
7651 pargs
= coerce_template_args_for_ttp (arg_tmpl
, pargs
, complain
);
7652 if (pargs
!= error_mark_node
)
7653 arg
= bind_template_template_parm (TREE_TYPE (arg_tmpl
),
7654 TYPE_TI_ARGS (arg
));
7659 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (arg_tmpl
));
7660 pargs
= coerce_template_parms (aparms
, pargs
, arg_tmpl
, complain
,
7661 /*require_all*/true,
7662 /*use_default*/true);
7664 --processing_template_decl
;
7668 /* Subroutine of unify for the case when PARM is a
7669 BOUND_TEMPLATE_TEMPLATE_PARM. */
7672 unify_bound_ttp_args (tree tparms
, tree targs
, tree parm
, tree
& arg
,
7675 tree parmvec
= TYPE_TI_ARGS (parm
);
7676 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
7678 /* The template template parm might be variadic and the argument
7679 not, so flatten both argument lists. */
7680 parmvec
= expand_template_argument_pack (parmvec
);
7681 argvec
= expand_template_argument_pack (argvec
);
7685 /* In keeping with P0522R0, adjust P's template arguments
7686 to apply to A's template; then flatten it again. */
7687 tree nparmvec
= coerce_ttp_args_for_tta (arg
, parmvec
, tf_none
);
7688 nparmvec
= expand_template_argument_pack (nparmvec
);
7690 if (unify (tparms
, targs
, nparmvec
, argvec
,
7691 UNIFY_ALLOW_NONE
, explain_p
))
7694 /* If the P0522 adjustment eliminated a pack expansion, deduce
7697 && TREE_VEC_LENGTH (nparmvec
) < TREE_VEC_LENGTH (parmvec
)
7698 && unify_pack_expansion (tparms
, targs
, parmvec
, argvec
,
7699 DEDUCE_EXACT
, /*sub*/true, explain_p
))
7704 /* Deduce arguments T, i from TT<T> or TT<i>.
7705 We check each element of PARMVEC and ARGVEC individually
7706 rather than the whole TREE_VEC since they can have
7707 different number of elements, which is allowed under N2555. */
7709 int len
= TREE_VEC_LENGTH (parmvec
);
7711 /* Check if the parameters end in a pack, making them
7713 int parm_variadic_p
= 0;
7715 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
7716 parm_variadic_p
= 1;
7718 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7719 /* If the template argument list of P contains a pack
7720 expansion that is not the last template argument, the
7721 entire template argument list is a non-deduced
7723 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
7724 return unify_success (explain_p
);
7726 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
7727 return unify_too_few_arguments (explain_p
,
7728 TREE_VEC_LENGTH (argvec
), len
);
7730 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7731 if (unify (tparms
, targs
,
7732 TREE_VEC_ELT (parmvec
, i
),
7733 TREE_VEC_ELT (argvec
, i
),
7734 UNIFY_ALLOW_NONE
, explain_p
))
7738 && unify_pack_expansion (tparms
, targs
,
7741 /*subr=*/true, explain_p
))
7748 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
7749 template template parameters. Both PARM_PARMS and ARG_PARMS are
7750 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
7753 Consider the example:
7754 template <class T> class A;
7755 template<template <class U> class TT> class B;
7757 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
7758 the parameters to A, and OUTER_ARGS contains A. */
7761 coerce_template_template_parms (tree parm_parms
,
7763 tsubst_flags_t complain
,
7767 int nparms
, nargs
, i
;
7771 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
7772 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
7774 nparms
= TREE_VEC_LENGTH (parm_parms
);
7775 nargs
= TREE_VEC_LENGTH (arg_parms
);
7779 /* P0522R0: A template template-parameter P is at least as specialized as
7780 a template template-argument A if, given the following rewrite to two
7781 function templates, the function template corresponding to P is at
7782 least as specialized as the function template corresponding to A
7783 according to the partial ordering rules for function templates
7784 ([temp.func.order]). Given an invented class template X with the
7785 template parameter list of A (including default arguments):
7787 * Each of the two function templates has the same template parameters,
7788 respectively, as P or A.
7790 * Each function template has a single function parameter whose type is
7791 a specialization of X with template arguments corresponding to the
7792 template parameters from the respective function template where, for
7793 each template parameter PP in the template parameter list of the
7794 function template, a corresponding template argument AA is formed. If
7795 PP declares a parameter pack, then AA is the pack expansion
7796 PP... ([temp.variadic]); otherwise, AA is the id-expression PP.
7798 If the rewrite produces an invalid type, then P is not at least as
7799 specialized as A. */
7801 /* So coerce P's args to apply to A's parms, and then deduce between A's
7802 args and the converted args. If that succeeds, A is at least as
7803 specialized as P, so they match.*/
7804 tree pargs
= template_parms_level_to_args (parm_parms
);
7805 pargs
= add_outermost_template_args (outer_args
, pargs
);
7806 ++processing_template_decl
;
7807 pargs
= coerce_template_parms (arg_parms
, pargs
, NULL_TREE
, tf_none
,
7808 /*require_all*/true, /*use_default*/true);
7809 --processing_template_decl
;
7810 if (pargs
!= error_mark_node
)
7812 tree targs
= make_tree_vec (nargs
);
7813 tree aargs
= template_parms_level_to_args (arg_parms
);
7814 if (!unify (arg_parms
, targs
, aargs
, pargs
, UNIFY_ALLOW_NONE
,
7820 /* Determine whether we have a parameter pack at the end of the
7821 template template parameter's template parameter list. */
7822 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
7824 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
7826 if (error_operand_p (parm
))
7829 switch (TREE_CODE (parm
))
7833 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
7838 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
7848 && !(variadic_p
&& nargs
>= nparms
- 1))
7851 /* Check all of the template parameters except the parameter pack at
7852 the end (if any). */
7853 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
7855 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
7856 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7859 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7860 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7862 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7870 /* Check each of the template parameters in the template
7871 argument against the template parameter pack at the end of
7872 the template template parameter. */
7873 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
7876 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7878 for (; i
< nargs
; ++i
)
7880 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7883 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7885 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7894 /* Verifies that the deduced template arguments (in TARGS) for the
7895 template template parameters (in TPARMS) represent valid bindings,
7896 by comparing the template parameter list of each template argument
7897 to the template parameter list of its corresponding template
7898 template parameter, in accordance with DR150. This
7899 routine can only be called after all template arguments have been
7900 deduced. It will return TRUE if all of the template template
7901 parameter bindings are okay, FALSE otherwise. */
7903 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
7905 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
7908 /* We're dealing with template parms in this process. */
7909 ++processing_template_decl
;
7911 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
7913 for (i
= 0; i
< ntparms
; ++i
)
7915 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
7916 tree targ
= TREE_VEC_ELT (targs
, i
);
7918 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
7920 tree packed_args
= NULL_TREE
;
7923 if (ARGUMENT_PACK_P (targ
))
7925 /* Look inside the argument pack. */
7926 packed_args
= ARGUMENT_PACK_ARGS (targ
);
7927 len
= TREE_VEC_LENGTH (packed_args
);
7930 for (idx
= 0; idx
< len
; ++idx
)
7932 tree targ_parms
= NULL_TREE
;
7935 /* Extract the next argument from the argument
7937 targ
= TREE_VEC_ELT (packed_args
, idx
);
7939 if (PACK_EXPANSION_P (targ
))
7940 /* Look at the pattern of the pack expansion. */
7941 targ
= PACK_EXPANSION_PATTERN (targ
);
7943 /* Extract the template parameters from the template
7945 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
7946 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
7947 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
7948 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
7950 /* Verify that we can coerce the template template
7951 parameters from the template argument to the template
7952 parameter. This requires an exact match. */
7954 && !coerce_template_template_parms
7955 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
7970 --processing_template_decl
;
7974 /* Since type attributes aren't mangled, we need to strip them from
7975 template type arguments. */
7978 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
7980 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
7982 bool removed_attributes
= false;
7983 tree canon
= strip_typedefs (arg
, &removed_attributes
);
7984 if (removed_attributes
7985 && (complain
& tf_warning
))
7986 warning (OPT_Wignored_attributes
,
7987 "ignoring attributes on template argument %qT", arg
);
7991 /* And from inside dependent non-type arguments like sizeof(Type). */
7994 canonicalize_expr_argument (tree arg
, tsubst_flags_t complain
)
7996 if (!arg
|| arg
== error_mark_node
)
7998 bool removed_attributes
= false;
7999 tree canon
= strip_typedefs_expr (arg
, &removed_attributes
);
8000 if (removed_attributes
8001 && (complain
& tf_warning
))
8002 warning (OPT_Wignored_attributes
,
8003 "ignoring attributes in template argument %qE", arg
);
8007 // A template declaration can be substituted for a constrained
8008 // template template parameter only when the argument is more
8009 // constrained than the parameter.
8011 is_compatible_template_arg (tree parm
, tree arg
)
8013 tree parm_cons
= get_constraints (parm
);
8015 /* For now, allow constrained template template arguments
8016 and unconstrained template template parameters. */
8017 if (parm_cons
== NULL_TREE
)
8020 /* If the template parameter is constrained, we need to rewrite its
8021 constraints in terms of the ARG's template parameters. This ensures
8022 that all of the template parameter types will have the same depth.
8024 Note that this is only valid when coerce_template_template_parm is
8025 true for the innermost template parameters of PARM and ARG. In other
8026 words, because coercion is successful, this conversion will be valid. */
8027 tree new_args
= NULL_TREE
;
8030 tree aparms
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
8031 new_args
= template_parms_level_to_args (aparms
);
8032 parm_cons
= tsubst_constraint_info (parm_cons
, new_args
,
8033 tf_none
, NULL_TREE
);
8034 if (parm_cons
== error_mark_node
)
8038 return weakly_subsumes (parm_cons
, new_args
, arg
);
8041 // Convert a placeholder argument into a binding to the original
8042 // parameter. The original parameter is saved as the TREE_TYPE of
8045 convert_wildcard_argument (tree parm
, tree arg
)
8047 TREE_TYPE (arg
) = parm
;
8051 /* We can't fully resolve ARG given as a non-type template argument to TYPE,
8052 because one of them is dependent. But we need to represent the
8053 conversion for the benefit of cp_tree_equal. */
8056 maybe_convert_nontype_argument (tree type
, tree arg
)
8058 /* Auto parms get no conversion. */
8059 if (type_uses_auto (type
))
8061 /* We don't need or want to add this conversion now if we're going to use the
8062 argument for deduction. */
8063 if (value_dependent_expression_p (arg
))
8066 type
= cv_unqualified (type
);
8067 tree argtype
= TREE_TYPE (arg
);
8068 if (same_type_p (type
, argtype
))
8071 arg
= build1 (IMPLICIT_CONV_EXPR
, type
, arg
);
8072 IMPLICIT_CONV_EXPR_NONTYPE_ARG (arg
) = true;
8076 /* Convert the indicated template ARG as necessary to match the
8077 indicated template PARM. Returns the converted ARG, or
8078 error_mark_node if the conversion was unsuccessful. Error and
8079 warning messages are issued under control of COMPLAIN. This
8080 conversion is for the Ith parameter in the parameter list. ARGS is
8081 the full set of template arguments deduced so far. */
8084 convert_template_argument (tree parm
,
8087 tsubst_flags_t complain
,
8093 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
8095 if (parm
== error_mark_node
|| error_operand_p (arg
))
8096 return error_mark_node
;
8098 /* Trivially convert placeholders. */
8099 if (TREE_CODE (arg
) == WILDCARD_DECL
)
8100 return convert_wildcard_argument (parm
, arg
);
8102 if (arg
== any_targ_node
)
8105 if (TREE_CODE (arg
) == TREE_LIST
8106 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
8108 /* The template argument was the name of some
8109 member function. That's usually
8110 invalid, but static members are OK. In any
8111 case, grab the underlying fields/functions
8112 and issue an error later if required. */
8113 TREE_TYPE (arg
) = unknown_type_node
;
8118 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
8119 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
8120 || requires_tmpl_type
);
8122 /* When determining whether an argument pack expansion is a template,
8123 look at the pattern. */
8124 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
8125 arg
= PACK_EXPANSION_PATTERN (arg
);
8127 /* Deal with an injected-class-name used as a template template arg. */
8128 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
8130 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
8131 if (TREE_CODE (t
) == TEMPLATE_DECL
)
8133 if (cxx_dialect
>= cxx11
)
8134 /* OK under DR 1004. */;
8135 else if (complain
& tf_warning_or_error
)
8136 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
8137 " used as template template argument", TYPE_NAME (arg
));
8138 else if (flag_pedantic_errors
)
8146 ((TREE_CODE (arg
) == TEMPLATE_DECL
8147 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
8148 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
8149 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
8150 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
8153 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
8154 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
8155 arg
= TYPE_STUB_DECL (arg
);
8157 is_type
= TYPE_P (arg
) || is_tmpl_type
;
8159 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
8160 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
8162 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
8164 if (complain
& tf_error
)
8165 error ("invalid use of destructor %qE as a type", orig_arg
);
8166 return error_mark_node
;
8169 permerror (input_location
,
8170 "to refer to a type member of a template parameter, "
8171 "use %<typename %E%>", orig_arg
);
8173 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
8174 TREE_OPERAND (arg
, 1),
8180 if (is_type
!= requires_type
)
8184 if (complain
& tf_error
)
8186 error ("type/value mismatch at argument %d in template "
8187 "parameter list for %qD",
8191 /* The template argument is a type, but we're expecting
8193 inform (input_location
,
8194 " expected a constant of type %qT, got %qT",
8196 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
8197 /* [temp.arg]/2: "In a template-argument, an ambiguity
8198 between a type-id and an expression is resolved to a
8199 type-id, regardless of the form of the corresponding
8200 template-parameter." So give the user a clue. */
8201 if (TREE_CODE (arg
) == FUNCTION_TYPE
)
8202 inform (input_location
, " ambiguous template argument "
8203 "for non-type template parameter is treated as "
8206 else if (requires_tmpl_type
)
8207 inform (input_location
,
8208 " expected a class template, got %qE", orig_arg
);
8210 inform (input_location
,
8211 " expected a type, got %qE", orig_arg
);
8214 return error_mark_node
;
8216 if (is_tmpl_type
^ requires_tmpl_type
)
8218 if (in_decl
&& (complain
& tf_error
))
8220 error ("type/value mismatch at argument %d in template "
8221 "parameter list for %qD",
8224 inform (input_location
,
8225 " expected a type, got %qT", DECL_NAME (arg
));
8227 inform (input_location
,
8228 " expected a class template, got %qT", orig_arg
);
8230 return error_mark_node
;
8233 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
8234 /* We already did the appropriate conversion when packing args. */
8238 if (requires_tmpl_type
)
8240 if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
8241 /* The number of argument required is not known yet.
8242 Just accept it for now. */
8246 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
8249 /* Strip alias templates that are equivalent to another
8251 arg
= get_underlying_template (arg
);
8252 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
8254 if (coerce_template_template_parms (parmparm
, argparm
,
8260 /* TEMPLATE_TEMPLATE_PARM node is preferred over
8262 if (val
!= error_mark_node
)
8264 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
8265 val
= TREE_TYPE (val
);
8266 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
8267 val
= make_pack_expansion (val
, complain
);
8272 if (in_decl
&& (complain
& tf_error
))
8274 error ("type/value mismatch at argument %d in "
8275 "template parameter list for %qD",
8277 inform (input_location
,
8278 " expected a template of type %qD, got %qT",
8282 val
= error_mark_node
;
8285 // Check that the constraints are compatible before allowing the
8287 if (val
!= error_mark_node
)
8288 if (!is_compatible_template_arg (parm
, arg
))
8290 if (in_decl
&& (complain
& tf_error
))
8292 error ("constraint mismatch at argument %d in "
8293 "template parameter list for %qD",
8295 inform (input_location
, " expected %qD but got %qD",
8298 val
= error_mark_node
;
8304 /* We only form one instance of each template specialization.
8305 Therefore, if we use a non-canonical variant (i.e., a
8306 typedef), any future messages referring to the type will use
8307 the typedef, which is confusing if those future uses do not
8308 themselves also use the typedef. */
8310 val
= canonicalize_type_argument (val
, complain
);
8314 tree t
= TREE_TYPE (parm
);
8316 if (TEMPLATE_PARM_LEVEL (get_template_parm_index (parm
))
8317 > TMPL_ARGS_DEPTH (args
))
8318 /* We don't have enough levels of args to do any substitution. This
8319 can happen in the context of -fnew-ttp-matching. */;
8320 else if (tree a
= type_uses_auto (t
))
8322 t
= do_auto_deduction (t
, arg
, a
, complain
, adc_unify
, args
);
8323 if (t
== error_mark_node
)
8324 return error_mark_node
;
8327 t
= tsubst (t
, args
, complain
, in_decl
);
8329 if (invalid_nontype_parm_type_p (t
, complain
))
8330 return error_mark_node
;
8332 if (t
!= TREE_TYPE (parm
))
8333 t
= canonicalize_type_argument (t
, complain
);
8335 if (!type_dependent_expression_p (orig_arg
)
8336 && !uses_template_parms (t
))
8337 /* We used to call digest_init here. However, digest_init
8338 will report errors, which we don't want when complain
8339 is zero. More importantly, digest_init will try too
8340 hard to convert things: for example, `0' should not be
8341 converted to pointer type at this point according to
8342 the standard. Accepting this is not merely an
8343 extension, since deciding whether or not these
8344 conversions can occur is part of determining which
8345 function template to call, or whether a given explicit
8346 argument specification is valid. */
8347 val
= convert_nontype_argument (t
, orig_arg
, complain
);
8350 val
= canonicalize_expr_argument (orig_arg
, complain
);
8351 val
= maybe_convert_nontype_argument (t
, val
);
8355 if (val
== NULL_TREE
)
8356 val
= error_mark_node
;
8357 else if (val
== error_mark_node
&& (complain
& tf_error
))
8358 error_at (cp_expr_loc_or_input_loc (orig_arg
),
8359 "could not convert template argument %qE from %qT to %qT",
8360 orig_arg
, TREE_TYPE (orig_arg
), t
);
8362 if (INDIRECT_REF_P (val
))
8364 /* Reject template arguments that are references to built-in
8365 functions with no library fallbacks. */
8366 const_tree inner
= TREE_OPERAND (val
, 0);
8367 const_tree innertype
= TREE_TYPE (inner
);
8369 && TYPE_REF_P (innertype
)
8370 && TREE_CODE (TREE_TYPE (innertype
)) == FUNCTION_TYPE
8371 && TREE_OPERAND_LENGTH (inner
) > 0
8372 && reject_gcc_builtin (TREE_OPERAND (inner
, 0)))
8373 return error_mark_node
;
8376 if (TREE_CODE (val
) == SCOPE_REF
)
8378 /* Strip typedefs from the SCOPE_REF. */
8379 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
8380 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
8382 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
8383 QUALIFIED_NAME_IS_TEMPLATE (val
));
8390 /* Coerces the remaining template arguments in INNER_ARGS (from
8391 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
8392 Returns the coerced argument pack. PARM_IDX is the position of this
8393 parameter in the template parameter list. ARGS is the original
8394 template argument list. */
8396 coerce_template_parameter_pack (tree parms
,
8404 tsubst_flags_t complain
)
8406 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
8407 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
8410 tree packed_parms
= NULL_TREE
;
8412 if (arg_idx
> nargs
)
8415 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
8417 /* When the template parameter is a non-type template parameter pack
8418 or template template parameter pack whose type or template
8419 parameters use parameter packs, we know exactly how many arguments
8420 we are looking for. Build a vector of the instantiated decls for
8421 these template parameters in PACKED_PARMS. */
8422 /* We can't use make_pack_expansion here because it would interpret a
8423 _DECL as a use rather than a declaration. */
8424 tree decl
= TREE_VALUE (parm
);
8425 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
8426 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
8427 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
8428 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
8430 TREE_VEC_LENGTH (args
)--;
8431 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
8432 TREE_VEC_LENGTH (args
)++;
8434 if (packed_parms
== error_mark_node
)
8435 return error_mark_node
;
8437 /* If we're doing a partial instantiation of a member template,
8438 verify that all of the types used for the non-type
8439 template parameter pack are, in fact, valid for non-type
8440 template parameters. */
8442 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
8444 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
8445 for (j
= 0; j
< len
; ++j
)
8447 tree t
= TREE_VEC_ELT (packed_parms
, j
);
8448 if (TREE_CODE (t
) == PARM_DECL
8449 && invalid_nontype_parm_type_p (TREE_TYPE (t
), complain
))
8450 return error_mark_node
;
8452 /* We don't know how many args we have yet, just
8453 use the unconverted ones for now. */
8457 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
8459 /* Check if we have a placeholder pack, which indicates we're
8460 in the context of a introduction list. In that case we want
8461 to match this pack to the single placeholder. */
8462 else if (arg_idx
< nargs
8463 && TREE_CODE (TREE_VEC_ELT (inner_args
, arg_idx
)) == WILDCARD_DECL
8464 && WILDCARD_PACK_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
8466 nargs
= arg_idx
+ 1;
8467 packed_args
= make_tree_vec (1);
8470 packed_args
= make_tree_vec (nargs
- arg_idx
);
8472 /* Convert the remaining arguments, which will be a part of the
8473 parameter pack "parm". */
8474 int first_pack_arg
= arg_idx
;
8475 for (; arg_idx
< nargs
; ++arg_idx
)
8477 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
8478 tree actual_parm
= TREE_VALUE (parm
);
8479 int pack_idx
= arg_idx
- first_pack_arg
;
8483 /* Once we've packed as many args as we have types, stop. */
8484 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
8486 else if (PACK_EXPANSION_P (arg
))
8487 /* We don't know how many args we have yet, just
8488 use the unconverted ones for now. */
8491 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
8494 if (arg
== error_mark_node
)
8496 if (complain
& tf_error
)
8497 error ("template argument %d is invalid", arg_idx
+ 1);
8500 arg
= convert_template_argument (actual_parm
,
8501 arg
, new_args
, complain
, parm_idx
,
8503 if (arg
== error_mark_node
)
8505 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
8508 if (arg_idx
- first_pack_arg
< TREE_VEC_LENGTH (packed_args
)
8509 && TREE_VEC_LENGTH (packed_args
) > 0)
8511 if (complain
& tf_error
)
8512 error ("wrong number of template arguments (%d, should be %d)",
8513 arg_idx
- first_pack_arg
, TREE_VEC_LENGTH (packed_args
));
8514 return error_mark_node
;
8517 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
8518 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
8519 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
8522 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
8523 TREE_CONSTANT (argument_pack
) = 1;
8526 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
8528 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
8529 TREE_VEC_LENGTH (packed_args
));
8530 return argument_pack
;
8533 /* Returns the number of pack expansions in the template argument vector
8537 pack_expansion_args_count (tree args
)
8542 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
8544 tree elt
= TREE_VEC_ELT (args
, i
);
8545 if (elt
&& PACK_EXPANSION_P (elt
))
8551 /* Convert all template arguments to their appropriate types, and
8552 return a vector containing the innermost resulting template
8553 arguments. If any error occurs, return error_mark_node. Error and
8554 warning messages are issued under control of COMPLAIN.
8556 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
8557 for arguments not specified in ARGS. Otherwise, if
8558 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
8559 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
8560 USE_DEFAULT_ARGS is false, then all arguments must be specified in
8564 coerce_template_parms (tree parms
,
8567 tsubst_flags_t complain
,
8568 bool require_all_args
,
8569 bool use_default_args
)
8571 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
8572 tree orig_inner_args
;
8575 tree new_inner_args
;
8577 /* When used as a boolean value, indicates whether this is a
8578 variadic template parameter list. Since it's an int, we can also
8579 subtract it from nparms to get the number of non-variadic
8582 int variadic_args_p
= 0;
8583 int post_variadic_parms
= 0;
8585 /* Adjustment to nparms for fixed parameter packs. */
8586 int fixed_pack_adjust
= 0;
8587 int fixed_packs
= 0;
8590 /* Likewise for parameters with default arguments. */
8593 if (args
== error_mark_node
)
8594 return error_mark_node
;
8596 nparms
= TREE_VEC_LENGTH (parms
);
8598 /* Determine if there are any parameter packs or default arguments. */
8599 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
8601 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
8603 ++post_variadic_parms
;
8604 if (template_parameter_pack_p (TREE_VALUE (parm
)))
8606 if (TREE_PURPOSE (parm
))
8610 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
8611 /* If there are no parameters that follow a parameter pack, we need to
8612 expand any argument packs so that we can deduce a parameter pack from
8613 some non-packed args followed by an argument pack, as in variadic85.C.
8614 If there are such parameters, we need to leave argument packs intact
8615 so the arguments are assigned properly. This can happen when dealing
8616 with a nested class inside a partial specialization of a class
8617 template, as in variadic92.C, or when deducing a template parameter pack
8618 from a sub-declarator, as in variadic114.C. */
8619 if (!post_variadic_parms
)
8620 inner_args
= expand_template_argument_pack (inner_args
);
8622 /* Count any pack expansion args. */
8623 variadic_args_p
= pack_expansion_args_count (inner_args
);
8625 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
8626 if ((nargs
- variadic_args_p
> nparms
&& !variadic_p
)
8627 || (nargs
< nparms
- variadic_p
8630 && (!use_default_args
8631 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
8632 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
8635 if (complain
& tf_error
)
8637 if (variadic_p
|| default_p
)
8639 nparms
-= variadic_p
+ default_p
;
8640 error ("wrong number of template arguments "
8641 "(%d, should be at least %d)", nargs
, nparms
);
8644 error ("wrong number of template arguments "
8645 "(%d, should be %d)", nargs
, nparms
);
8648 inform (DECL_SOURCE_LOCATION (in_decl
),
8649 "provided for %qD", in_decl
);
8652 return error_mark_node
;
8654 /* We can't pass a pack expansion to a non-pack parameter of an alias
8655 template (DR 1430). */
8657 && (DECL_ALIAS_TEMPLATE_P (in_decl
)
8658 || concept_definition_p (in_decl
))
8660 && nargs
- variadic_args_p
< nparms
- variadic_p
)
8662 if (complain
& tf_error
)
8664 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
8666 tree arg
= TREE_VEC_ELT (inner_args
, i
);
8667 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
8669 if (PACK_EXPANSION_P (arg
)
8670 && !template_parameter_pack_p (parm
))
8672 if (DECL_ALIAS_TEMPLATE_P (in_decl
))
8673 error_at (location_of (arg
),
8674 "pack expansion argument for non-pack parameter "
8675 "%qD of alias template %qD", parm
, in_decl
);
8677 error_at (location_of (arg
),
8678 "pack expansion argument for non-pack parameter "
8679 "%qD of concept %qD", parm
, in_decl
);
8680 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
8687 return error_mark_node
;
8690 /* We need to evaluate the template arguments, even though this
8691 template-id may be nested within a "sizeof". */
8694 new_inner_args
= make_tree_vec (nparms
);
8695 new_args
= add_outermost_template_args (args
, new_inner_args
);
8696 int pack_adjust
= 0;
8697 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
8702 /* Get the Ith template parameter. */
8703 parm
= TREE_VEC_ELT (parms
, parm_idx
);
8705 if (parm
== error_mark_node
)
8707 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
8711 /* Calculate the next argument. */
8712 if (arg_idx
< nargs
)
8713 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
8717 if (template_parameter_pack_p (TREE_VALUE (parm
))
8718 && (arg
|| require_all_args
|| !(complain
& tf_partial
))
8719 && !(arg
&& ARGUMENT_PACK_P (arg
)))
8721 /* Some arguments will be placed in the
8722 template parameter pack PARM. */
8723 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
8724 inner_args
, arg_idx
,
8728 if (arg
== NULL_TREE
)
8730 /* We don't know how many args we have yet, just use the
8731 unconverted (and still packed) ones for now. */
8732 new_inner_args
= orig_inner_args
;
8737 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
8739 /* Store this argument. */
8740 if (arg
== error_mark_node
)
8743 /* We are done with all of the arguments. */
8749 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
8750 arg_idx
+= pack_adjust
;
8751 if (fixed_parameter_pack_p (TREE_VALUE (parm
)))
8754 fixed_pack_adjust
+= pack_adjust
;
8762 if (PACK_EXPANSION_P (arg
))
8764 /* "If every valid specialization of a variadic template
8765 requires an empty template parameter pack, the template is
8766 ill-formed, no diagnostic required." So check that the
8767 pattern works with this parameter. */
8768 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
8769 tree conv
= convert_template_argument (TREE_VALUE (parm
),
8773 if (conv
== error_mark_node
)
8775 if (complain
& tf_error
)
8776 inform (input_location
, "so any instantiation with a "
8777 "non-empty parameter pack would be ill-formed");
8780 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
8781 /* Recover from missing typename. */
8782 TREE_VEC_ELT (inner_args
, arg_idx
)
8783 = make_pack_expansion (conv
, complain
);
8785 /* We don't know how many args we have yet, just
8786 use the unconverted ones for now. */
8787 new_inner_args
= inner_args
;
8792 else if (require_all_args
)
8794 /* There must be a default arg in this case. */
8795 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
8797 /* The position of the first default template argument,
8798 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
8800 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8801 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8802 arg_idx
- pack_adjust
);
8807 if (arg
== error_mark_node
)
8809 if (complain
& tf_error
)
8810 error ("template argument %d is invalid", arg_idx
+ 1);
8814 /* This can occur if there was an error in the template
8815 parameter list itself (which we would already have
8816 reported) that we are trying to recover from, e.g., a class
8817 template with a parameter list such as
8818 template<typename..., typename> (cpp0x/variadic150.C). */
8821 /* This can also happen with a fixed parameter pack (71834). */
8822 if (arg_idx
>= nargs
)
8826 arg
= convert_template_argument (TREE_VALUE (parm
),
8827 arg
, new_args
, complain
,
8830 if (arg
== error_mark_node
)
8833 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
8836 if (missing
|| arg_idx
< nargs
- variadic_args_p
)
8838 /* If we had fixed parameter packs, we didn't know how many arguments we
8839 actually needed earlier; now we do. */
8840 nparms
+= fixed_pack_adjust
;
8841 variadic_p
-= fixed_packs
;
8845 if (arg_idx
< nargs
)
8847 /* We had some pack expansion arguments that will only work if the packs
8848 are empty, but wait until instantiation time to complain.
8849 See variadic-ttp3.C. */
8851 /* Except that we can't provide empty packs to alias templates or
8852 concepts when there are no corresponding parameters. Basically,
8853 we can get here with this:
8855 template<typename T> concept C = true;
8857 template<typename... Args>
8861 When parsing C<Args...>, we try to form a concept check of
8862 C<?, Args...>. Without the extra check for substituting an empty
8863 pack past the last parameter, we can accept the check as valid.
8865 FIXME: This may be valid for alias templates (but I doubt it).
8867 FIXME: The error could be better also. */
8868 if (in_decl
&& concept_definition_p (in_decl
))
8870 if (complain
& tf_error
)
8871 error_at (location_of (TREE_VEC_ELT (args
, arg_idx
)),
8872 "too many arguments");
8873 return error_mark_node
;
8876 int len
= nparms
+ (nargs
- arg_idx
);
8877 tree args
= make_tree_vec (len
);
8879 for (; i
< nparms
; ++i
)
8880 TREE_VEC_ELT (args
, i
) = TREE_VEC_ELT (new_inner_args
, i
);
8881 for (; i
< len
; ++i
, ++arg_idx
)
8882 TREE_VEC_ELT (args
, i
) = TREE_VEC_ELT (inner_args
,
8883 arg_idx
- pack_adjust
);
8884 new_inner_args
= args
;
8889 gcc_assert (!(complain
& tf_error
) || seen_error ());
8890 return error_mark_node
;
8893 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8894 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8895 TREE_VEC_LENGTH (new_inner_args
));
8897 return new_inner_args
;
8900 /* Convert all template arguments to their appropriate types, and
8901 return a vector containing the innermost resulting template
8902 arguments. If any error occurs, return error_mark_node. Error and
8903 warning messages are not issued.
8905 Note that no function argument deduction is performed, and default
8906 arguments are used to fill in unspecified arguments. */
8908 coerce_template_parms (tree parms
, tree args
, tree in_decl
)
8910 return coerce_template_parms (parms
, args
, in_decl
, tf_none
, true, true);
8913 /* Convert all template arguments to their appropriate type, and
8914 instantiate default arguments as needed. This returns a vector
8915 containing the innermost resulting template arguments, or
8916 error_mark_node if unsuccessful. */
8918 coerce_template_parms (tree parms
, tree args
, tree in_decl
,
8919 tsubst_flags_t complain
)
8921 return coerce_template_parms (parms
, args
, in_decl
, complain
, true, true);
8924 /* Like coerce_template_parms. If PARMS represents all template
8925 parameters levels, this function returns a vector of vectors
8926 representing all the resulting argument levels. Note that in this
8927 case, only the innermost arguments are coerced because the
8928 outermost ones are supposed to have been coerced already.
8930 Otherwise, if PARMS represents only (the innermost) vector of
8931 parameters, this function returns a vector containing just the
8932 innermost resulting arguments. */
8935 coerce_innermost_template_parms (tree parms
,
8938 tsubst_flags_t complain
,
8939 bool require_all_args
,
8940 bool use_default_args
)
8942 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
8943 int args_depth
= TMPL_ARGS_DEPTH (args
);
8946 if (parms_depth
> 1)
8948 coerced_args
= make_tree_vec (parms_depth
);
8952 for (level
= parms
, cur_depth
= parms_depth
;
8953 parms_depth
> 0 && level
!= NULL_TREE
;
8954 level
= TREE_CHAIN (level
), --cur_depth
)
8957 if (cur_depth
== args_depth
)
8958 l
= coerce_template_parms (TREE_VALUE (level
),
8959 args
, in_decl
, complain
,
8963 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
8965 if (l
== error_mark_node
)
8966 return error_mark_node
;
8968 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
8972 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
8973 args
, in_decl
, complain
,
8976 return coerced_args
;
8979 /* Returns 1 if template args OT and NT are equivalent. */
8982 template_args_equal (tree ot
, tree nt
, bool partial_order
/* = false */)
8986 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
8988 if (nt
== any_targ_node
|| ot
== any_targ_node
)
8991 if (TREE_CODE (nt
) == TREE_VEC
)
8992 /* For member templates */
8993 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
8994 else if (PACK_EXPANSION_P (ot
))
8995 return (PACK_EXPANSION_P (nt
)
8996 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
8997 PACK_EXPANSION_PATTERN (nt
))
8998 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
8999 PACK_EXPANSION_EXTRA_ARGS (nt
)));
9000 else if (ARGUMENT_PACK_P (ot
))
9005 if (!ARGUMENT_PACK_P (nt
))
9008 opack
= ARGUMENT_PACK_ARGS (ot
);
9009 npack
= ARGUMENT_PACK_ARGS (nt
);
9010 len
= TREE_VEC_LENGTH (opack
);
9011 if (TREE_VEC_LENGTH (npack
) != len
)
9013 for (i
= 0; i
< len
; ++i
)
9014 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
9015 TREE_VEC_ELT (npack
, i
)))
9019 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
9021 else if (TYPE_P (nt
))
9025 /* Don't treat an alias template specialization with dependent
9026 arguments as equivalent to its underlying type when used as a
9027 template argument; we need them to be distinct so that we
9028 substitute into the specialization arguments at instantiation
9029 time. And aliases can't be equivalent without being ==, so
9030 we don't need to look any deeper.
9032 During partial ordering, however, we need to treat them normally so
9033 that we can order uses of the same alias with different
9034 cv-qualification (79960). */
9036 && (TYPE_ALIAS_P (nt
) || TYPE_ALIAS_P (ot
)))
9039 return same_type_p (ot
, nt
);
9041 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
9045 /* Try to treat a template non-type argument that has been converted
9046 to the parameter type as equivalent to one that hasn't yet. */
9047 for (enum tree_code code1
= TREE_CODE (ot
);
9048 CONVERT_EXPR_CODE_P (code1
)
9049 || code1
== NON_LVALUE_EXPR
;
9050 code1
= TREE_CODE (ot
))
9051 ot
= TREE_OPERAND (ot
, 0);
9052 for (enum tree_code code2
= TREE_CODE (nt
);
9053 CONVERT_EXPR_CODE_P (code2
)
9054 || code2
== NON_LVALUE_EXPR
;
9055 code2
= TREE_CODE (nt
))
9056 nt
= TREE_OPERAND (nt
, 0);
9058 return cp_tree_equal (ot
, nt
);
9062 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
9063 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
9064 NEWARG_PTR with the offending arguments if they are non-NULL. */
9067 comp_template_args (tree oldargs
, tree newargs
,
9068 tree
*oldarg_ptr
, tree
*newarg_ptr
,
9073 if (oldargs
== newargs
)
9076 if (!oldargs
|| !newargs
)
9079 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
9082 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
9084 tree nt
= TREE_VEC_ELT (newargs
, i
);
9085 tree ot
= TREE_VEC_ELT (oldargs
, i
);
9087 if (! template_args_equal (ot
, nt
, partial_order
))
9089 if (oldarg_ptr
!= NULL
)
9091 if (newarg_ptr
!= NULL
)
9100 comp_template_args_porder (tree oargs
, tree nargs
)
9102 return comp_template_args (oargs
, nargs
, NULL
, NULL
, true);
9105 /* Implement a freelist interface for objects of type T.
9107 Head is a separate object, rather than a regular member, so that we
9108 can define it as a GTY deletable pointer, which is highly
9109 desirable. A data member could be declared that way, but then the
9110 containing object would implicitly get GTY((user)), which would
9111 prevent us from instantiating freelists as global objects.
9112 Although this way we can create freelist global objects, they're
9113 such thin wrappers that instantiating temporaries at every use
9114 loses nothing and saves permanent storage for the freelist object.
9116 Member functions next, anew, poison and reinit have default
9117 implementations that work for most of the types we're interested
9118 in, but if they don't work for some type, they should be explicitly
9119 specialized. See the comments before them for requirements, and
9120 the example specializations for the tree_list_freelist. */
9121 template <typename T
>
9124 /* Return the next object in a chain. We could just do type
9125 punning, but if we access the object with its underlying type, we
9126 avoid strict-aliasing trouble. This needs only work between
9127 poison and reinit. */
9128 static T
*&next (T
*obj
) { return obj
->next
; }
9130 /* Return a newly allocated, uninitialized or minimally-initialized
9131 object of type T. Any initialization performed by anew should
9132 either remain across the life of the object and the execution of
9133 poison, or be redone by reinit. */
9134 static T
*anew () { return ggc_alloc
<T
> (); }
9136 /* Optionally scribble all over the bits holding the object, so that
9137 they become (mostly?) uninitialized memory. This is called while
9138 preparing to make the object part of the free list. */
9139 static void poison (T
*obj
) {
9140 T
*p ATTRIBUTE_UNUSED
= obj
;
9141 T
**q ATTRIBUTE_UNUSED
= &next (obj
);
9143 #ifdef ENABLE_GC_CHECKING
9144 /* Poison the data, to indicate the data is garbage. */
9145 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (p
, sizeof (*p
)));
9146 memset (p
, 0xa5, sizeof (*p
));
9148 /* Let valgrind know the object is free. */
9149 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (p
, sizeof (*p
)));
9151 /* Let valgrind know the next portion of the object is available,
9152 but uninitialized. */
9153 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (q
, sizeof (*q
)));
9156 /* Bring an object that underwent at least one lifecycle after anew
9157 and before the most recent free and poison, back to a usable
9158 state, reinitializing whatever is needed for it to be
9159 functionally equivalent to an object just allocated and returned
9160 by anew. This may poison or clear the next field, used by
9161 freelist housekeeping after poison was called. */
9162 static void reinit (T
*obj
) {
9163 T
**q ATTRIBUTE_UNUSED
= &next (obj
);
9165 #ifdef ENABLE_GC_CHECKING
9166 memset (q
, 0xa5, sizeof (*q
));
9168 /* Let valgrind know the entire object is available, but
9170 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (*obj
)));
9173 /* Reference a GTY-deletable pointer that points to the first object
9174 in the free list proper. */
9177 /* Construct a freelist object chaining objects off of HEAD. */
9178 freelist (T
*&head
) : head(head
) {}
9180 /* Add OBJ to the free object list. The former head becomes OBJ's
9189 /* Take an object from the free list, if one is available, or
9190 allocate a new one. Objects taken from the free list should be
9191 regarded as filled with garbage, except for bits that are
9192 configured to be preserved across free and alloc. */
9207 /* Explicitly specialize the interfaces for freelist<tree_node>: we
9208 want to allocate a TREE_LIST using the usual interface, and ensure
9209 TREE_CHAIN remains functional. Alas, we have to duplicate a bit of
9210 build_tree_list logic in reinit, so this could go out of sync. */
9213 freelist
<tree_node
>::next (tree obj
)
9215 return TREE_CHAIN (obj
);
9219 freelist
<tree_node
>::anew ()
9221 return build_tree_list (NULL
, NULL
);
9225 freelist
<tree_node
>::poison (tree obj ATTRIBUTE_UNUSED
)
9227 int size ATTRIBUTE_UNUSED
= sizeof (tree_list
);
9228 tree p ATTRIBUTE_UNUSED
= obj
;
9229 tree_base
*b ATTRIBUTE_UNUSED
= &obj
->base
;
9230 tree
*q ATTRIBUTE_UNUSED
= &next (obj
);
9232 #ifdef ENABLE_GC_CHECKING
9233 gcc_checking_assert (TREE_CODE (obj
) == TREE_LIST
);
9235 /* Poison the data, to indicate the data is garbage. */
9236 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (p
, size
));
9237 memset (p
, 0xa5, size
);
9239 /* Let valgrind know the object is free. */
9240 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (p
, size
));
9241 /* But we still want to use the TREE_CODE and TREE_CHAIN parts. */
9242 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
9243 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (q
, sizeof (*q
)));
9245 #ifdef ENABLE_GC_CHECKING
9246 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (b
, sizeof (*b
)));
9247 /* Keep TREE_CHAIN functional. */
9248 TREE_SET_CODE (obj
, TREE_LIST
);
9250 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
9255 freelist
<tree_node
>::reinit (tree obj ATTRIBUTE_UNUSED
)
9257 tree_base
*b ATTRIBUTE_UNUSED
= &obj
->base
;
9259 #ifdef ENABLE_GC_CHECKING
9260 gcc_checking_assert (TREE_CODE (obj
) == TREE_LIST
);
9261 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (tree_list
)));
9262 memset (obj
, 0, sizeof (tree_list
));
9265 /* Let valgrind know the entire object is available, but
9267 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (tree_list
)));
9269 #ifdef ENABLE_GC_CHECKING
9270 TREE_SET_CODE (obj
, TREE_LIST
);
9272 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
9276 /* Point to the first object in the TREE_LIST freelist. */
9277 static GTY((deletable
)) tree tree_list_freelist_head
;
9278 /* Return the/an actual TREE_LIST freelist. */
9279 static inline freelist
<tree_node
>
9280 tree_list_freelist ()
9282 return tree_list_freelist_head
;
9285 /* Point to the first object in the tinst_level freelist. */
9286 static GTY((deletable
)) tinst_level
*tinst_level_freelist_head
;
9287 /* Return the/an actual tinst_level freelist. */
9288 static inline freelist
<tinst_level
>
9289 tinst_level_freelist ()
9291 return tinst_level_freelist_head
;
9294 /* Point to the first object in the pending_template freelist. */
9295 static GTY((deletable
)) pending_template
*pending_template_freelist_head
;
9296 /* Return the/an actual pending_template freelist. */
9297 static inline freelist
<pending_template
>
9298 pending_template_freelist ()
9300 return pending_template_freelist_head
;
9303 /* Build the TREE_LIST object out of a split list, store it
9304 permanently, and return it. */
9306 tinst_level::to_list ()
9308 gcc_assert (split_list_p ());
9309 tree ret
= tree_list_freelist ().alloc ();
9310 TREE_PURPOSE (ret
) = tldcl
;
9311 TREE_VALUE (ret
) = targs
;
9314 gcc_assert (tree_list_p ());
9318 const unsigned short tinst_level::refcount_infinity
;
9320 /* Increment OBJ's refcount unless it is already infinite. */
9321 static tinst_level
*
9322 inc_refcount_use (tinst_level
*obj
)
9324 if (obj
&& obj
->refcount
!= tinst_level::refcount_infinity
)
9329 /* Release storage for OBJ and node, if it's a TREE_LIST. */
9331 tinst_level::free (tinst_level
*obj
)
9333 if (obj
->tree_list_p ())
9334 tree_list_freelist ().free (obj
->get_node ());
9335 tinst_level_freelist ().free (obj
);
9338 /* Decrement OBJ's refcount if not infinite. If it reaches zero, release
9339 OBJ's DECL and OBJ, and start over with the tinst_level object that
9340 used to be referenced by OBJ's NEXT. */
9342 dec_refcount_use (tinst_level
*obj
)
9345 && obj
->refcount
!= tinst_level::refcount_infinity
9346 && !--obj
->refcount
)
9348 tinst_level
*next
= obj
->next
;
9349 tinst_level::free (obj
);
9354 /* Modify PTR so that it points to OBJ, adjusting the refcounts of OBJ
9355 and of the former PTR. Omitting the second argument is equivalent
9356 to passing (T*)NULL; this is allowed because passing the
9357 zero-valued integral constant NULL confuses type deduction and/or
9358 overload resolution. */
9359 template <typename T
>
9361 set_refcount_ptr (T
*& ptr
, T
*obj
= NULL
)
9364 ptr
= inc_refcount_use (obj
);
9365 dec_refcount_use (save
);
9369 add_pending_template (tree d
)
9371 tree ti
= (TYPE_P (d
)
9372 ? CLASSTYPE_TEMPLATE_INFO (d
)
9373 : DECL_TEMPLATE_INFO (d
));
9374 struct pending_template
*pt
;
9377 if (TI_PENDING_TEMPLATE_FLAG (ti
))
9380 /* We are called both from instantiate_decl, where we've already had a
9381 tinst_level pushed, and instantiate_template, where we haven't.
9383 gcc_assert (TREE_CODE (d
) != TREE_LIST
);
9384 level
= !current_tinst_level
9385 || current_tinst_level
->maybe_get_node () != d
;
9388 push_tinst_level (d
);
9390 pt
= pending_template_freelist ().alloc ();
9393 set_refcount_ptr (pt
->tinst
, current_tinst_level
);
9394 if (last_pending_template
)
9395 last_pending_template
->next
= pt
;
9397 pending_templates
= pt
;
9399 last_pending_template
= pt
;
9401 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
9408 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
9409 ARGLIST. Valid choices for FNS are given in the cp-tree.def
9410 documentation for TEMPLATE_ID_EXPR. */
9413 lookup_template_function (tree fns
, tree arglist
)
9415 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
9416 return error_mark_node
;
9418 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
9420 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
9422 error ("%q#D is not a function template", fns
);
9423 return error_mark_node
;
9426 if (BASELINK_P (fns
))
9428 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
9430 BASELINK_FUNCTIONS (fns
),
9435 return build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fns
, arglist
);
9438 /* Within the scope of a template class S<T>, the name S gets bound
9439 (in build_self_reference) to a TYPE_DECL for the class, not a
9440 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
9441 or one of its enclosing classes, and that type is a template,
9442 return the associated TEMPLATE_DECL. Otherwise, the original
9445 Also handle the case when DECL is a TREE_LIST of ambiguous
9446 injected-class-names from different bases. */
9449 maybe_get_template_decl_from_type_decl (tree decl
)
9451 if (decl
== NULL_TREE
)
9454 /* DR 176: A lookup that finds an injected-class-name (10.2
9455 [class.member.lookup]) can result in an ambiguity in certain cases
9456 (for example, if it is found in more than one base class). If all of
9457 the injected-class-names that are found refer to specializations of
9458 the same class template, and if the name is followed by a
9459 template-argument-list, the reference refers to the class template
9460 itself and not a specialization thereof, and is not ambiguous. */
9461 if (TREE_CODE (decl
) == TREE_LIST
)
9463 tree t
, tmpl
= NULL_TREE
;
9464 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
9466 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
9469 else if (tmpl
!= elt
)
9472 if (tmpl
&& t
== NULL_TREE
)
9478 return (decl
!= NULL_TREE
9479 && DECL_SELF_REFERENCE_P (decl
)
9480 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
9481 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
9484 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
9485 parameters, find the desired type.
9487 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
9489 IN_DECL, if non-NULL, is the template declaration we are trying to
9492 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
9493 the class we are looking up.
9495 Issue error and warning messages under control of COMPLAIN.
9497 If the template class is really a local class in a template
9498 function, then the FUNCTION_CONTEXT is the function in which it is
9501 ??? Note that this function is currently called *twice* for each
9502 template-id: the first time from the parser, while creating the
9503 incomplete type (finish_template_type), and the second type during the
9504 real instantiation (instantiate_template_class). This is surely something
9505 that we want to avoid. It also causes some problems with argument
9506 coercion (see convert_nontype_argument for more information on this). */
9509 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
9510 int entering_scope
, tsubst_flags_t complain
)
9512 tree templ
= NULL_TREE
, parmlist
;
9519 if (identifier_p (d1
))
9521 tree value
= innermost_non_namespace_value (d1
);
9522 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
9527 push_decl_namespace (context
);
9528 templ
= lookup_name (d1
);
9529 templ
= maybe_get_template_decl_from_type_decl (templ
);
9531 pop_decl_namespace ();
9534 context
= DECL_CONTEXT (templ
);
9536 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
9538 tree type
= TREE_TYPE (d1
);
9540 /* If we are declaring a constructor, say A<T>::A<T>, we will get
9541 an implicit typename for the second A. Deal with it. */
9542 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
9543 type
= TREE_TYPE (type
);
9545 if (CLASSTYPE_TEMPLATE_INFO (type
))
9547 templ
= CLASSTYPE_TI_TEMPLATE (type
);
9548 d1
= DECL_NAME (templ
);
9551 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
9552 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
9554 templ
= TYPE_TI_TEMPLATE (d1
);
9555 d1
= DECL_NAME (templ
);
9557 else if (DECL_TYPE_TEMPLATE_P (d1
))
9560 d1
= DECL_NAME (templ
);
9561 context
= DECL_CONTEXT (templ
);
9563 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
9566 d1
= DECL_NAME (templ
);
9569 /* Issue an error message if we didn't find a template. */
9572 if (complain
& tf_error
)
9573 error ("%qT is not a template", d1
);
9574 return error_mark_node
;
9577 if (TREE_CODE (templ
) != TEMPLATE_DECL
9578 /* Make sure it's a user visible template, if it was named by
9580 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
9581 && !PRIMARY_TEMPLATE_P (templ
)))
9583 if (complain
& tf_error
)
9585 error ("non-template type %qT used as a template", d1
);
9587 error ("for template declaration %q+D", in_decl
);
9589 return error_mark_node
;
9592 complain
&= ~tf_user
;
9594 /* An alias that just changes the name of a template is equivalent to the
9595 other template, so if any of the arguments are pack expansions, strip
9596 the alias to avoid problems with a pack expansion passed to a non-pack
9597 alias template parameter (DR 1430). */
9598 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
9599 templ
= get_underlying_template (templ
);
9601 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
9604 tree arglist2
= coerce_template_args_for_ttp (templ
, arglist
, complain
);
9605 if (arglist2
== error_mark_node
9606 || (!uses_template_parms (arglist2
)
9607 && check_instantiated_args (templ
, arglist2
, complain
)))
9608 return error_mark_node
;
9610 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
9615 tree template_type
= TREE_TYPE (templ
);
9618 tree found
= NULL_TREE
;
9621 int is_dependent_type
;
9622 int use_partial_inst_tmpl
= false;
9624 if (template_type
== error_mark_node
)
9625 /* An error occurred while building the template TEMPL, and a
9626 diagnostic has most certainly been emitted for that
9627 already. Let's propagate that error. */
9628 return error_mark_node
;
9630 gen_tmpl
= most_general_template (templ
);
9631 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
9632 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
9633 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
9635 if (arg_depth
== 1 && parm_depth
> 1)
9637 /* We've been given an incomplete set of template arguments.
9640 template <class T> struct S1 {
9641 template <class U> struct S2 {};
9642 template <class U> struct S2<U*> {};
9645 we will be called with an ARGLIST of `U*', but the
9646 TEMPLATE will be `template <class T> template
9647 <class U> struct S1<T>::S2'. We must fill in the missing
9649 tree ti
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (templ
));
9650 arglist
= add_outermost_template_args (TI_ARGS (ti
), arglist
);
9651 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
9654 /* Now we should have enough arguments. */
9655 gcc_assert (parm_depth
== arg_depth
);
9657 /* From here on, we're only interested in the most general
9660 /* Calculate the BOUND_ARGS. These will be the args that are
9661 actually tsubst'd into the definition to create the
9663 arglist
= coerce_innermost_template_parms (parmlist
, arglist
, gen_tmpl
,
9665 /*require_all_args=*/true,
9666 /*use_default_args=*/true);
9668 if (arglist
== error_mark_node
)
9669 /* We were unable to bind the arguments. */
9670 return error_mark_node
;
9672 /* In the scope of a template class, explicit references to the
9673 template class refer to the type of the template, not any
9674 instantiation of it. For example, in:
9676 template <class T> class C { void f(C<T>); }
9678 the `C<T>' is just the same as `C'. Outside of the
9679 class, however, such a reference is an instantiation. */
9681 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
9682 || currently_open_class (template_type
))
9684 tree tinfo
= TYPE_TEMPLATE_INFO (template_type
);
9686 if (tinfo
&& comp_template_args (TI_ARGS (tinfo
), arglist
))
9687 return template_type
;
9690 /* If we already have this specialization, return it. */
9691 elt
.tmpl
= gen_tmpl
;
9693 elt
.spec
= NULL_TREE
;
9694 hash
= spec_hasher::hash (&elt
);
9695 entry
= type_specializations
->find_with_hash (&elt
, hash
);
9700 /* If the the template's constraints are not satisfied,
9701 then we cannot form a valid type.
9703 Note that the check is deferred until after the hash
9704 lookup. This prevents redundant checks on previously
9705 instantiated specializations. */
9707 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
)
9708 && !constraints_satisfied_p (gen_tmpl
, arglist
))
9710 if (complain
& tf_error
)
9712 auto_diagnostic_group d
;
9713 error ("template constraint failure for %qD", gen_tmpl
);
9714 diagnose_constraints (input_location
, gen_tmpl
, arglist
);
9716 return error_mark_node
;
9719 is_dependent_type
= uses_template_parms (arglist
);
9721 /* If the deduced arguments are invalid, then the binding
9723 if (!is_dependent_type
9724 && check_instantiated_args (gen_tmpl
,
9725 INNERMOST_TEMPLATE_ARGS (arglist
),
9727 return error_mark_node
;
9729 if (!is_dependent_type
9730 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
9731 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
9732 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
9734 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
9735 DECL_NAME (gen_tmpl
),
9736 /*tag_scope=*/ts_global
);
9740 context
= DECL_CONTEXT (gen_tmpl
);
9741 if (context
&& TYPE_P (context
))
9743 context
= tsubst_aggr_type (context
, arglist
, complain
, in_decl
, true);
9744 context
= complete_type (context
);
9747 context
= tsubst (context
, arglist
, complain
, in_decl
);
9749 if (context
== error_mark_node
)
9750 return error_mark_node
;
9753 context
= global_namespace
;
9755 /* Create the type. */
9756 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9758 /* The user referred to a specialization of an alias
9759 template represented by GEN_TMPL.
9761 [temp.alias]/2 says:
9763 When a template-id refers to the specialization of an
9764 alias template, it is equivalent to the associated
9765 type obtained by substitution of its
9766 template-arguments for the template-parameters in the
9767 type-id of the alias template. */
9769 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
9770 /* Note that the call above (by indirectly calling
9771 register_specialization in tsubst_decl) registers the
9772 TYPE_DECL representing the specialization of the alias
9773 template. So next time someone substitutes ARGLIST for
9774 the template parms into the alias template (GEN_TMPL),
9775 she'll get that TYPE_DECL back. */
9777 if (t
== error_mark_node
)
9780 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
9782 if (!is_dependent_type
)
9784 set_current_access_from_decl (TYPE_NAME (template_type
));
9785 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
9786 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
9787 arglist
, complain
, in_decl
),
9788 tsubst_attributes (TYPE_ATTRIBUTES (template_type
),
9789 arglist
, complain
, in_decl
),
9790 SCOPED_ENUM_P (template_type
), NULL
);
9792 if (t
== error_mark_node
)
9797 /* We don't want to call start_enum for this type, since
9798 the values for the enumeration constants may involve
9799 template parameters. And, no one should be interested
9800 in the enumeration constants for such a type. */
9801 t
= cxx_make_type (ENUMERAL_TYPE
);
9802 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
9804 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
9805 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
9806 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
9808 else if (CLASS_TYPE_P (template_type
))
9810 /* Lambda closures are regenerated in tsubst_lambda_expr, not
9811 instantiated here. */
9812 gcc_assert (!LAMBDA_TYPE_P (template_type
));
9814 t
= make_class_type (TREE_CODE (template_type
));
9815 CLASSTYPE_DECLARED_CLASS (t
)
9816 = CLASSTYPE_DECLARED_CLASS (template_type
);
9817 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
9819 /* A local class. Make sure the decl gets registered properly. */
9820 if (context
== current_function_decl
)
9821 if (pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
)
9823 return error_mark_node
;
9825 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
9826 /* This instantiation is another name for the primary
9827 template type. Set the TYPE_CANONICAL field
9829 TYPE_CANONICAL (t
) = template_type
;
9830 else if (any_template_arguments_need_structural_equality_p (arglist
))
9831 /* Some of the template arguments require structural
9832 equality testing, so this template class requires
9833 structural equality testing. */
9834 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9839 /* If we called start_enum or pushtag above, this information
9840 will already be set up. */
9843 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
9845 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
9846 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
9847 DECL_SOURCE_LOCATION (type_decl
)
9848 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
9851 type_decl
= TYPE_NAME (t
);
9853 if (CLASS_TYPE_P (template_type
))
9855 TREE_PRIVATE (type_decl
)
9856 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
9857 TREE_PROTECTED (type_decl
)
9858 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
9859 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
9861 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
9862 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
9866 if (OVERLOAD_TYPE_P (t
)
9867 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9869 static const char *tags
[] = {"abi_tag", "may_alias"};
9871 for (unsigned ix
= 0; ix
!= 2; ix
++)
9874 = lookup_attribute (tags
[ix
], TYPE_ATTRIBUTES (template_type
));
9878 = tree_cons (TREE_PURPOSE (attributes
),
9879 TREE_VALUE (attributes
),
9880 TYPE_ATTRIBUTES (t
));
9884 /* Let's consider the explicit specialization of a member
9885 of a class template specialization that is implicitly instantiated,
9890 template<class U> struct M {}; //#0
9895 struct S<int>::M<char> //#1
9899 [temp.expl.spec]/4 says this is valid.
9901 In this case, when we write:
9904 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
9907 When we encounter #1, we want to store the partial instantiation
9908 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
9910 For all cases other than this "explicit specialization of member of a
9911 class template", we just want to store the most general template into
9912 the CLASSTYPE_TI_TEMPLATE of M.
9914 This case of "explicit specialization of member of a class template"
9916 1/ the enclosing class is an instantiation of, and therefore not
9917 the same as, the context of the most general template, and
9918 2/ we aren't looking at the partial instantiation itself, i.e.
9919 the innermost arguments are not the same as the innermost parms of
9920 the most general template.
9922 So it's only when 1/ and 2/ happens that we want to use the partial
9923 instantiation of the member template in lieu of its most general
9926 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
9927 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
9928 /* the enclosing class must be an instantiation... */
9929 && CLASS_TYPE_P (context
)
9930 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
9932 TREE_VEC_LENGTH (arglist
)--;
9933 ++processing_template_decl
;
9934 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (gen_tmpl
));
9935 tree partial_inst_args
=
9936 tsubst (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
)),
9937 arglist
, complain
, NULL_TREE
);
9938 --processing_template_decl
;
9939 TREE_VEC_LENGTH (arglist
)++;
9940 if (partial_inst_args
== error_mark_node
)
9941 return error_mark_node
;
9942 use_partial_inst_tmpl
=
9943 /*...and we must not be looking at the partial instantiation
9945 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
9949 if (!use_partial_inst_tmpl
)
9950 /* This case is easy; there are no member templates involved. */
9954 /* This is a full instantiation of a member template. Find
9955 the partial instantiation of which this is an instance. */
9957 /* Temporarily reduce by one the number of levels in the ARGLIST
9958 so as to avoid comparing the last set of arguments. */
9959 TREE_VEC_LENGTH (arglist
)--;
9960 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
9961 TREE_VEC_LENGTH (arglist
)++;
9962 /* FOUND is either a proper class type, or an alias
9963 template specialization. In the later case, it's a
9964 TYPE_DECL, resulting from the substituting of arguments
9965 for parameters in the TYPE_DECL of the alias template
9966 done earlier. So be careful while getting the template
9968 found
= (TREE_CODE (found
) == TEMPLATE_DECL
9970 : (TREE_CODE (found
) == TYPE_DECL
9971 ? DECL_TI_TEMPLATE (found
)
9972 : CLASSTYPE_TI_TEMPLATE (found
)));
9974 if (DECL_CLASS_TEMPLATE_P (found
)
9975 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (found
)))
9977 /* If this partial instantiation is specialized, we want to
9978 use it for hash table lookup. */
9980 elt
.args
= arglist
= INNERMOST_TEMPLATE_ARGS (arglist
);
9981 hash
= spec_hasher::hash (&elt
);
9985 // Build template info for the new specialization.
9986 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
9989 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
9990 gcc_checking_assert (*slot
== NULL
);
9991 entry
= ggc_alloc
<spec_entry
> ();
9995 /* Note this use of the partial instantiation so we can check it
9996 later in maybe_process_partial_specialization. */
9997 DECL_TEMPLATE_INSTANTIATIONS (found
)
9998 = tree_cons (arglist
, t
,
9999 DECL_TEMPLATE_INSTANTIATIONS (found
));
10001 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
10002 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
10003 /* Now that the type has been registered on the instantiations
10004 list, we set up the enumerators. Because the enumeration
10005 constants may involve the enumeration type itself, we make
10006 sure to register the type first, and then create the
10007 constants. That way, doing tsubst_expr for the enumeration
10008 constants won't result in recursive calls here; we'll find
10009 the instantiation and exit above. */
10010 tsubst_enum (template_type
, t
, arglist
);
10012 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
10013 /* If the type makes use of template parameters, the
10014 code that generates debugging information will crash. */
10015 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
10017 /* Possibly limit visibility based on template args. */
10018 TREE_PUBLIC (type_decl
) = 1;
10019 determine_visibility (type_decl
);
10021 inherit_targ_abi_tags (t
);
10027 /* Wrapper for lookup_template_class_1. */
10030 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
10031 int entering_scope
, tsubst_flags_t complain
)
10034 timevar_push (TV_TEMPLATE_INST
);
10035 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
10036 entering_scope
, complain
);
10037 timevar_pop (TV_TEMPLATE_INST
);
10041 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
10044 lookup_template_variable (tree templ
, tree arglist
)
10046 if (flag_concepts
&& variable_concept_p (templ
))
10047 return build_concept_check (templ
, arglist
, tf_none
);
10049 /* The type of the expression is NULL_TREE since the template-id could refer
10050 to an explicit or partial specialization. */
10051 return build2 (TEMPLATE_ID_EXPR
, NULL_TREE
, templ
, arglist
);
10054 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
10057 finish_template_variable (tree var
, tsubst_flags_t complain
)
10059 tree templ
= TREE_OPERAND (var
, 0);
10060 tree arglist
= TREE_OPERAND (var
, 1);
10062 tree tmpl_args
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ
));
10063 arglist
= add_outermost_template_args (tmpl_args
, arglist
);
10065 templ
= most_general_template (templ
);
10066 tree parms
= DECL_TEMPLATE_PARMS (templ
);
10067 arglist
= coerce_innermost_template_parms (parms
, arglist
, templ
, complain
,
10069 /*use_default*/true);
10071 if (flag_concepts
&& !constraints_satisfied_p (templ
, arglist
))
10073 if (complain
& tf_error
)
10075 auto_diagnostic_group d
;
10076 error ("use of invalid variable template %qE", var
);
10077 diagnose_constraints (location_of (var
), templ
, arglist
);
10079 return error_mark_node
;
10082 return instantiate_template (templ
, arglist
, complain
);
10085 /* Construct a TEMPLATE_ID_EXPR for the given variable template TEMPL having
10086 TARGS template args, and instantiate it if it's not dependent. */
10089 lookup_and_finish_template_variable (tree templ
, tree targs
,
10090 tsubst_flags_t complain
)
10092 templ
= lookup_template_variable (templ
, targs
);
10093 if (!any_dependent_template_arguments_p (targs
))
10095 templ
= finish_template_variable (templ
, complain
);
10099 return convert_from_reference (templ
);
10103 struct pair_fn_data
10108 /* True when we should also visit template parameters that occur in
10109 non-deduced contexts. */
10110 bool include_nondeduced_p
;
10111 hash_set
<tree
> *visited
;
10114 /* Called from for_each_template_parm via walk_tree. */
10117 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
10120 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
10121 tree_fn_t fn
= pfd
->fn
;
10122 void *data
= pfd
->data
;
10123 tree result
= NULL_TREE
;
10125 #define WALK_SUBTREE(NODE) \
10128 result = for_each_template_parm (NODE, fn, data, pfd->visited, \
10129 pfd->include_nondeduced_p, \
10131 if (result) goto out; \
10135 if (pfd
->any_fn
&& (*pfd
->any_fn
)(t
, data
))
10139 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
))
10140 WALK_SUBTREE (TYPE_CONTEXT (t
));
10142 switch (TREE_CODE (t
))
10145 if (TYPE_PTRMEMFUNC_P (t
))
10147 /* Fall through. */
10150 case ENUMERAL_TYPE
:
10151 if (!TYPE_TEMPLATE_INFO (t
))
10152 *walk_subtrees
= 0;
10154 WALK_SUBTREE (TYPE_TI_ARGS (t
));
10158 WALK_SUBTREE (TYPE_MIN_VALUE (t
));
10159 WALK_SUBTREE (TYPE_MAX_VALUE (t
));
10163 /* Since we're not going to walk subtrees, we have to do this
10164 explicitly here. */
10165 WALK_SUBTREE (TYPE_METHOD_BASETYPE (t
));
10166 /* Fall through. */
10168 case FUNCTION_TYPE
:
10169 /* Check the return type. */
10170 WALK_SUBTREE (TREE_TYPE (t
));
10172 /* Check the parameter types. Since default arguments are not
10173 instantiated until they are needed, the TYPE_ARG_TYPES may
10174 contain expressions that involve template parameters. But,
10175 no-one should be looking at them yet. And, once they're
10176 instantiated, they don't contain template parameters, so
10177 there's no point in looking at them then, either. */
10181 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
10182 WALK_SUBTREE (TREE_VALUE (parm
));
10184 /* Since we've already handled the TYPE_ARG_TYPES, we don't
10185 want walk_tree walking into them itself. */
10186 *walk_subtrees
= 0;
10189 if (flag_noexcept_type
)
10191 tree spec
= TYPE_RAISES_EXCEPTIONS (t
);
10193 WALK_SUBTREE (TREE_PURPOSE (spec
));
10198 case DECLTYPE_TYPE
:
10199 case UNDERLYING_TYPE
:
10200 if (pfd
->include_nondeduced_p
10201 && for_each_template_parm (TYPE_VALUES_RAW (t
), fn
, data
,
10203 pfd
->include_nondeduced_p
,
10205 return error_mark_node
;
10206 *walk_subtrees
= false;
10209 case FUNCTION_DECL
:
10211 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
10212 WALK_SUBTREE (DECL_TI_ARGS (t
));
10213 /* Fall through. */
10217 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
))
10218 WALK_SUBTREE (DECL_INITIAL (t
));
10219 if (DECL_CONTEXT (t
)
10220 && pfd
->include_nondeduced_p
)
10221 WALK_SUBTREE (DECL_CONTEXT (t
));
10224 case BOUND_TEMPLATE_TEMPLATE_PARM
:
10225 /* Record template parameters such as `T' inside `TT<T>'. */
10226 WALK_SUBTREE (TYPE_TI_ARGS (t
));
10227 /* Fall through. */
10229 case TEMPLATE_TEMPLATE_PARM
:
10230 case TEMPLATE_TYPE_PARM
:
10231 case TEMPLATE_PARM_INDEX
:
10232 if (fn
&& (*fn
)(t
, data
))
10238 case TEMPLATE_DECL
:
10239 /* A template template parameter is encountered. */
10240 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10241 WALK_SUBTREE (TREE_TYPE (t
));
10243 /* Already substituted template template parameter */
10244 *walk_subtrees
= 0;
10247 case TYPENAME_TYPE
:
10248 /* A template-id in a TYPENAME_TYPE might be a deduced context after
10249 partial instantiation. */
10250 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t
));
10254 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
10255 && pfd
->include_nondeduced_p
)
10256 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
10260 case COMPONENT_REF
:
10261 /* If there's no type, then this thing must be some expression
10262 involving template parameters. */
10263 if (!fn
&& !TREE_TYPE (t
))
10264 return error_mark_node
;
10269 case IMPLICIT_CONV_EXPR
:
10270 case REINTERPRET_CAST_EXPR
:
10271 case CONST_CAST_EXPR
:
10272 case STATIC_CAST_EXPR
:
10273 case DYNAMIC_CAST_EXPR
:
10277 case PSEUDO_DTOR_EXPR
:
10279 return error_mark_node
;
10283 if (pfd
->include_nondeduced_p
)
10284 WALK_SUBTREE (TREE_OPERAND (t
, 0));
10287 case REQUIRES_EXPR
:
10290 return error_mark_node
;
10292 /* Recursively walk the type of each constraint variable. */
10293 tree p
= TREE_OPERAND (t
, 0);
10296 WALK_SUBTREE (TREE_TYPE (p
));
10297 p
= TREE_CHAIN (p
);
10306 #undef WALK_SUBTREE
10308 /* We didn't find any template parameters we liked. */
10313 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
10314 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
10315 call FN with the parameter and the DATA.
10316 If FN returns nonzero, the iteration is terminated, and
10317 for_each_template_parm returns 1. Otherwise, the iteration
10318 continues. If FN never returns a nonzero value, the value
10319 returned by for_each_template_parm is 0. If FN is NULL, it is
10320 considered to be the function which always returns 1.
10322 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
10323 parameters that occur in non-deduced contexts. When false, only
10324 visits those template parameters that can be deduced. */
10327 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
10328 hash_set
<tree
> *visited
,
10329 bool include_nondeduced_p
,
10332 struct pair_fn_data pfd
;
10337 pfd
.any_fn
= any_fn
;
10339 pfd
.include_nondeduced_p
= include_nondeduced_p
;
10341 /* Walk the tree. (Conceptually, we would like to walk without
10342 duplicates, but for_each_template_parm_r recursively calls
10343 for_each_template_parm, so we would need to reorganize a fair
10344 bit to use walk_tree_without_duplicates, so we keep our own
10347 pfd
.visited
= visited
;
10349 pfd
.visited
= new hash_set
<tree
>;
10350 result
= cp_walk_tree (&t
,
10351 for_each_template_parm_r
,
10358 delete pfd
.visited
;
10365 struct find_template_parameter_info
10367 explicit find_template_parameter_info (int d
)
10371 hash_set
<tree
> visited
;
10372 hash_set
<tree
> parms
;
10376 /* Appends the declaration of T to the list in DATA. */
10379 keep_template_parm (tree t
, void* data
)
10381 find_template_parameter_info
*ftpi
= (find_template_parameter_info
*)data
;
10383 /* Template parameters declared within the expression are not part of
10384 the parameter mapping. For example, in this concept:
10386 template<typename T>
10387 concept C = requires { <expr> } -> same_as<int>;
10389 the return specifier same_as<int> declares a new decltype parameter
10390 that must not be part of the parameter mapping. The same is true
10391 for generic lambda parameters, lambda template parameters, etc. */
10394 template_parm_level_and_index (t
, &level
, &index
);
10395 if (level
> ftpi
->max_depth
)
10398 /* Arguments like const T yield parameters like const T. This means that
10399 a template-id like X<T, const T> would yield two distinct parameters:
10400 T and const T. Adjust types to their unqualified versions. */
10402 t
= TYPE_MAIN_VARIANT (t
);
10403 ftpi
->parms
.add (t
);
10408 /* Ensure that we recursively examine certain terms that are not normally
10409 visited in for_each_template_parm_r. */
10412 any_template_parm_r (tree t
, void *data
)
10414 find_template_parameter_info
*ftpi
= (find_template_parameter_info
*)data
;
10416 #define WALK_SUBTREE(NODE) \
10419 for_each_template_parm (NODE, keep_template_parm, data, \
10420 &ftpi->visited, true, \
10421 any_template_parm_r); \
10425 switch (TREE_CODE (t
))
10429 case ENUMERAL_TYPE
:
10430 /* Search for template parameters in type aliases. */
10431 if (tree ats
= alias_template_specialization_p (t
, nt_opaque
))
10433 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (ats
);
10434 WALK_SUBTREE (TI_ARGS (tinfo
));
10438 case TEMPLATE_TYPE_PARM
:
10439 /* Type constraints of a placeholder type may contain parameters. */
10441 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
10442 WALK_SUBTREE (constr
);
10445 case TEMPLATE_ID_EXPR
:
10446 /* Search through references to variable templates. */
10447 WALK_SUBTREE (TREE_OPERAND (t
, 0));
10448 WALK_SUBTREE (TREE_OPERAND (t
, 1));
10453 WALK_SUBTREE (TREE_TYPE (t
));
10457 /* A parameter or constraint variable may also depend on a template
10458 parameter without explicitly naming it. */
10459 WALK_SUBTREE (TREE_TYPE (t
));
10466 /* Keep walking. */
10470 /* Returns a list of unique template parameters found within T. */
10473 find_template_parameters (tree t
, int depth
)
10475 find_template_parameter_info
ftpi (depth
);
10476 for_each_template_parm (t
, keep_template_parm
, &ftpi
, &ftpi
.visited
,
10477 /*include_nondeduced*/true, any_template_parm_r
);
10478 tree list
= NULL_TREE
;
10479 for (hash_set
<tree
>::iterator iter
= ftpi
.parms
.begin();
10480 iter
!= ftpi
.parms
.end(); ++iter
)
10481 list
= tree_cons (NULL_TREE
, *iter
, list
);
10485 /* Returns true if T depends on any template parameter. */
10488 uses_template_parms (tree t
)
10490 if (t
== NULL_TREE
)
10494 int saved_processing_template_decl
;
10496 saved_processing_template_decl
= processing_template_decl
;
10497 if (!saved_processing_template_decl
)
10498 processing_template_decl
= 1;
10500 dependent_p
= dependent_type_p (t
);
10501 else if (TREE_CODE (t
) == TREE_VEC
)
10502 dependent_p
= any_dependent_template_arguments_p (t
);
10503 else if (TREE_CODE (t
) == TREE_LIST
)
10504 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
10505 || uses_template_parms (TREE_CHAIN (t
)));
10506 else if (TREE_CODE (t
) == TYPE_DECL
)
10507 dependent_p
= dependent_type_p (TREE_TYPE (t
));
10508 else if (DECL_P (t
)
10510 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
10511 || TREE_CODE (t
) == OVERLOAD
10513 || identifier_p (t
)
10514 || TREE_CODE (t
) == TRAIT_EXPR
10515 || TREE_CODE (t
) == CONSTRUCTOR
10516 || CONSTANT_CLASS_P (t
))
10517 dependent_p
= (type_dependent_expression_p (t
)
10518 || value_dependent_expression_p (t
));
10521 gcc_assert (t
== error_mark_node
);
10522 dependent_p
= false;
10525 processing_template_decl
= saved_processing_template_decl
;
10527 return dependent_p
;
10530 /* Returns true iff current_function_decl is an incompletely instantiated
10531 template. Useful instead of processing_template_decl because the latter
10532 is set to 0 during instantiate_non_dependent_expr. */
10535 in_template_function (void)
10537 tree fn
= current_function_decl
;
10539 ++processing_template_decl
;
10540 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
10541 && DECL_TEMPLATE_INFO (fn
)
10542 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
10543 --processing_template_decl
;
10547 /* Returns true if T depends on any template parameter with level LEVEL. */
10550 uses_template_parms_level (tree t
, int level
)
10552 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
10553 /*include_nondeduced_p=*/true);
10556 /* Returns true if the signature of DECL depends on any template parameter from
10557 its enclosing class. */
10560 uses_outer_template_parms (tree decl
)
10562 int depth
= template_class_depth (CP_DECL_CONTEXT (decl
));
10565 if (for_each_template_parm (TREE_TYPE (decl
), template_parm_outer_level
,
10566 &depth
, NULL
, /*include_nondeduced_p=*/true))
10568 if (PRIMARY_TEMPLATE_P (decl
)
10569 && for_each_template_parm (INNERMOST_TEMPLATE_PARMS
10570 (DECL_TEMPLATE_PARMS (decl
)),
10571 template_parm_outer_level
,
10572 &depth
, NULL
, /*include_nondeduced_p=*/true))
10574 tree ci
= get_constraints (decl
);
10576 ci
= CI_ASSOCIATED_CONSTRAINTS (ci
);
10577 if (ci
&& for_each_template_parm (ci
, template_parm_outer_level
,
10578 &depth
, NULL
, /*nondeduced*/true))
10583 /* Returns TRUE iff INST is an instantiation we don't need to do in an
10584 ill-formed translation unit, i.e. a variable or function that isn't
10585 usable in a constant expression. */
10588 neglectable_inst_p (tree d
)
10590 return (d
&& DECL_P (d
)
10591 && !undeduced_auto_decl (d
)
10592 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
10593 : decl_maybe_constant_var_p (d
)));
10596 /* Returns TRUE iff we should refuse to instantiate DECL because it's
10597 neglectable and instantiated from within an erroneous instantiation. */
10600 limit_bad_template_recursion (tree decl
)
10602 struct tinst_level
*lev
= current_tinst_level
;
10603 int errs
= errorcount
+ sorrycount
;
10604 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
10607 for (; lev
; lev
= lev
->next
)
10608 if (neglectable_inst_p (lev
->maybe_get_node ()))
10611 return (lev
&& errs
> lev
->errors
);
10614 static int tinst_depth
;
10615 extern int max_tinst_depth
;
10618 static GTY(()) struct tinst_level
*last_error_tinst_level
;
10620 /* We're starting to instantiate D; record the template instantiation context
10621 at LOC for diagnostics and to restore it later. */
10624 push_tinst_level_loc (tree tldcl
, tree targs
, location_t loc
)
10626 struct tinst_level
*new_level
;
10628 if (tinst_depth
>= max_tinst_depth
)
10630 /* Tell error.c not to try to instantiate any templates. */
10632 fatal_error (input_location
,
10633 "template instantiation depth exceeds maximum of %d"
10634 " (use %<-ftemplate-depth=%> to increase the maximum)",
10639 /* If the current instantiation caused problems, don't let it instantiate
10640 anything else. Do allow deduction substitution and decls usable in
10641 constant expressions. */
10642 if (!targs
&& limit_bad_template_recursion (tldcl
))
10645 /* When not -quiet, dump template instantiations other than functions, since
10646 announce_function will take care of those. */
10647 if (!quiet_flag
&& !targs
10648 && TREE_CODE (tldcl
) != TREE_LIST
10649 && TREE_CODE (tldcl
) != FUNCTION_DECL
)
10650 fprintf (stderr
, " %s", decl_as_string (tldcl
, TFF_DECL_SPECIFIERS
));
10652 new_level
= tinst_level_freelist ().alloc ();
10653 new_level
->tldcl
= tldcl
;
10654 new_level
->targs
= targs
;
10655 new_level
->locus
= loc
;
10656 new_level
->errors
= errorcount
+ sorrycount
;
10657 new_level
->next
= NULL
;
10658 new_level
->refcount
= 0;
10659 set_refcount_ptr (new_level
->next
, current_tinst_level
);
10660 set_refcount_ptr (current_tinst_level
, new_level
);
10663 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
10664 depth_reached
= tinst_depth
;
10669 /* We're starting substitution of TMPL<ARGS>; record the template
10670 substitution context for diagnostics and to restore it later. */
10673 push_tinst_level (tree tmpl
, tree args
)
10675 return push_tinst_level_loc (tmpl
, args
, input_location
);
10678 /* We're starting to instantiate D; record INPUT_LOCATION and the
10679 template instantiation context for diagnostics and to restore it
10683 push_tinst_level (tree d
)
10685 return push_tinst_level_loc (d
, input_location
);
10688 /* Likewise, but record LOC as the program location. */
10691 push_tinst_level_loc (tree d
, location_t loc
)
10693 gcc_assert (TREE_CODE (d
) != TREE_LIST
);
10694 return push_tinst_level_loc (d
, NULL
, loc
);
10697 /* We're done instantiating this template; return to the instantiation
10701 pop_tinst_level (void)
10703 /* Restore the filename and line number stashed away when we started
10704 this instantiation. */
10705 input_location
= current_tinst_level
->locus
;
10706 set_refcount_ptr (current_tinst_level
, current_tinst_level
->next
);
10710 /* We're instantiating a deferred template; restore the template
10711 instantiation context in which the instantiation was requested, which
10712 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
10715 reopen_tinst_level (struct tinst_level
*level
)
10717 struct tinst_level
*t
;
10720 for (t
= level
; t
; t
= t
->next
)
10723 set_refcount_ptr (current_tinst_level
, level
);
10724 pop_tinst_level ();
10725 if (current_tinst_level
)
10726 current_tinst_level
->errors
= errorcount
+sorrycount
;
10727 return level
->maybe_get_node ();
10730 /* Returns the TINST_LEVEL which gives the original instantiation
10733 struct tinst_level
*
10734 outermost_tinst_level (void)
10736 struct tinst_level
*level
= current_tinst_level
;
10738 while (level
->next
)
10739 level
= level
->next
;
10743 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
10744 vector of template arguments, as for tsubst.
10746 Returns an appropriate tsubst'd friend declaration. */
10749 tsubst_friend_function (tree decl
, tree args
)
10753 if (TREE_CODE (decl
) == FUNCTION_DECL
10754 && DECL_TEMPLATE_INSTANTIATION (decl
)
10755 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
10756 /* This was a friend declared with an explicit template
10757 argument list, e.g.:
10759 friend void f<>(T);
10761 to indicate that f was a template instantiation, not a new
10762 function declaration. Now, we have to figure out what
10763 instantiation of what template. */
10765 tree template_id
, arglist
, fns
;
10768 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
10770 /* Friend functions are looked up in the containing namespace scope.
10771 We must enter that scope, to avoid finding member functions of the
10772 current class with same name. */
10773 push_nested_namespace (ns
);
10774 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
10775 tf_warning_or_error
, NULL_TREE
,
10776 /*integral_constant_expression_p=*/false);
10777 pop_nested_namespace (ns
);
10778 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
10779 tf_warning_or_error
, NULL_TREE
);
10780 template_id
= lookup_template_function (fns
, arglist
);
10782 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
10783 tmpl
= determine_specialization (template_id
, new_friend
,
10785 /*need_member_template=*/0,
10786 TREE_VEC_LENGTH (args
),
10788 return instantiate_template (tmpl
, new_args
, tf_error
);
10791 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
10793 /* The NEW_FRIEND will look like an instantiation, to the
10794 compiler, but is not an instantiation from the point of view of
10795 the language. For example, we might have had:
10797 template <class T> struct S {
10798 template <class U> friend void f(T, U);
10801 Then, in S<int>, template <class U> void f(int, U) is not an
10802 instantiation of anything. */
10803 if (new_friend
== error_mark_node
)
10804 return error_mark_node
;
10806 DECL_USE_TEMPLATE (new_friend
) = 0;
10807 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
10809 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
10810 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
10811 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
10813 /* Attach the template requirements to the new declaration
10814 for declaration matching. We need to rebuild the requirements
10815 so that parameter levels match. */
10816 if (tree ci
= get_constraints (decl
))
10818 tree parms
= DECL_TEMPLATE_PARMS (new_friend
);
10819 tree args
= generic_targs_for (new_friend
);
10820 tree treqs
= tsubst_constraint (CI_TEMPLATE_REQS (ci
), args
,
10821 tf_warning_or_error
, NULL_TREE
);
10822 tree freqs
= tsubst_constraint (CI_DECLARATOR_REQS (ci
), args
,
10823 tf_warning_or_error
, NULL_TREE
);
10825 /* Update the constraints -- these won't really be valid for
10826 checking, but that's not what we need them for. These ensure
10827 that the declared function can find the friend during
10828 declaration matching. */
10829 tree new_ci
= get_constraints (new_friend
);
10830 CI_TEMPLATE_REQS (new_ci
) = treqs
;
10831 CI_DECLARATOR_REQS (new_ci
) = freqs
;
10833 /* Also update the template parameter list. */
10834 TEMPLATE_PARMS_CONSTRAINTS (parms
) = treqs
;
10838 /* The mangled name for the NEW_FRIEND is incorrect. The function
10839 is not a template instantiation and should not be mangled like
10840 one. Therefore, we forget the mangling here; we'll recompute it
10841 later if we need it. */
10842 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
10844 SET_DECL_RTL (new_friend
, NULL
);
10845 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
10848 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
10851 tree new_friend_template_info
;
10852 tree new_friend_result_template_info
;
10854 int new_friend_is_defn
;
10856 /* We must save some information from NEW_FRIEND before calling
10857 duplicate decls since that function will free NEW_FRIEND if
10859 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
10860 new_friend_is_defn
=
10861 (DECL_INITIAL (DECL_TEMPLATE_RESULT
10862 (template_for_substitution (new_friend
)))
10864 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
10866 /* This declaration is a `primary' template. */
10867 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
10869 new_friend_result_template_info
10870 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
10873 new_friend_result_template_info
= NULL_TREE
;
10875 /* Inside pushdecl_namespace_level, we will push into the
10876 current namespace. However, the friend function should go
10877 into the namespace of the template. */
10878 ns
= decl_namespace_context (new_friend
);
10879 push_nested_namespace (ns
);
10880 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
10881 pop_nested_namespace (ns
);
10883 if (old_decl
== error_mark_node
)
10884 return error_mark_node
;
10886 if (old_decl
!= new_friend
)
10888 /* This new friend declaration matched an existing
10889 declaration. For example, given:
10891 template <class T> void f(T);
10892 template <class U> class C {
10893 template <class T> friend void f(T) {}
10896 the friend declaration actually provides the definition
10897 of `f', once C has been instantiated for some type. So,
10898 old_decl will be the out-of-class template declaration,
10899 while new_friend is the in-class definition.
10901 But, if `f' was called before this point, the
10902 instantiation of `f' will have DECL_TI_ARGS corresponding
10903 to `T' but not to `U', references to which might appear
10904 in the definition of `f'. Previously, the most general
10905 template for an instantiation of `f' was the out-of-class
10906 version; now it is the in-class version. Therefore, we
10907 run through all specialization of `f', adding to their
10908 DECL_TI_ARGS appropriately. In particular, they need a
10909 new set of outer arguments, corresponding to the
10910 arguments for this class instantiation.
10912 The same situation can arise with something like this:
10914 friend void f(int);
10915 template <class T> class C {
10916 friend void f(T) {}
10919 when `C<int>' is instantiated. Now, `f(int)' is defined
10922 if (!new_friend_is_defn
)
10923 /* On the other hand, if the in-class declaration does
10924 *not* provide a definition, then we don't want to alter
10925 existing definitions. We can just leave everything
10930 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
10931 tree new_args
= TI_ARGS (new_friend_template_info
);
10933 /* Overwrite whatever template info was there before, if
10934 any, with the new template information pertaining to
10935 the declaration. */
10936 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
10938 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
10940 /* We should have called reregister_specialization in
10941 duplicate_decls. */
10942 gcc_assert (retrieve_specialization (new_template
,
10946 /* Instantiate it if the global has already been used. */
10947 if (DECL_ODR_USED (old_decl
))
10948 instantiate_decl (old_decl
, /*defer_ok=*/true,
10949 /*expl_inst_class_mem_p=*/false);
10955 /* Indicate that the old function template is a partial
10957 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
10958 = new_friend_result_template_info
;
10960 gcc_assert (new_template
10961 == most_general_template (new_template
));
10962 gcc_assert (new_template
!= old_decl
);
10964 /* Reassign any specializations already in the hash table
10965 to the new more general template, and add the
10966 additional template args. */
10967 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
10969 t
= TREE_CHAIN (t
))
10971 tree spec
= TREE_VALUE (t
);
10974 elt
.tmpl
= old_decl
;
10975 elt
.args
= DECL_TI_ARGS (spec
);
10976 elt
.spec
= NULL_TREE
;
10978 decl_specializations
->remove_elt (&elt
);
10980 DECL_TI_ARGS (spec
)
10981 = add_outermost_template_args (new_args
,
10982 DECL_TI_ARGS (spec
));
10984 register_specialization
10985 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
10988 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
10992 /* The information from NEW_FRIEND has been merged into OLD_DECL
10993 by duplicate_decls. */
10994 new_friend
= old_decl
;
10999 tree context
= DECL_CONTEXT (new_friend
);
11003 template <class T> class C {
11004 template <class U> friend void C1<U>::f (); // case 1
11005 friend void C2<T>::f (); // case 2
11007 we only need to make sure CONTEXT is a complete type for
11008 case 2. To distinguish between the two cases, we note that
11009 CONTEXT of case 1 remains dependent type after tsubst while
11010 this isn't true for case 2. */
11011 ++processing_template_decl
;
11012 dependent_p
= dependent_type_p (context
);
11013 --processing_template_decl
;
11016 && !complete_type_or_else (context
, NULL_TREE
))
11017 return error_mark_node
;
11019 if (COMPLETE_TYPE_P (context
))
11021 tree fn
= new_friend
;
11022 /* do_friend adds the TEMPLATE_DECL for any member friend
11023 template even if it isn't a member template, i.e.
11024 template <class T> friend A<T>::f();
11025 Look through it in that case. */
11026 if (TREE_CODE (fn
) == TEMPLATE_DECL
11027 && !PRIMARY_TEMPLATE_P (fn
))
11028 fn
= DECL_TEMPLATE_RESULT (fn
);
11029 /* Check to see that the declaration is really present, and,
11030 possibly obtain an improved declaration. */
11031 fn
= check_classfn (context
, fn
, NULL_TREE
);
11041 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
11042 template arguments, as for tsubst.
11044 Returns an appropriate tsubst'd friend type or error_mark_node on
11048 tsubst_friend_class (tree friend_tmpl
, tree args
)
11052 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
11054 tmpl
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
11055 return TREE_TYPE (tmpl
);
11058 tree context
= CP_DECL_CONTEXT (friend_tmpl
);
11059 if (TREE_CODE (context
) == NAMESPACE_DECL
)
11060 push_nested_namespace (context
);
11063 context
= tsubst (context
, args
, tf_error
, NULL_TREE
);
11064 push_nested_class (context
);
11067 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), /*prefer_type=*/false,
11068 /*non_class=*/false, /*block_p=*/false,
11069 /*namespaces_only=*/false, LOOKUP_HIDDEN
);
11071 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
11073 /* The friend template has already been declared. Just
11074 check to see that the declarations match, and install any new
11075 default parameters. We must tsubst the default parameters,
11076 of course. We only need the innermost template parameters
11077 because that is all that redeclare_class_template will look
11079 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
11080 > TMPL_ARGS_DEPTH (args
))
11082 tree parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
11083 args
, tf_warning_or_error
);
11084 location_t saved_input_location
= input_location
;
11085 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
11086 tree cons
= get_constraints (tmpl
);
11087 redeclare_class_template (TREE_TYPE (tmpl
), parms
, cons
);
11088 input_location
= saved_input_location
;
11093 /* The friend template has not already been declared. In this
11094 case, the instantiation of the template class will cause the
11095 injection of this template into the namespace scope. */
11096 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
11098 if (tmpl
!= error_mark_node
)
11100 /* The new TMPL is not an instantiation of anything, so we
11101 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE
11102 for the new type because that is supposed to be the
11103 corresponding template decl, i.e., TMPL. */
11104 DECL_USE_TEMPLATE (tmpl
) = 0;
11105 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
11106 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
11107 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
11108 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
11110 /* It is hidden. */
11111 retrofit_lang_decl (DECL_TEMPLATE_RESULT (tmpl
));
11112 DECL_ANTICIPATED (tmpl
)
11113 = DECL_ANTICIPATED (DECL_TEMPLATE_RESULT (tmpl
)) = true;
11115 /* Inject this template into the enclosing namspace scope. */
11116 tmpl
= pushdecl_namespace_level (tmpl
, true);
11120 if (TREE_CODE (context
) == NAMESPACE_DECL
)
11121 pop_nested_namespace (context
);
11123 pop_nested_class ();
11125 return TREE_TYPE (tmpl
);
11128 /* Returns zero if TYPE cannot be completed later due to circularity.
11129 Otherwise returns one. */
11132 can_complete_type_without_circularity (tree type
)
11134 if (type
== NULL_TREE
|| type
== error_mark_node
)
11136 else if (COMPLETE_TYPE_P (type
))
11138 else if (TREE_CODE (type
) == ARRAY_TYPE
)
11139 return can_complete_type_without_circularity (TREE_TYPE (type
));
11140 else if (CLASS_TYPE_P (type
)
11141 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
11147 static tree
tsubst_omp_clauses (tree
, enum c_omp_region_type
, tree
,
11148 tsubst_flags_t
, tree
);
11150 /* Instantiate a single dependent attribute T (a TREE_LIST), and return either
11151 T or a new TREE_LIST, possibly a chain in the case of a pack expansion. */
11154 tsubst_attribute (tree t
, tree
*decl_p
, tree args
,
11155 tsubst_flags_t complain
, tree in_decl
)
11157 gcc_assert (ATTR_IS_DEPENDENT (t
));
11159 tree val
= TREE_VALUE (t
);
11160 if (val
== NULL_TREE
)
11161 /* Nothing to do. */;
11162 else if ((flag_openmp
|| flag_openmp_simd
)
11163 && is_attribute_p ("omp declare simd",
11164 get_attribute_name (t
)))
11166 tree clauses
= TREE_VALUE (val
);
11167 clauses
= tsubst_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
, args
,
11168 complain
, in_decl
);
11169 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
11170 clauses
= finish_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
);
11171 tree parms
= DECL_ARGUMENTS (*decl_p
);
11173 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
11175 val
= build_tree_list (NULL_TREE
, clauses
);
11179 else if (flag_openmp
11180 && is_attribute_p ("omp declare variant base",
11181 get_attribute_name (t
)))
11183 ++cp_unevaluated_operand
;
11185 = tsubst_expr (TREE_PURPOSE (val
), args
, complain
,
11186 in_decl
, /*integral_constant_expression_p=*/false);
11187 --cp_unevaluated_operand
;
11188 tree chain
= TREE_CHAIN (val
);
11189 location_t match_loc
= cp_expr_loc_or_input_loc (TREE_PURPOSE (chain
));
11190 tree ctx
= copy_list (TREE_VALUE (val
));
11191 tree simd
= get_identifier ("simd");
11192 tree score
= get_identifier (" score");
11193 tree condition
= get_identifier ("condition");
11194 for (tree t1
= ctx
; t1
; t1
= TREE_CHAIN (t1
))
11196 const char *set
= IDENTIFIER_POINTER (TREE_PURPOSE (t1
));
11197 TREE_VALUE (t1
) = copy_list (TREE_VALUE (t1
));
11198 for (tree t2
= TREE_VALUE (t1
); t2
; t2
= TREE_CHAIN (t2
))
11200 if (TREE_PURPOSE (t2
) == simd
&& set
[0] == 'c')
11202 tree clauses
= TREE_VALUE (t2
);
11203 clauses
= tsubst_omp_clauses (clauses
,
11204 C_ORT_OMP_DECLARE_SIMD
, args
,
11205 complain
, in_decl
);
11206 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
11207 clauses
= finish_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
);
11208 TREE_VALUE (t2
) = clauses
;
11212 TREE_VALUE (t2
) = copy_list (TREE_VALUE (t2
));
11213 for (tree t3
= TREE_VALUE (t2
); t3
; t3
= TREE_CHAIN (t3
))
11214 if (TREE_VALUE (t3
))
11217 = ((TREE_PURPOSE (t2
) != condition
|| set
[0] != 'u')
11218 && TREE_PURPOSE (t3
) != score
);
11219 tree v
= TREE_VALUE (t3
);
11220 if (TREE_CODE (v
) == STRING_CST
&& allow_string
)
11222 v
= tsubst_expr (v
, args
, complain
, in_decl
, true);
11223 v
= fold_non_dependent_expr (v
);
11224 if (!INTEGRAL_TYPE_P (TREE_TYPE (v
))
11225 || (TREE_PURPOSE (t3
) == score
11226 ? TREE_CODE (v
) != INTEGER_CST
11227 : !tree_fits_shwi_p (v
)))
11230 = cp_expr_loc_or_loc (TREE_VALUE (t3
),
11232 if (TREE_PURPOSE (t3
) == score
)
11233 error_at (loc
, "score argument must be "
11234 "constant integer expression");
11235 else if (allow_string
)
11236 error_at (loc
, "property must be constant "
11237 "integer expression or string "
11240 error_at (loc
, "property must be constant "
11241 "integer expression");
11244 else if (TREE_PURPOSE (t3
) == score
11245 && tree_int_cst_sgn (v
) < 0)
11248 = cp_expr_loc_or_loc (TREE_VALUE (t3
),
11250 error_at (loc
, "score argument must be "
11254 TREE_VALUE (t3
) = v
;
11259 val
= tree_cons (varid
, ctx
, chain
);
11261 /* If the first attribute argument is an identifier, don't
11262 pass it through tsubst. Attributes like mode, format,
11263 cleanup and several target specific attributes expect it
11265 else if (attribute_takes_identifier_p (get_attribute_name (t
)))
11268 = tsubst_expr (TREE_CHAIN (val
), args
, complain
, in_decl
,
11269 /*integral_constant_expression_p=*/false);
11270 if (chain
!= TREE_CHAIN (val
))
11271 val
= tree_cons (NULL_TREE
, TREE_VALUE (val
), chain
);
11273 else if (PACK_EXPANSION_P (val
))
11275 /* An attribute pack expansion. */
11276 tree purp
= TREE_PURPOSE (t
);
11277 tree pack
= tsubst_pack_expansion (val
, args
, complain
, in_decl
);
11278 if (pack
== error_mark_node
)
11279 return error_mark_node
;
11280 int len
= TREE_VEC_LENGTH (pack
);
11281 tree list
= NULL_TREE
;
11283 for (int i
= 0; i
< len
; ++i
)
11285 tree elt
= TREE_VEC_ELT (pack
, i
);
11286 *q
= build_tree_list (purp
, elt
);
11287 q
= &TREE_CHAIN (*q
);
11292 val
= tsubst_expr (val
, args
, complain
, in_decl
,
11293 /*integral_constant_expression_p=*/false);
11295 if (val
!= TREE_VALUE (t
))
11296 return build_tree_list (TREE_PURPOSE (t
), val
);
11300 /* Instantiate any dependent attributes in ATTRIBUTES, returning either it
11301 unchanged or a new TREE_LIST chain. */
11304 tsubst_attributes (tree attributes
, tree args
,
11305 tsubst_flags_t complain
, tree in_decl
)
11307 tree last_dep
= NULL_TREE
;
11309 for (tree t
= attributes
; t
; t
= TREE_CHAIN (t
))
11310 if (ATTR_IS_DEPENDENT (t
))
11313 attributes
= copy_list (attributes
);
11318 for (tree
*p
= &attributes
; *p
; )
11321 if (ATTR_IS_DEPENDENT (t
))
11323 tree subst
= tsubst_attribute (t
, NULL
, args
, complain
, in_decl
);
11328 p
= &TREE_CHAIN (*p
);
11329 *p
= TREE_CHAIN (t
);
11333 p
= &TREE_CHAIN (*p
);
11339 /* Apply any attributes which had to be deferred until instantiation
11340 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
11341 ARGS, COMPLAIN, IN_DECL are as tsubst. */
11344 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
11345 tree args
, tsubst_flags_t complain
, tree in_decl
)
11347 tree last_dep
= NULL_TREE
;
11351 if (attributes
== NULL_TREE
)
11354 if (DECL_P (*decl_p
))
11356 if (TREE_TYPE (*decl_p
) == error_mark_node
)
11358 p
= &DECL_ATTRIBUTES (*decl_p
);
11359 /* DECL_ATTRIBUTES comes from copy_node in tsubst_decl, and is identical
11360 to our attributes parameter. */
11361 gcc_assert (*p
== attributes
);
11365 p
= &TYPE_ATTRIBUTES (*decl_p
);
11366 /* TYPE_ATTRIBUTES was set up (with abi_tag and may_alias) in
11367 lookup_template_class_1, and should be preserved. */
11368 gcc_assert (*p
!= attributes
);
11370 p
= &TREE_CHAIN (*p
);
11373 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
11374 if (ATTR_IS_DEPENDENT (t
))
11377 attributes
= copy_list (attributes
);
11384 tree late_attrs
= NULL_TREE
;
11385 tree
*q
= &late_attrs
;
11390 if (ATTR_IS_DEPENDENT (t
))
11392 *p
= TREE_CHAIN (t
);
11393 TREE_CHAIN (t
) = NULL_TREE
;
11394 *q
= tsubst_attribute (t
, decl_p
, args
, complain
, in_decl
);
11396 q
= &TREE_CHAIN (*q
);
11399 p
= &TREE_CHAIN (t
);
11402 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
11406 /* Perform (or defer) access check for typedefs that were referenced
11407 from within the template TMPL code.
11408 This is a subroutine of instantiate_decl and instantiate_class_template.
11409 TMPL is the template to consider and TARGS is the list of arguments of
11413 perform_typedefs_access_check (tree tmpl
, tree targs
)
11416 qualified_typedef_usage_t
*iter
;
11419 || (!CLASS_TYPE_P (tmpl
)
11420 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
11423 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
11425 tree type_decl
= iter
->typedef_decl
;
11426 tree type_scope
= iter
->context
;
11428 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
11431 if (uses_template_parms (type_decl
))
11432 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
11433 if (uses_template_parms (type_scope
))
11434 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
11436 /* Make access check error messages point to the location
11437 of the use of the typedef. */
11438 iloc_sentinel
ils (iter
->locus
);
11439 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
11440 type_decl
, type_decl
,
11441 tf_warning_or_error
);
11446 instantiate_class_template_1 (tree type
)
11448 tree templ
, args
, pattern
, t
, member
;
11452 unsigned int saved_maximum_field_alignment
;
11455 if (type
== error_mark_node
)
11456 return error_mark_node
;
11458 if (COMPLETE_OR_OPEN_TYPE_P (type
)
11459 || uses_template_parms (type
))
11462 /* Figure out which template is being instantiated. */
11463 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
11464 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
11466 /* Mark the type as in the process of being defined. */
11467 TYPE_BEING_DEFINED (type
) = 1;
11469 /* We may be in the middle of deferred access check. Disable
11471 deferring_access_check_sentinel
acs (dk_no_deferred
);
11473 /* Determine what specialization of the original template to
11475 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
11476 if (t
== error_mark_node
)
11477 return error_mark_node
;
11480 /* This TYPE is actually an instantiation of a partial
11481 specialization. We replace the innermost set of ARGS with
11482 the arguments appropriate for substitution. For example,
11485 template <class T> struct S {};
11486 template <class T> struct S<T*> {};
11488 and supposing that we are instantiating S<int*>, ARGS will
11489 presently be {int*} -- but we need {int}. */
11490 pattern
= TREE_TYPE (t
);
11491 args
= TREE_PURPOSE (t
);
11495 pattern
= TREE_TYPE (templ
);
11496 args
= CLASSTYPE_TI_ARGS (type
);
11499 /* If the template we're instantiating is incomplete, then clearly
11500 there's nothing we can do. */
11501 if (!COMPLETE_TYPE_P (pattern
))
11503 /* We can try again later. */
11504 TYPE_BEING_DEFINED (type
) = 0;
11508 /* If we've recursively instantiated too many templates, stop. */
11509 if (! push_tinst_level (type
))
11512 int saved_unevaluated_operand
= cp_unevaluated_operand
;
11513 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
11515 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
11516 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
11517 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
11518 fn_context
= error_mark_node
;
11520 push_to_top_level ();
11523 cp_unevaluated_operand
= 0;
11524 c_inhibit_evaluation_warnings
= 0;
11526 /* Use #pragma pack from the template context. */
11527 saved_maximum_field_alignment
= maximum_field_alignment
;
11528 maximum_field_alignment
= TYPE_PRECISION (pattern
);
11530 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
11532 /* Set the input location to the most specialized template definition.
11533 This is needed if tsubsting causes an error. */
11534 typedecl
= TYPE_MAIN_DECL (pattern
);
11535 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
11536 DECL_SOURCE_LOCATION (typedecl
);
11538 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
11539 SET_TYPE_ALIGN (type
, TYPE_ALIGN (pattern
));
11540 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
11541 CLASSTYPE_NON_AGGREGATE (type
) = CLASSTYPE_NON_AGGREGATE (pattern
);
11542 if (ANON_AGGR_TYPE_P (pattern
))
11543 SET_ANON_AGGR_TYPE_P (type
);
11544 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
11546 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
11547 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
11548 /* Adjust visibility for template arguments. */
11549 determine_visibility (TYPE_MAIN_DECL (type
));
11551 if (CLASS_TYPE_P (type
))
11552 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
11554 pbinfo
= TYPE_BINFO (pattern
);
11556 /* We should never instantiate a nested class before its enclosing
11557 class; we need to look up the nested class by name before we can
11558 instantiate it, and that lookup should instantiate the enclosing
11560 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
11561 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
11563 base_list
= NULL_TREE
;
11564 if (BINFO_N_BASE_BINFOS (pbinfo
))
11570 /* We must enter the scope containing the type, as that is where
11571 the accessibility of types named in dependent bases are
11573 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
11575 /* Substitute into each of the bases to determine the actual
11577 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
11580 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
11581 tree expanded_bases
= NULL_TREE
;
11584 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
11587 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
11588 args
, tf_error
, NULL_TREE
);
11589 if (expanded_bases
== error_mark_node
)
11592 len
= TREE_VEC_LENGTH (expanded_bases
);
11595 for (idx
= 0; idx
< len
; idx
++)
11597 if (expanded_bases
)
11598 /* Extract the already-expanded base class. */
11599 base
= TREE_VEC_ELT (expanded_bases
, idx
);
11601 /* Substitute to figure out the base class. */
11602 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
11605 if (base
== error_mark_node
)
11608 base_list
= tree_cons (access
, base
, base_list
);
11609 if (BINFO_VIRTUAL_P (pbase_binfo
))
11610 TREE_TYPE (base_list
) = integer_type_node
;
11614 /* The list is now in reverse order; correct that. */
11615 base_list
= nreverse (base_list
);
11618 pop_scope (pushed_scope
);
11620 /* Now call xref_basetypes to set up all the base-class
11622 xref_basetypes (type
, base_list
);
11624 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
11625 (int) ATTR_FLAG_TYPE_IN_PLACE
,
11626 args
, tf_error
, NULL_TREE
);
11627 fixup_attribute_variants (type
);
11629 /* Now that our base classes are set up, enter the scope of the
11630 class, so that name lookups into base classes, etc. will work
11631 correctly. This is precisely analogous to what we do in
11632 begin_class_definition when defining an ordinary non-template
11633 class, except we also need to push the enclosing classes. */
11634 push_nested_class (type
);
11636 /* Now members are processed in the order of declaration. */
11637 for (member
= CLASSTYPE_DECL_LIST (pattern
);
11638 member
; member
= TREE_CHAIN (member
))
11640 tree t
= TREE_VALUE (member
);
11642 if (TREE_PURPOSE (member
))
11646 if (LAMBDA_TYPE_P (t
))
11647 /* A closure type for a lambda in an NSDMI or default argument.
11648 Ignore it; it will be regenerated when needed. */
11651 /* Build new CLASSTYPE_NESTED_UTDS. */
11654 bool class_template_p
;
11656 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
11657 && TYPE_LANG_SPECIFIC (t
)
11658 && CLASSTYPE_IS_TEMPLATE (t
));
11659 /* If the member is a class template, then -- even after
11660 substitution -- there may be dependent types in the
11661 template argument list for the class. We increment
11662 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
11663 that function will assume that no types are dependent
11664 when outside of a template. */
11665 if (class_template_p
)
11666 ++processing_template_decl
;
11667 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
11668 if (class_template_p
)
11669 --processing_template_decl
;
11670 if (newtag
== error_mark_node
)
11673 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
11675 tree name
= TYPE_IDENTIFIER (t
);
11677 if (class_template_p
)
11678 /* Unfortunately, lookup_template_class sets
11679 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
11680 instantiation (i.e., for the type of a member
11681 template class nested within a template class.)
11682 This behavior is required for
11683 maybe_process_partial_specialization to work
11684 correctly, but is not accurate in this case;
11685 the TAG is not an instantiation of anything.
11686 (The corresponding TEMPLATE_DECL is an
11687 instantiation, but the TYPE is not.) */
11688 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
11690 /* Now, we call pushtag to put this NEWTAG into the scope of
11691 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
11692 pushtag calling push_template_decl. We don't have to do
11693 this for enums because it will already have been done in
11696 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
11697 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
11700 else if (DECL_DECLARES_FUNCTION_P (t
))
11704 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11705 ++processing_template_decl
;
11706 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
11707 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11708 --processing_template_decl
;
11709 set_current_access_from_decl (r
);
11710 finish_member_declaration (r
);
11711 /* Instantiate members marked with attribute used. */
11712 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
11714 if (TREE_CODE (r
) == FUNCTION_DECL
11715 && DECL_OMP_DECLARE_REDUCTION_P (r
))
11716 cp_check_omp_declare_reduction (r
);
11718 else if ((DECL_CLASS_TEMPLATE_P (t
) || DECL_IMPLICIT_TYPEDEF_P (t
))
11719 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
11720 /* A closure type for a lambda in an NSDMI or default argument.
11721 Ignore it; it will be regenerated when needed. */;
11724 /* Build new TYPE_FIELDS. */
11725 if (TREE_CODE (t
) == STATIC_ASSERT
)
11729 ++c_inhibit_evaluation_warnings
;
11731 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
11732 tf_warning_or_error
, NULL_TREE
,
11733 /*integral_constant_expression_p=*/true);
11734 --c_inhibit_evaluation_warnings
;
11736 finish_static_assert (condition
,
11737 STATIC_ASSERT_MESSAGE (t
),
11738 STATIC_ASSERT_SOURCE_LOCATION (t
),
11739 /*member_p=*/true);
11741 else if (TREE_CODE (t
) != CONST_DECL
)
11744 tree vec
= NULL_TREE
;
11747 /* The file and line for this declaration, to
11748 assist in error message reporting. Since we
11749 called push_tinst_level above, we don't need to
11751 input_location
= DECL_SOURCE_LOCATION (t
);
11753 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11754 ++processing_template_decl
;
11755 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
11756 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11757 --processing_template_decl
;
11759 if (TREE_CODE (r
) == TREE_VEC
)
11761 /* A capture pack became multiple fields. */
11763 len
= TREE_VEC_LENGTH (vec
);
11766 for (int i
= 0; i
< len
; ++i
)
11769 r
= TREE_VEC_ELT (vec
, i
);
11774 [t]he initialization (and any associated
11775 side-effects) of a static data member does
11776 not occur unless the static data member is
11777 itself used in a way that requires the
11778 definition of the static data member to
11781 Therefore, we do not substitute into the
11782 initialized for the static data member here. */
11783 finish_static_data_member_decl
11785 /*init=*/NULL_TREE
,
11786 /*init_const_expr_p=*/false,
11787 /*asmspec_tree=*/NULL_TREE
,
11789 /* Instantiate members marked with attribute used. */
11790 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
11793 else if (TREE_CODE (r
) == FIELD_DECL
)
11795 /* Determine whether R has a valid type and can be
11796 completed later. If R is invalid, then its type
11797 is replaced by error_mark_node. */
11798 tree rtype
= TREE_TYPE (r
);
11799 if (can_complete_type_without_circularity (rtype
))
11800 complete_type (rtype
);
11802 if (!complete_or_array_type_p (rtype
))
11804 /* If R's type couldn't be completed and
11805 it isn't a flexible array member (whose
11806 type is incomplete by definition) give
11808 cxx_incomplete_type_error (r
, rtype
);
11809 TREE_TYPE (r
) = error_mark_node
;
11811 else if (TREE_CODE (rtype
) == ARRAY_TYPE
11812 && TYPE_DOMAIN (rtype
) == NULL_TREE
11813 && (TREE_CODE (type
) == UNION_TYPE
11814 || TREE_CODE (type
) == QUAL_UNION_TYPE
))
11816 error ("flexible array member %qD in union", r
);
11817 TREE_TYPE (r
) = error_mark_node
;
11819 else if (!verify_type_context (input_location
,
11820 TCTX_FIELD
, rtype
))
11821 TREE_TYPE (r
) = error_mark_node
;
11824 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
11825 such a thing will already have been added to the field
11826 list by tsubst_enum in finish_member_declaration in the
11827 CLASSTYPE_NESTED_UTDS case above. */
11828 if (!(TREE_CODE (r
) == TYPE_DECL
11829 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
11830 && DECL_ARTIFICIAL (r
)))
11832 set_current_access_from_decl (r
);
11833 finish_member_declaration (r
);
11841 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
11842 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
11844 /* Build new CLASSTYPE_FRIEND_CLASSES. */
11846 tree friend_type
= t
;
11847 bool adjust_processing_template_decl
= false;
11849 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
11851 /* template <class T> friend class C; */
11852 friend_type
= tsubst_friend_class (friend_type
, args
);
11853 adjust_processing_template_decl
= true;
11855 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
11857 /* template <class T> friend class C::D; */
11858 friend_type
= tsubst (friend_type
, args
,
11859 tf_warning_or_error
, NULL_TREE
);
11860 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
11861 friend_type
= TREE_TYPE (friend_type
);
11862 adjust_processing_template_decl
= true;
11864 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
11865 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
11867 /* This could be either
11871 when dependent_type_p is false or
11873 template <class U> friend class T::C;
11876 /* Bump processing_template_decl in case this is something like
11877 template <class T> friend struct A<T>::B. */
11878 ++processing_template_decl
;
11879 friend_type
= tsubst (friend_type
, args
,
11880 tf_warning_or_error
, NULL_TREE
);
11881 if (dependent_type_p (friend_type
))
11882 adjust_processing_template_decl
= true;
11883 --processing_template_decl
;
11885 else if (TREE_CODE (friend_type
) != BOUND_TEMPLATE_TEMPLATE_PARM
11886 && !CLASSTYPE_USE_TEMPLATE (friend_type
)
11887 && TYPE_HIDDEN_P (friend_type
))
11891 where C hasn't been declared yet. Let's lookup name
11892 from namespace scope directly, bypassing any name that
11893 come from dependent base class. */
11894 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
11896 /* The call to xref_tag_from_type does injection for friend
11898 push_nested_namespace (ns
);
11900 xref_tag_from_type (friend_type
, NULL_TREE
,
11901 /*tag_scope=*/ts_current
);
11902 pop_nested_namespace (ns
);
11904 else if (uses_template_parms (friend_type
))
11905 /* friend class C<T>; */
11906 friend_type
= tsubst (friend_type
, args
,
11907 tf_warning_or_error
, NULL_TREE
);
11912 where C is already declared or
11914 friend class C<int>;
11916 We don't have to do anything in these cases. */
11918 if (adjust_processing_template_decl
)
11919 /* Trick make_friend_class into realizing that the friend
11920 we're adding is a template, not an ordinary class. It's
11921 important that we use make_friend_class since it will
11922 perform some error-checking and output cross-reference
11924 ++processing_template_decl
;
11926 if (friend_type
!= error_mark_node
)
11927 make_friend_class (type
, friend_type
, /*complain=*/false);
11929 if (adjust_processing_template_decl
)
11930 --processing_template_decl
;
11934 /* Build new DECL_FRIENDLIST. */
11937 /* The file and line for this declaration, to
11938 assist in error message reporting. Since we
11939 called push_tinst_level above, we don't need to
11941 input_location
= DECL_SOURCE_LOCATION (t
);
11943 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11945 ++processing_template_decl
;
11946 push_deferring_access_checks (dk_no_check
);
11949 r
= tsubst_friend_function (t
, args
);
11950 add_friend (type
, r
, /*complain=*/false);
11951 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11953 pop_deferring_access_checks ();
11954 --processing_template_decl
;
11962 /* Restore these before substituting into the lambda capture
11964 cp_unevaluated_operand
= saved_unevaluated_operand
;
11965 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
11968 /* Set the file and line number information to whatever is given for
11969 the class itself. This puts error messages involving generated
11970 implicit functions at a predictable point, and the same point
11971 that would be used for non-template classes. */
11972 input_location
= DECL_SOURCE_LOCATION (typedecl
);
11974 unreverse_member_declarations (type
);
11975 finish_struct_1 (type
);
11976 TYPE_BEING_DEFINED (type
) = 0;
11978 /* We don't instantiate default arguments for member functions. 14.7.1:
11980 The implicit instantiation of a class template specialization causes
11981 the implicit instantiation of the declarations, but not of the
11982 definitions or default arguments, of the class member functions,
11983 member classes, static data members and member templates.... */
11985 /* Some typedefs referenced from within the template code need to be access
11986 checked at template instantiation time, i.e now. These types were
11987 added to the template at parsing time. Let's get those and perform
11988 the access checks then. */
11989 perform_typedefs_access_check (pattern
, args
);
11990 perform_deferred_access_checks (tf_warning_or_error
);
11991 pop_nested_class ();
11992 maximum_field_alignment
= saved_maximum_field_alignment
;
11994 pop_from_top_level ();
11995 pop_tinst_level ();
11997 /* The vtable for a template class can be emitted in any translation
11998 unit in which the class is instantiated. When there is no key
11999 method, however, finish_struct_1 will already have added TYPE to
12000 the keyed_classes. */
12001 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
12002 vec_safe_push (keyed_classes
, type
);
12007 /* Wrapper for instantiate_class_template_1. */
12010 instantiate_class_template (tree type
)
12013 timevar_push (TV_TEMPLATE_INST
);
12014 ret
= instantiate_class_template_1 (type
);
12015 timevar_pop (TV_TEMPLATE_INST
);
12020 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12026 else if (TYPE_P (t
))
12027 r
= tsubst (t
, args
, complain
, in_decl
);
12030 if (!(complain
& tf_warning
))
12031 ++c_inhibit_evaluation_warnings
;
12032 r
= tsubst_expr (t
, args
, complain
, in_decl
,
12033 /*integral_constant_expression_p=*/true);
12034 if (!(complain
& tf_warning
))
12035 --c_inhibit_evaluation_warnings
;
12041 /* Given a function parameter pack TMPL_PARM and some function parameters
12042 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
12043 and set *SPEC_P to point at the next point in the list. */
12046 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
12048 /* Collect all of the extra "packed" parameters into an
12051 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
12052 tree spec_parm
= *spec_p
;
12055 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
12057 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
12060 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
12061 parmvec
= make_tree_vec (len
);
12062 spec_parm
= *spec_p
;
12063 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
12065 tree elt
= spec_parm
;
12066 if (DECL_PACK_P (elt
))
12067 elt
= make_pack_expansion (elt
);
12068 TREE_VEC_ELT (parmvec
, i
) = elt
;
12071 /* Build the argument packs. */
12072 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
12073 *spec_p
= spec_parm
;
12078 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
12079 NONTYPE_ARGUMENT_PACK. */
12082 make_fnparm_pack (tree spec_parm
)
12084 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
12087 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
12088 pack expansion with no extra args, 2 if it has extra args, or 0
12089 if it is not a pack expansion. */
12092 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
12094 if (TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
12095 /* We're being called before this happens in tsubst_pack_expansion. */
12096 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
12097 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
12098 if (i
>= TREE_VEC_LENGTH (vec
))
12100 tree elt
= TREE_VEC_ELT (vec
, i
);
12102 /* A decl pack is itself an expansion. */
12103 elt
= TREE_TYPE (elt
);
12104 if (!PACK_EXPANSION_P (elt
))
12106 if (PACK_EXPANSION_EXTRA_ARGS (elt
))
12112 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
12115 make_argument_pack_select (tree arg_pack
, unsigned index
)
12117 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
12119 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
12120 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
12125 /* This is a subroutine of tsubst_pack_expansion.
12127 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
12128 mechanism to store the (non complete list of) arguments of the
12129 substitution and return a non substituted pack expansion, in order
12130 to wait for when we have enough arguments to really perform the
12134 use_pack_expansion_extra_args_p (tree parm_packs
,
12136 bool has_empty_arg
)
12138 /* If one pack has an expansion and another pack has a normal
12139 argument or if one pack has an empty argument and an another
12140 one hasn't then tsubst_pack_expansion cannot perform the
12141 substitution and need to fall back on the
12142 PACK_EXPANSION_EXTRA mechanism. */
12143 if (parm_packs
== NULL_TREE
)
12145 else if (has_empty_arg
)
12147 /* If all the actual packs are pack expansions, we can still
12148 subsitute directly. */
12149 for (tree p
= parm_packs
; p
; p
= TREE_CHAIN (p
))
12151 tree a
= TREE_VALUE (p
);
12152 if (TREE_CODE (a
) == ARGUMENT_PACK_SELECT
)
12153 a
= ARGUMENT_PACK_SELECT_FROM_PACK (a
);
12154 a
= ARGUMENT_PACK_ARGS (a
);
12155 if (TREE_VEC_LENGTH (a
) == 1)
12156 a
= TREE_VEC_ELT (a
, 0);
12157 if (PACK_EXPANSION_P (a
))
12164 bool has_expansion_arg
= false;
12165 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
12167 bool has_non_expansion_arg
= false;
12168 for (tree parm_pack
= parm_packs
;
12170 parm_pack
= TREE_CHAIN (parm_pack
))
12172 tree arg
= TREE_VALUE (parm_pack
);
12174 int exp
= argument_pack_element_is_expansion_p (arg
, i
);
12176 /* We can't substitute a pack expansion with extra args into
12180 has_expansion_arg
= true;
12182 has_non_expansion_arg
= true;
12185 if (has_expansion_arg
&& has_non_expansion_arg
)
12191 /* [temp.variadic]/6 says that:
12193 The instantiation of a pack expansion [...]
12194 produces a list E1,E2, ..., En, where N is the number of elements
12195 in the pack expansion parameters.
12197 This subroutine of tsubst_pack_expansion produces one of these Ei.
12199 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
12200 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
12201 PATTERN, and each TREE_VALUE is its corresponding argument pack.
12202 INDEX is the index 'i' of the element Ei to produce. ARGS,
12203 COMPLAIN, and IN_DECL are the same parameters as for the
12204 tsubst_pack_expansion function.
12206 The function returns the resulting Ei upon successful completion,
12207 or error_mark_node.
12209 Note that this function possibly modifies the ARGS parameter, so
12210 it's the responsibility of the caller to restore it. */
12213 gen_elem_of_pack_expansion_instantiation (tree pattern
,
12216 tree args
/* This parm gets
12218 tsubst_flags_t complain
,
12222 bool ith_elem_is_expansion
= false;
12224 /* For each parameter pack, change the substitution of the parameter
12225 pack to the ith argument in its argument pack, then expand the
12227 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
12229 tree parm
= TREE_PURPOSE (pack
);
12230 tree arg_pack
= TREE_VALUE (pack
);
12231 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
12233 ith_elem_is_expansion
|=
12234 argument_pack_element_is_expansion_p (arg_pack
, index
);
12236 /* Select the Ith argument from the pack. */
12237 if (TREE_CODE (parm
) == PARM_DECL
12239 || TREE_CODE (parm
) == FIELD_DECL
)
12243 aps
= make_argument_pack_select (arg_pack
, index
);
12244 if (!mark_used (parm
, complain
) && !(complain
& tf_error
))
12245 return error_mark_node
;
12246 register_local_specialization (aps
, parm
);
12249 aps
= retrieve_local_specialization (parm
);
12254 template_parm_level_and_index (parm
, &level
, &idx
);
12258 aps
= make_argument_pack_select (arg_pack
, index
);
12259 /* Update the corresponding argument. */
12260 TMPL_ARG (args
, level
, idx
) = aps
;
12263 /* Re-use the ARGUMENT_PACK_SELECT. */
12264 aps
= TMPL_ARG (args
, level
, idx
);
12266 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
12269 /* Substitute into the PATTERN with the (possibly altered)
12271 if (pattern
== in_decl
)
12272 /* Expanding a fixed parameter pack from
12273 coerce_template_parameter_pack. */
12274 t
= tsubst_decl (pattern
, args
, complain
);
12275 else if (pattern
== error_mark_node
)
12276 t
= error_mark_node
;
12277 else if (!TYPE_P (pattern
))
12278 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
12279 /*integral_constant_expression_p=*/false);
12281 t
= tsubst (pattern
, args
, complain
, in_decl
);
12283 /* If the Ith argument pack element is a pack expansion, then
12284 the Ith element resulting from the substituting is going to
12285 be a pack expansion as well. */
12286 if (ith_elem_is_expansion
)
12287 t
= make_pack_expansion (t
, complain
);
12292 /* When the unexpanded parameter pack in a fold expression expands to an empty
12293 sequence, the value of the expression is as follows; the program is
12294 ill-formed if the operator is not listed in this table.
12301 expand_empty_fold (tree t
, tsubst_flags_t complain
)
12303 tree_code code
= (tree_code
)TREE_INT_CST_LOW (TREE_OPERAND (t
, 0));
12304 if (!FOLD_EXPR_MODIFY_P (t
))
12307 case TRUTH_ANDIF_EXPR
:
12308 return boolean_true_node
;
12309 case TRUTH_ORIF_EXPR
:
12310 return boolean_false_node
;
12311 case COMPOUND_EXPR
:
12317 if (complain
& tf_error
)
12318 error_at (location_of (t
),
12319 "fold of empty expansion over %O", code
);
12320 return error_mark_node
;
12323 /* Given a fold-expression T and a current LEFT and RIGHT operand,
12324 form an expression that combines the two terms using the
12328 fold_expression (tree t
, tree left
, tree right
, tsubst_flags_t complain
)
12330 tree op
= FOLD_EXPR_OP (t
);
12331 tree_code code
= (tree_code
)TREE_INT_CST_LOW (op
);
12333 // Handle compound assignment operators.
12334 if (FOLD_EXPR_MODIFY_P (t
))
12335 return build_x_modify_expr (input_location
, left
, code
, right
, complain
);
12339 case COMPOUND_EXPR
:
12340 return build_x_compound_expr (input_location
, left
, right
, complain
);
12342 return build_x_binary_op (input_location
, code
,
12343 left
, TREE_CODE (left
),
12344 right
, TREE_CODE (right
),
12350 /* Substitute ARGS into the pack of a fold expression T. */
12353 tsubst_fold_expr_pack (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12355 return tsubst_pack_expansion (FOLD_EXPR_PACK (t
), args
, complain
, in_decl
);
12358 /* Substitute ARGS into the pack of a fold expression T. */
12361 tsubst_fold_expr_init (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12363 return tsubst_expr (FOLD_EXPR_INIT (t
), args
, complain
, in_decl
, false);
12366 /* Expand a PACK of arguments into a grouped as left fold.
12367 Given a pack containing elements A0, A1, ..., An and an
12368 operator @, this builds the expression:
12370 ((A0 @ A1) @ A2) ... @ An
12372 Note that PACK must not be empty.
12374 The operator is defined by the original fold expression T. */
12377 expand_left_fold (tree t
, tree pack
, tsubst_flags_t complain
)
12379 tree left
= TREE_VEC_ELT (pack
, 0);
12380 for (int i
= 1; i
< TREE_VEC_LENGTH (pack
); ++i
)
12382 tree right
= TREE_VEC_ELT (pack
, i
);
12383 left
= fold_expression (t
, left
, right
, complain
);
12388 /* Substitute into a unary left fold expression. */
12391 tsubst_unary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
12394 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
12395 if (pack
== error_mark_node
)
12396 return error_mark_node
;
12397 if (PACK_EXPANSION_P (pack
))
12399 tree r
= copy_node (t
);
12400 FOLD_EXPR_PACK (r
) = pack
;
12403 if (TREE_VEC_LENGTH (pack
) == 0)
12404 return expand_empty_fold (t
, complain
);
12406 return expand_left_fold (t
, pack
, complain
);
12409 /* Substitute into a binary left fold expression.
12411 Do ths by building a single (non-empty) vector of argumnts and
12412 building the expression from those elements. */
12415 tsubst_binary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
12418 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
12419 if (pack
== error_mark_node
)
12420 return error_mark_node
;
12421 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
12422 if (init
== error_mark_node
)
12423 return error_mark_node
;
12425 if (PACK_EXPANSION_P (pack
))
12427 tree r
= copy_node (t
);
12428 FOLD_EXPR_PACK (r
) = pack
;
12429 FOLD_EXPR_INIT (r
) = init
;
12433 tree vec
= make_tree_vec (TREE_VEC_LENGTH (pack
) + 1);
12434 TREE_VEC_ELT (vec
, 0) = init
;
12435 for (int i
= 0; i
< TREE_VEC_LENGTH (pack
); ++i
)
12436 TREE_VEC_ELT (vec
, i
+ 1) = TREE_VEC_ELT (pack
, i
);
12438 return expand_left_fold (t
, vec
, complain
);
12441 /* Expand a PACK of arguments into a grouped as right fold.
12442 Given a pack containing elementns A0, A1, ..., and an
12443 operator @, this builds the expression:
12445 A0@ ... (An-2 @ (An-1 @ An))
12447 Note that PACK must not be empty.
12449 The operator is defined by the original fold expression T. */
12452 expand_right_fold (tree t
, tree pack
, tsubst_flags_t complain
)
12454 // Build the expression.
12455 int n
= TREE_VEC_LENGTH (pack
);
12456 tree right
= TREE_VEC_ELT (pack
, n
- 1);
12457 for (--n
; n
!= 0; --n
)
12459 tree left
= TREE_VEC_ELT (pack
, n
- 1);
12460 right
= fold_expression (t
, left
, right
, complain
);
12465 /* Substitute into a unary right fold expression. */
12468 tsubst_unary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
12471 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
12472 if (pack
== error_mark_node
)
12473 return error_mark_node
;
12474 if (PACK_EXPANSION_P (pack
))
12476 tree r
= copy_node (t
);
12477 FOLD_EXPR_PACK (r
) = pack
;
12480 if (TREE_VEC_LENGTH (pack
) == 0)
12481 return expand_empty_fold (t
, complain
);
12483 return expand_right_fold (t
, pack
, complain
);
12486 /* Substitute into a binary right fold expression.
12488 Do ths by building a single (non-empty) vector of arguments and
12489 building the expression from those elements. */
12492 tsubst_binary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
12495 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
12496 if (pack
== error_mark_node
)
12497 return error_mark_node
;
12498 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
12499 if (init
== error_mark_node
)
12500 return error_mark_node
;
12502 if (PACK_EXPANSION_P (pack
))
12504 tree r
= copy_node (t
);
12505 FOLD_EXPR_PACK (r
) = pack
;
12506 FOLD_EXPR_INIT (r
) = init
;
12510 int n
= TREE_VEC_LENGTH (pack
);
12511 tree vec
= make_tree_vec (n
+ 1);
12512 for (int i
= 0; i
< n
; ++i
)
12513 TREE_VEC_ELT (vec
, i
) = TREE_VEC_ELT (pack
, i
);
12514 TREE_VEC_ELT (vec
, n
) = init
;
12516 return expand_right_fold (t
, vec
, complain
);
12519 /* Walk through the pattern of a pack expansion, adding everything in
12520 local_specializations to a list. */
12525 hash_set
<tree
> internal
;
12527 tsubst_flags_t complain
;
12529 el_data (tsubst_flags_t c
)
12530 : extra (NULL_TREE
), complain (c
) {}
12533 extract_locals_r (tree
*tp
, int */
*walk_subtrees*/
, void *data_
)
12535 el_data
&data
= *reinterpret_cast<el_data
*>(data_
);
12536 tree
*extra
= &data
.extra
;
12537 tsubst_flags_t complain
= data
.complain
;
12539 if (TYPE_P (*tp
) && typedef_variant_p (*tp
))
12540 /* Remember local typedefs (85214). */
12541 tp
= &TYPE_NAME (*tp
);
12543 if (TREE_CODE (*tp
) == DECL_EXPR
)
12544 data
.internal
.add (DECL_EXPR_DECL (*tp
));
12545 else if (tree spec
= retrieve_local_specialization (*tp
))
12547 if (data
.internal
.contains (*tp
))
12548 /* Don't mess with variables declared within the pattern. */
12550 if (TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
)
12552 /* Maybe pull out the PARM_DECL for a partial instantiation. */
12553 tree args
= ARGUMENT_PACK_ARGS (spec
);
12554 if (TREE_VEC_LENGTH (args
) == 1)
12556 tree elt
= TREE_VEC_ELT (args
, 0);
12557 if (PACK_EXPANSION_P (elt
))
12558 elt
= PACK_EXPANSION_PATTERN (elt
);
12559 if (DECL_PACK_P (elt
))
12562 if (TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
)
12564 /* Handle lambda capture here, since we aren't doing any
12565 substitution now, and so tsubst_copy won't call
12566 process_outer_var_ref. */
12567 tree args
= ARGUMENT_PACK_ARGS (spec
);
12568 int len
= TREE_VEC_LENGTH (args
);
12569 for (int i
= 0; i
< len
; ++i
)
12571 tree arg
= TREE_VEC_ELT (args
, i
);
12573 if (outer_automatic_var_p (arg
))
12574 carg
= process_outer_var_ref (arg
, complain
);
12577 /* Make a new NONTYPE_ARGUMENT_PACK of the capture
12581 spec
= copy_node (spec
);
12582 args
= copy_node (args
);
12583 SET_ARGUMENT_PACK_ARGS (spec
, args
);
12584 register_local_specialization (spec
, *tp
);
12586 TREE_VEC_ELT (args
, i
) = carg
;
12591 if (outer_automatic_var_p (spec
))
12592 spec
= process_outer_var_ref (spec
, complain
);
12593 *extra
= tree_cons (*tp
, spec
, *extra
);
12598 extract_local_specs (tree pattern
, tsubst_flags_t complain
)
12600 el_data
data (complain
);
12601 cp_walk_tree_without_duplicates (&pattern
, extract_locals_r
, &data
);
12605 /* Extract any uses of local_specializations from PATTERN and add them to ARGS
12606 for use in PACK_EXPANSION_EXTRA_ARGS. */
12609 build_extra_args (tree pattern
, tree args
, tsubst_flags_t complain
)
12612 if (local_specializations
)
12613 if (tree locals
= extract_local_specs (pattern
, complain
))
12614 extra
= tree_cons (NULL_TREE
, extra
, locals
);
12618 /* Apply any local specializations from PACK_EXPANSION_EXTRA_ARGS and add the
12619 normal template args to ARGS. */
12622 add_extra_args (tree extra
, tree args
)
12624 if (extra
&& TREE_CODE (extra
) == TREE_LIST
)
12626 for (tree elt
= TREE_CHAIN (extra
); elt
; elt
= TREE_CHAIN (elt
))
12628 /* The partial instantiation involved local declarations collected in
12629 extract_local_specs; map from the general template to our local
12631 tree gen
= TREE_PURPOSE (elt
);
12632 tree inst
= TREE_VALUE (elt
);
12634 if (tree local
= retrieve_local_specialization (inst
))
12636 /* else inst is already a full instantiation of the pack. */
12637 register_local_specialization (inst
, gen
);
12639 gcc_assert (!TREE_PURPOSE (extra
));
12640 extra
= TREE_VALUE (extra
);
12643 /* I think we should always be able to substitute dependent args into the
12644 pattern. If that turns out to be incorrect in some cases, enable the
12645 alternate code (and add complain/in_decl parms to this function). */
12646 gcc_checking_assert (!uses_template_parms (extra
));
12648 if (!uses_template_parms (extra
))
12650 gcc_unreachable ();
12651 extra
= tsubst_template_args (extra
, args
, complain
, in_decl
);
12652 args
= add_outermost_template_args (args
, extra
);
12656 args
= add_to_template_args (extra
, args
);
12660 /* Substitute ARGS into T, which is an pack expansion
12661 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
12662 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
12663 (if only a partial substitution could be performed) or
12664 ERROR_MARK_NODE if there was an error. */
12666 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
12670 tree pack
, packs
= NULL_TREE
;
12671 bool unsubstituted_packs
= false;
12672 bool unsubstituted_fn_pack
= false;
12675 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
12676 bool need_local_specializations
= false;
12679 gcc_assert (PACK_EXPANSION_P (t
));
12680 pattern
= PACK_EXPANSION_PATTERN (t
);
12682 /* Add in any args remembered from an earlier partial instantiation. */
12683 args
= add_extra_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
12685 levels
= TMPL_ARGS_DEPTH (args
);
12687 /* Determine the argument packs that will instantiate the parameter
12688 packs used in the expansion expression. While we're at it,
12689 compute the number of arguments to be expanded and make sure it
12691 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
12692 pack
= TREE_CHAIN (pack
))
12694 tree parm_pack
= TREE_VALUE (pack
);
12695 tree arg_pack
= NULL_TREE
;
12696 tree orig_arg
= NULL_TREE
;
12699 if (TREE_CODE (parm_pack
) == BASES
)
12701 gcc_assert (parm_pack
== pattern
);
12702 if (BASES_DIRECT (parm_pack
))
12703 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
12708 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
12709 args
, complain
, in_decl
,
12712 else if (builtin_pack_call_p (parm_pack
))
12714 if (parm_pack
!= pattern
)
12716 if (complain
& tf_error
)
12717 sorry ("%qE is not the entire pattern of the pack expansion",
12719 return error_mark_node
;
12721 return expand_builtin_pack_call (parm_pack
, args
,
12722 complain
, in_decl
);
12724 else if (TREE_CODE (parm_pack
) == PARM_DECL
)
12726 /* We know we have correct local_specializations if this
12727 expansion is at function scope, or if we're dealing with a
12728 local parameter in a requires expression; for the latter,
12729 tsubst_requires_expr set it up appropriately. */
12730 if (PACK_EXPANSION_LOCAL_P (t
) || CONSTRAINT_VAR_P (parm_pack
))
12731 arg_pack
= retrieve_local_specialization (parm_pack
);
12733 /* We can't rely on local_specializations for a parameter
12734 name used later in a function declaration (such as in a
12735 late-specified return type). Even if it exists, it might
12736 have the wrong value for a recursive call. */
12737 need_local_specializations
= true;
12741 /* This parameter pack was used in an unevaluated context. Just
12742 make a dummy decl, since it's only used for its type. */
12743 ++cp_unevaluated_operand
;
12744 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
12745 --cp_unevaluated_operand
;
12746 if (arg_pack
&& DECL_PACK_P (arg_pack
))
12747 /* Partial instantiation of the parm_pack, we can't build
12748 up an argument pack yet. */
12749 arg_pack
= NULL_TREE
;
12751 arg_pack
= make_fnparm_pack (arg_pack
);
12753 else if (argument_pack_element_is_expansion_p (arg_pack
, 0))
12754 /* This argument pack isn't fully instantiated yet. We set this
12755 flag rather than clear arg_pack because we do want to do the
12756 optimization below, and we don't want to substitute directly
12757 into the pattern (as that would expose a NONTYPE_ARGUMENT_PACK
12758 where it isn't expected). */
12759 unsubstituted_fn_pack
= true;
12761 else if (is_capture_proxy (parm_pack
))
12763 arg_pack
= retrieve_local_specialization (parm_pack
);
12764 if (argument_pack_element_is_expansion_p (arg_pack
, 0))
12765 unsubstituted_fn_pack
= true;
12770 template_parm_level_and_index (parm_pack
, &level
, &idx
);
12771 if (level
<= levels
)
12772 arg_pack
= TMPL_ARG (args
, level
, idx
);
12775 orig_arg
= arg_pack
;
12776 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
12777 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
12779 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
12780 /* This can only happen if we forget to expand an argument
12781 pack somewhere else. Just return an error, silently. */
12783 result
= make_tree_vec (1);
12784 TREE_VEC_ELT (result
, 0) = error_mark_node
;
12791 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
12793 /* Don't bother trying to do a partial substitution with
12794 incomplete packs; we'll try again after deduction. */
12795 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
12800 else if (len
!= my_len
12801 && !unsubstituted_fn_pack
)
12803 if (!(complain
& tf_error
))
12804 /* Fail quietly. */;
12805 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
12806 error ("mismatched argument pack lengths while expanding %qT",
12809 error ("mismatched argument pack lengths while expanding %qE",
12811 return error_mark_node
;
12814 /* Keep track of the parameter packs and their corresponding
12816 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
12817 TREE_TYPE (packs
) = orig_arg
;
12821 /* We can't substitute for this parameter pack. We use a flag as
12822 well as the missing_level counter because function parameter
12823 packs don't have a level. */
12824 if (!(processing_template_decl
|| is_auto (parm_pack
)))
12826 gcc_unreachable ();
12828 gcc_assert (processing_template_decl
|| is_auto (parm_pack
));
12829 unsubstituted_packs
= true;
12833 /* If the expansion is just T..., return the matching argument pack, unless
12834 we need to call convert_from_reference on all the elements. This is an
12835 important optimization; see c++/68422. */
12836 if (!unsubstituted_packs
12837 && TREE_PURPOSE (packs
) == pattern
)
12839 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
12841 /* If the argument pack is a single pack expansion, pull it out. */
12842 if (TREE_VEC_LENGTH (args
) == 1
12843 && pack_expansion_args_count (args
))
12844 return TREE_VEC_ELT (args
, 0);
12846 /* Types need no adjustment, nor does sizeof..., and if we still have
12847 some pack expansion args we won't do anything yet. */
12848 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
12849 || PACK_EXPANSION_SIZEOF_P (t
)
12850 || pack_expansion_args_count (args
))
12852 /* Also optimize expression pack expansions if we can tell that the
12853 elements won't have reference type. */
12854 tree type
= TREE_TYPE (pattern
);
12855 if (type
&& !TYPE_REF_P (type
)
12856 && !PACK_EXPANSION_P (type
)
12857 && !WILDCARD_TYPE_P (type
))
12859 /* Otherwise use the normal path so we get convert_from_reference. */
12862 /* We cannot expand this expansion expression, because we don't have
12863 all of the argument packs we need. */
12864 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
12866 /* We got some full packs, but we can't substitute them in until we
12867 have values for all the packs. So remember these until then. */
12869 t
= make_pack_expansion (pattern
, complain
);
12870 PACK_EXPANSION_EXTRA_ARGS (t
)
12871 = build_extra_args (pattern
, args
, complain
);
12874 else if (unsubstituted_packs
)
12876 /* There were no real arguments, we're just replacing a parameter
12877 pack with another version of itself. Substitute into the
12878 pattern and return a PACK_EXPANSION_*. The caller will need to
12880 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
12881 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
12882 /*integral_constant_expression_p=*/false);
12884 t
= tsubst (pattern
, args
, complain
, in_decl
);
12885 t
= make_pack_expansion (t
, complain
);
12889 gcc_assert (len
>= 0);
12891 if (need_local_specializations
)
12893 /* We're in a late-specified return type, so create our own local
12894 specializations map; the current map is either NULL or (in the
12895 case of recursive unification) might have bindings that we don't
12896 want to use or alter. */
12897 saved_local_specializations
= local_specializations
;
12898 local_specializations
= new hash_map
<tree
, tree
>;
12901 /* For each argument in each argument pack, substitute into the
12903 result
= make_tree_vec (len
);
12904 tree elem_args
= copy_template_args (args
);
12905 for (i
= 0; i
< len
; ++i
)
12907 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
12909 elem_args
, complain
,
12911 TREE_VEC_ELT (result
, i
) = t
;
12912 if (t
== error_mark_node
)
12914 result
= error_mark_node
;
12919 /* Update ARGS to restore the substitution from parameter packs to
12920 their argument packs. */
12921 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12923 tree parm
= TREE_PURPOSE (pack
);
12925 if (TREE_CODE (parm
) == PARM_DECL
12927 || TREE_CODE (parm
) == FIELD_DECL
)
12928 register_local_specialization (TREE_TYPE (pack
), parm
);
12933 if (TREE_VALUE (pack
) == NULL_TREE
)
12936 template_parm_level_and_index (parm
, &level
, &idx
);
12938 /* Update the corresponding argument. */
12939 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
12940 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
12943 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
12947 if (need_local_specializations
)
12949 delete local_specializations
;
12950 local_specializations
= saved_local_specializations
;
12953 /* If the dependent pack arguments were such that we end up with only a
12954 single pack expansion again, there's no need to keep it in a TREE_VEC. */
12955 if (len
== 1 && TREE_CODE (result
) == TREE_VEC
12956 && PACK_EXPANSION_P (TREE_VEC_ELT (result
, 0)))
12957 return TREE_VEC_ELT (result
, 0);
12962 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
12963 TMPL. We do this using DECL_PARM_INDEX, which should work even with
12964 parameter packs; all parms generated from a function parameter pack will
12965 have the same DECL_PARM_INDEX. */
12968 get_pattern_parm (tree parm
, tree tmpl
)
12970 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
12973 if (DECL_ARTIFICIAL (parm
))
12975 for (patparm
= DECL_ARGUMENTS (pattern
);
12976 patparm
; patparm
= DECL_CHAIN (patparm
))
12977 if (DECL_ARTIFICIAL (patparm
)
12978 && DECL_NAME (parm
) == DECL_NAME (patparm
))
12983 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
12984 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
12985 gcc_assert (DECL_PARM_INDEX (patparm
)
12986 == DECL_PARM_INDEX (parm
));
12992 /* Make an argument pack out of the TREE_VEC VEC. */
12995 make_argument_pack (tree vec
)
12998 tree elt
= TREE_VEC_ELT (vec
, 0);
13000 pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
13003 pack
= make_node (NONTYPE_ARGUMENT_PACK
);
13004 TREE_CONSTANT (pack
) = 1;
13006 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
13010 /* Return an exact copy of template args T that can be modified
13014 copy_template_args (tree t
)
13016 if (t
== error_mark_node
)
13019 int len
= TREE_VEC_LENGTH (t
);
13020 tree new_vec
= make_tree_vec (len
);
13022 for (int i
= 0; i
< len
; ++i
)
13024 tree elt
= TREE_VEC_ELT (t
, i
);
13025 if (elt
&& TREE_CODE (elt
) == TREE_VEC
)
13026 elt
= copy_template_args (elt
);
13027 TREE_VEC_ELT (new_vec
, i
) = elt
;
13030 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_vec
)
13031 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
13036 /* Substitute ARGS into the *_ARGUMENT_PACK orig_arg. */
13039 tsubst_argument_pack (tree orig_arg
, tree args
, tsubst_flags_t complain
,
13042 /* Substitute into each of the arguments. */
13043 tree new_arg
= TYPE_P (orig_arg
)
13044 ? cxx_make_type (TREE_CODE (orig_arg
))
13045 : make_node (TREE_CODE (orig_arg
));
13047 tree pack_args
= tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
13048 args
, complain
, in_decl
);
13049 if (pack_args
== error_mark_node
)
13050 new_arg
= error_mark_node
;
13052 SET_ARGUMENT_PACK_ARGS (new_arg
, pack_args
);
13054 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
)
13055 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
13060 /* Substitute ARGS into the vector or list of template arguments T. */
13063 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
13066 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
13069 if (t
== error_mark_node
)
13070 return error_mark_node
;
13072 len
= TREE_VEC_LENGTH (t
);
13073 elts
= XALLOCAVEC (tree
, len
);
13075 for (i
= 0; i
< len
; i
++)
13077 tree orig_arg
= TREE_VEC_ELT (t
, i
);
13080 if (TREE_CODE (orig_arg
) == TREE_VEC
)
13081 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
13082 else if (PACK_EXPANSION_P (orig_arg
))
13084 /* Substitute into an expansion expression. */
13085 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
13087 if (TREE_CODE (new_arg
) == TREE_VEC
)
13088 /* Add to the expanded length adjustment the number of
13089 expanded arguments. We subtract one from this
13090 measurement, because the argument pack expression
13091 itself is already counted as 1 in
13092 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
13093 the argument pack is empty. */
13094 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
13096 else if (ARGUMENT_PACK_P (orig_arg
))
13097 new_arg
= tsubst_argument_pack (orig_arg
, args
, complain
, in_decl
);
13099 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
13101 if (new_arg
== error_mark_node
)
13102 return error_mark_node
;
13105 if (new_arg
!= orig_arg
)
13112 /* Make space for the expanded arguments coming from template
13114 t
= make_tree_vec (len
+ expanded_len_adjust
);
13115 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
13116 arguments for a member template.
13117 In that case each TREE_VEC in ORIG_T represents a level of template
13118 arguments, and ORIG_T won't carry any non defaulted argument count.
13119 It will rather be the nested TREE_VECs that will carry one.
13120 In other words, ORIG_T carries a non defaulted argument count only
13121 if it doesn't contain any nested TREE_VEC. */
13122 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
13124 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
13125 count
+= expanded_len_adjust
;
13126 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
13128 for (i
= 0, out
= 0; i
< len
; i
++)
13130 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
13131 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
13132 && TREE_CODE (elts
[i
]) == TREE_VEC
)
13136 /* Now expand the template argument pack "in place". */
13137 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
13138 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
13142 TREE_VEC_ELT (t
, out
) = elts
[i
];
13150 /* Substitute ARGS into one level PARMS of template parameters. */
13153 tsubst_template_parms_level (tree parms
, tree args
, tsubst_flags_t complain
)
13155 if (parms
== error_mark_node
)
13156 return error_mark_node
;
13158 tree new_vec
= make_tree_vec (TREE_VEC_LENGTH (parms
));
13160 for (int i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
13162 tree tuple
= TREE_VEC_ELT (parms
, i
);
13164 if (tuple
== error_mark_node
)
13167 TREE_VEC_ELT (new_vec
, i
) =
13168 tsubst_template_parm (tuple
, args
, complain
);
13174 /* Return the result of substituting ARGS into the template parameters
13175 given by PARMS. If there are m levels of ARGS and m + n levels of
13176 PARMS, then the result will contain n levels of PARMS. For
13177 example, if PARMS is `template <class T> template <class U>
13178 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
13179 result will be `template <int*, double, class V>'. */
13182 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
13184 tree r
= NULL_TREE
;
13187 /* When substituting into a template, we must set
13188 PROCESSING_TEMPLATE_DECL as the template parameters may be
13189 dependent if they are based on one-another, and the dependency
13190 predicates are short-circuit outside of templates. */
13191 ++processing_template_decl
;
13193 for (new_parms
= &r
;
13194 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
13195 new_parms
= &(TREE_CHAIN (*new_parms
)),
13196 parms
= TREE_CHAIN (parms
))
13198 tree new_vec
= tsubst_template_parms_level (TREE_VALUE (parms
),
13201 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
13202 - TMPL_ARGS_DEPTH (args
)),
13203 new_vec
, NULL_TREE
);
13206 --processing_template_decl
;
13211 /* Return the result of substituting ARGS into one template parameter
13212 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
13213 parameter and which TREE_PURPOSE is the default argument of the
13214 template parameter. */
13217 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
13219 tree default_value
, parm_decl
;
13221 if (args
== NULL_TREE
13223 || t
== error_mark_node
)
13226 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
13228 default_value
= TREE_PURPOSE (t
);
13229 parm_decl
= TREE_VALUE (t
);
13230 tree constraint
= TEMPLATE_PARM_CONSTRAINTS (t
);
13232 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
13233 if (TREE_CODE (parm_decl
) == PARM_DECL
13234 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
13235 parm_decl
= error_mark_node
;
13236 default_value
= tsubst_template_arg (default_value
, args
,
13237 complain
, NULL_TREE
);
13238 constraint
= tsubst_constraint (constraint
, args
, complain
, NULL_TREE
);
13240 tree r
= build_tree_list (default_value
, parm_decl
);
13241 TEMPLATE_PARM_CONSTRAINTS (r
) = constraint
;
13245 /* Substitute the ARGS into the indicated aggregate (or enumeration)
13246 type T. If T is not an aggregate or enumeration type, it is
13247 handled as if by tsubst. IN_DECL is as for tsubst. If
13248 ENTERING_SCOPE is nonzero, T is the context for a template which
13249 we are presently tsubst'ing. Return the substituted value. */
13252 tsubst_aggr_type (tree t
,
13254 tsubst_flags_t complain
,
13256 int entering_scope
)
13258 if (t
== NULL_TREE
)
13261 switch (TREE_CODE (t
))
13264 if (TYPE_PTRMEMFUNC_P (t
))
13265 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
13267 /* Fall through. */
13268 case ENUMERAL_TYPE
:
13270 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
13276 /* In "sizeof(X<I>)" we need to evaluate "I". */
13279 /* First, determine the context for the type we are looking
13281 context
= TYPE_CONTEXT (t
);
13282 if (context
&& TYPE_P (context
))
13284 context
= tsubst_aggr_type (context
, args
, complain
,
13285 in_decl
, /*entering_scope=*/1);
13286 /* If context is a nested class inside a class template,
13287 it may still need to be instantiated (c++/33959). */
13288 context
= complete_type (context
);
13291 /* Then, figure out what arguments are appropriate for the
13292 type we are trying to find. For example, given:
13294 template <class T> struct S;
13295 template <class T, class U> void f(T, U) { S<U> su; }
13297 and supposing that we are instantiating f<int, double>,
13298 then our ARGS will be {int, double}, but, when looking up
13299 S we only want {double}. */
13300 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
13301 complain
, in_decl
);
13302 if (argvec
== error_mark_node
)
13303 r
= error_mark_node
;
13306 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
13307 entering_scope
, complain
);
13308 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
13314 /* This is not a template type, so there's nothing to do. */
13318 return tsubst (t
, args
, complain
, in_decl
);
13322 static GTY((cache
)) decl_tree_cache_map
*defarg_inst
;
13324 /* Substitute into the default argument ARG (a default argument for
13325 FN), which has the indicated TYPE. */
13328 tsubst_default_argument (tree fn
, int parmnum
, tree type
, tree arg
,
13329 tsubst_flags_t complain
)
13331 int errs
= errorcount
+ sorrycount
;
13333 /* This can happen in invalid code. */
13334 if (TREE_CODE (arg
) == DEFERRED_PARSE
)
13337 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
13338 parm
= chain_index (parmnum
, parm
);
13339 tree parmtype
= TREE_TYPE (parm
);
13340 if (DECL_BY_REFERENCE (parm
))
13341 parmtype
= TREE_TYPE (parmtype
);
13342 if (parmtype
== error_mark_node
)
13343 return error_mark_node
;
13345 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, parmtype
));
13348 if (defarg_inst
&& (slot
= defarg_inst
->get (parm
)))
13351 /* This default argument came from a template. Instantiate the
13352 default argument here, not in tsubst. In the case of
13361 we must be careful to do name lookup in the scope of S<T>,
13362 rather than in the current class. */
13363 push_to_top_level ();
13364 push_access_scope (fn
);
13365 push_deferring_access_checks (dk_no_deferred
);
13366 start_lambda_scope (parm
);
13368 /* The default argument expression may cause implicitly defined
13369 member functions to be synthesized, which will result in garbage
13370 collection. We must treat this situation as if we were within
13371 the body of function so as to avoid collecting live data on the
13374 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
13375 complain
, NULL_TREE
,
13376 /*integral_constant_expression_p=*/false);
13379 finish_lambda_scope ();
13381 /* Make sure the default argument is reasonable. */
13382 arg
= check_default_argument (type
, arg
, complain
);
13384 if (errorcount
+sorrycount
> errs
13385 && (complain
& tf_warning_or_error
))
13386 inform (input_location
,
13387 " when instantiating default argument for call to %qD", fn
);
13389 pop_deferring_access_checks ();
13390 pop_access_scope (fn
);
13391 pop_from_top_level ();
13393 if (arg
!= error_mark_node
&& !cp_unevaluated_operand
)
13396 defarg_inst
= decl_tree_cache_map::create_ggc (37);
13397 defarg_inst
->put (parm
, arg
);
13403 /* Substitute into all the default arguments for FN. */
13406 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
13411 tmpl_args
= DECL_TI_ARGS (fn
);
13413 /* If this function is not yet instantiated, we certainly don't need
13414 its default arguments. */
13415 if (uses_template_parms (tmpl_args
))
13417 /* Don't do this again for clones. */
13418 if (DECL_CLONED_FUNCTION_P (fn
))
13422 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
13424 arg
= TREE_CHAIN (arg
), ++i
)
13425 if (TREE_PURPOSE (arg
))
13426 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
, i
,
13428 TREE_PURPOSE (arg
),
13432 /* Hash table mapping a FUNCTION_DECL to its dependent explicit-specifier. */
13433 static GTY((cache
)) decl_tree_cache_map
*explicit_specifier_map
;
13435 /* Store a pair to EXPLICIT_SPECIFIER_MAP. */
13438 store_explicit_specifier (tree v
, tree t
)
13440 if (!explicit_specifier_map
)
13441 explicit_specifier_map
= decl_tree_cache_map::create_ggc (37);
13442 DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (v
) = true;
13443 explicit_specifier_map
->put (v
, t
);
13446 /* Lookup an element in EXPLICIT_SPECIFIER_MAP. */
13449 lookup_explicit_specifier (tree v
)
13451 return *explicit_specifier_map
->get (v
);
13454 /* Subroutine of tsubst_decl for the case when T is a FUNCTION_DECL. */
13457 tsubst_function_decl (tree t
, tree args
, tsubst_flags_t complain
,
13458 tree lambda_fntype
)
13460 tree gen_tmpl
, argvec
;
13461 hashval_t hash
= 0;
13464 /* Nobody should be tsubst'ing into non-template functions. */
13465 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
13467 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
13469 /* If T is not dependent, just return it. */
13470 if (!uses_template_parms (DECL_TI_ARGS (t
))
13471 && !LAMBDA_FUNCTION_P (t
))
13474 /* Calculate the most general template of which R is a
13476 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
13478 /* We're substituting a lambda function under tsubst_lambda_expr but not
13479 directly from it; find the matching function we're already inside.
13480 But don't do this if T is a generic lambda with a single level of
13481 template parms, as in that case we're doing a normal instantiation. */
13482 if (LAMBDA_FUNCTION_P (t
) && !lambda_fntype
13483 && (!generic_lambda_fn_p (t
)
13484 || TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
)) > 1))
13485 return enclosing_instantiation_of (t
);
13487 /* Calculate the complete set of arguments used to
13489 argvec
= tsubst_template_args (DECL_TI_ARGS
13490 (DECL_TEMPLATE_RESULT
13491 (DECL_TI_TEMPLATE (t
))),
13492 args
, complain
, in_decl
);
13493 if (argvec
== error_mark_node
)
13494 return error_mark_node
;
13496 /* Check to see if we already have this specialization. */
13497 if (!lambda_fntype
)
13499 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
13500 if (tree spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
))
13504 /* We can see more levels of arguments than parameters if
13505 there was a specialization of a member template, like
13508 template <class T> struct S { template <class U> void f(); }
13509 template <> template <class U> void S<int>::f(U);
13511 Here, we'll be substituting into the specialization,
13512 because that's where we can find the code we actually
13513 want to generate, but we'll have enough arguments for
13514 the most general template.
13516 We also deal with the peculiar case:
13518 template <class T> struct S {
13519 template <class U> friend void f();
13521 template <class U> void f() {}
13523 template void f<double>();
13525 Here, the ARGS for the instantiation of will be {int,
13526 double}. But, we only need as many ARGS as there are
13527 levels of template parameters in CODE_PATTERN. We are
13528 careful not to get fooled into reducing the ARGS in
13531 template <class T> struct S { template <class U> void f(U); }
13532 template <class T> template <> void S<T>::f(int) {}
13534 which we can spot because the pattern will be a
13535 specialization in this case. */
13536 int args_depth
= TMPL_ARGS_DEPTH (args
);
13538 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
13540 if (args_depth
> parms_depth
&& !DECL_TEMPLATE_SPECIALIZATION (t
))
13541 args
= get_innermost_template_args (args
, parms_depth
);
13545 /* This special case arises when we have something like this:
13547 template <class T> struct S {
13548 friend void f<int>(int, double);
13551 Here, the DECL_TI_TEMPLATE for the friend declaration
13552 will be an IDENTIFIER_NODE. We are being called from
13553 tsubst_friend_function, and we want only to create a
13554 new decl (R) with appropriate types so that we can call
13555 determine_specialization. */
13556 gen_tmpl
= NULL_TREE
;
13557 argvec
= NULL_TREE
;
13560 tree closure
= (lambda_fntype
? TYPE_METHOD_BASETYPE (lambda_fntype
)
13562 tree ctx
= closure
? closure
: DECL_CONTEXT (t
);
13563 bool member
= ctx
&& TYPE_P (ctx
);
13565 if (member
&& !closure
)
13566 ctx
= tsubst_aggr_type (ctx
, args
,
13567 complain
, t
, /*entering_scope=*/1);
13569 tree type
= (lambda_fntype
? lambda_fntype
13570 : tsubst (TREE_TYPE (t
), args
,
13571 complain
| tf_fndecl_type
, in_decl
));
13572 if (type
== error_mark_node
)
13573 return error_mark_node
;
13575 /* If we hit excessive deduction depth, the type is bogus even if
13576 it isn't error_mark_node, so don't build a decl. */
13577 if (excessive_deduction_depth
)
13578 return error_mark_node
;
13580 /* We do NOT check for matching decls pushed separately at this
13581 point, as they may not represent instantiations of this
13582 template, and in any case are considered separate under the
13584 tree r
= copy_decl (t
);
13585 DECL_USE_TEMPLATE (r
) = 0;
13586 TREE_TYPE (r
) = type
;
13587 /* Clear out the mangled name and RTL for the instantiation. */
13588 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
13589 SET_DECL_RTL (r
, NULL
);
13590 /* Leave DECL_INITIAL set on deleted instantiations. */
13591 if (!DECL_DELETED_FN (r
))
13592 DECL_INITIAL (r
) = NULL_TREE
;
13593 DECL_CONTEXT (r
) = ctx
;
13595 /* Handle explicit(dependent-expr). */
13596 if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t
))
13598 tree spec
= lookup_explicit_specifier (t
);
13599 spec
= tsubst_copy_and_build (spec
, args
, complain
, in_decl
,
13600 /*function_p=*/false,
13602 spec
= build_explicit_specifier (spec
, complain
);
13603 DECL_NONCONVERTING_P (r
) = (spec
== boolean_true_node
);
13606 /* OpenMP UDRs have the only argument a reference to the declared
13607 type. We want to diagnose if the declared type is a reference,
13608 which is invalid, but as references to references are usually
13609 quietly merged, diagnose it here. */
13610 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
13613 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
13614 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
13615 if (TYPE_REF_P (argtype
))
13616 error_at (DECL_SOURCE_LOCATION (t
),
13617 "reference type %qT in "
13618 "%<#pragma omp declare reduction%>", argtype
);
13619 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
13620 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
13624 if (member
&& DECL_CONV_FN_P (r
))
13625 /* Type-conversion operator. Reconstruct the name, in
13626 case it's the name of one of the template's parameters. */
13627 DECL_NAME (r
) = make_conv_op_name (TREE_TYPE (type
));
13629 tree parms
= DECL_ARGUMENTS (t
);
13631 parms
= DECL_CHAIN (parms
);
13632 parms
= tsubst (parms
, args
, complain
, t
);
13633 for (tree parm
= parms
; parm
; parm
= DECL_CHAIN (parm
))
13634 DECL_CONTEXT (parm
) = r
;
13637 tree tparm
= build_this_parm (r
, closure
, type_memfn_quals (type
));
13638 DECL_CHAIN (tparm
) = parms
;
13641 DECL_ARGUMENTS (r
) = parms
;
13642 DECL_RESULT (r
) = NULL_TREE
;
13644 TREE_STATIC (r
) = 0;
13645 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
13646 DECL_EXTERNAL (r
) = 1;
13647 /* If this is an instantiation of a function with internal
13648 linkage, we already know what object file linkage will be
13649 assigned to the instantiation. */
13650 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
13651 DECL_DEFER_OUTPUT (r
) = 0;
13652 DECL_CHAIN (r
) = NULL_TREE
;
13653 DECL_PENDING_INLINE_INFO (r
) = 0;
13654 DECL_PENDING_INLINE_P (r
) = 0;
13655 DECL_SAVED_TREE (r
) = NULL_TREE
;
13656 DECL_STRUCT_FUNCTION (r
) = NULL
;
13658 /* We'll re-clone as appropriate in instantiate_template. */
13659 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
13661 /* If we aren't complaining now, return on error before we register
13662 the specialization so that we'll complain eventually. */
13663 if ((complain
& tf_error
) == 0
13664 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
13665 && !grok_op_properties (r
, /*complain=*/false))
13666 return error_mark_node
;
13668 /* Associate the constraints directly with the instantiation. We
13669 don't substitute through the constraints; that's only done when
13670 they are checked. */
13671 if (tree ci
= get_constraints (t
))
13672 set_constraints (r
, ci
);
13674 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
13675 SET_DECL_FRIEND_CONTEXT (r
,
13676 tsubst (DECL_FRIEND_CONTEXT (t
),
13677 args
, complain
, in_decl
));
13679 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
13680 this in the special friend case mentioned above where
13681 GEN_TMPL is NULL. */
13682 if (gen_tmpl
&& !closure
)
13684 DECL_TEMPLATE_INFO (r
)
13685 = build_template_info (gen_tmpl
, argvec
);
13686 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13689 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
13691 /* We instantiated this while substituting into
13692 the type earlier (template/friend54.C). */
13695 /* We're not supposed to instantiate default arguments
13696 until they are called, for a template. But, for a
13699 template <class T> void f ()
13700 { extern void g(int i = T()); }
13702 we should do the substitution when the template is
13703 instantiated. We handle the member function case in
13704 instantiate_class_template since the default arguments
13705 might refer to other members of the class. */
13707 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
13708 && !uses_template_parms (argvec
))
13709 tsubst_default_arguments (r
, complain
);
13712 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13714 /* Copy the list of befriending classes. */
13715 for (tree
*friends
= &DECL_BEFRIENDING_CLASSES (r
);
13717 friends
= &TREE_CHAIN (*friends
))
13719 *friends
= copy_node (*friends
);
13720 TREE_VALUE (*friends
)
13721 = tsubst (TREE_VALUE (*friends
), args
, complain
, in_decl
);
13724 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
13726 maybe_retrofit_in_chrg (r
);
13727 if (DECL_CONSTRUCTOR_P (r
) && !grok_ctor_properties (ctx
, r
))
13728 return error_mark_node
;
13729 /* If this is an instantiation of a member template, clone it.
13730 If it isn't, that'll be handled by
13731 clone_constructors_and_destructors. */
13732 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
13733 clone_function_decl (r
, /*update_methods=*/false);
13735 else if ((complain
& tf_error
) != 0
13736 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
13737 && !grok_op_properties (r
, /*complain=*/true))
13738 return error_mark_node
;
13740 /* Possibly limit visibility based on template args. */
13741 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
13742 if (DECL_VISIBILITY_SPECIFIED (t
))
13744 DECL_VISIBILITY_SPECIFIED (r
) = 0;
13745 DECL_ATTRIBUTES (r
)
13746 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
13748 determine_visibility (r
);
13749 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
13750 && !processing_template_decl
)
13751 defaulted_late_check (r
);
13753 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
13754 args
, complain
, in_decl
);
13756 if (tree attr
= lookup_attribute ("omp declare variant base",
13757 DECL_ATTRIBUTES (r
)))
13758 omp_declare_variant_finalize (r
, attr
);
13763 /* Subroutine of tsubst_decl for the case when T is a TEMPLATE_DECL. */
13766 tsubst_template_decl (tree t
, tree args
, tsubst_flags_t complain
,
13767 tree lambda_fntype
)
13769 /* We can get here when processing a member function template,
13770 member class template, or template template parameter. */
13771 tree decl
= DECL_TEMPLATE_RESULT (t
);
13777 hashval_t hash
= 0;
13779 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
13781 /* Template template parameter is treated here. */
13782 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13783 if (new_type
== error_mark_node
)
13784 r
= error_mark_node
;
13785 /* If we get a real template back, return it. This can happen in
13786 the context of most_specialized_partial_spec. */
13787 else if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
13790 /* The new TEMPLATE_DECL was built in
13791 reduce_template_parm_level. */
13792 r
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (new_type
);
13796 if (!lambda_fntype
)
13798 /* We might already have an instance of this template.
13799 The ARGS are for the surrounding class type, so the
13800 full args contain the tsubst'd args for the context,
13801 plus the innermost args from the template decl. */
13802 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
13803 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
13804 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
13805 /* Because this is a template, the arguments will still be
13806 dependent, even after substitution. If
13807 PROCESSING_TEMPLATE_DECL is not set, the dependency
13808 predicates will short-circuit. */
13809 ++processing_template_decl
;
13810 full_args
= tsubst_template_args (tmpl_args
, args
,
13811 complain
, in_decl
);
13812 --processing_template_decl
;
13813 if (full_args
== error_mark_node
)
13814 return error_mark_node
;
13816 /* If this is a default template template argument,
13817 tsubst might not have changed anything. */
13818 if (full_args
== tmpl_args
)
13821 hash
= hash_tmpl_and_args (t
, full_args
);
13822 spec
= retrieve_specialization (t
, full_args
, hash
);
13823 if (spec
!= NULL_TREE
)
13826 /* Type partial instantiations are stored as the type by
13827 lookup_template_class_1, not here as the template. */
13828 spec
= CLASSTYPE_TI_TEMPLATE (spec
);
13833 /* Make a new template decl. It will be similar to the
13834 original, but will record the current template arguments.
13835 We also create a new function declaration, which is just
13836 like the old one, but points to this new template, rather
13837 than the old one. */
13839 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
13840 DECL_CHAIN (r
) = NULL_TREE
;
13842 // Build new template info linking to the original template decl.
13843 if (!lambda_fntype
)
13845 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
13846 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13849 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13851 /* The template parameters for this new template are all the
13852 template parameters for the old template, except the
13853 outermost level of parameters. */
13854 DECL_TEMPLATE_PARMS (r
)
13855 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
13858 if (TREE_CODE (decl
) == TYPE_DECL
13859 && !TYPE_DECL_ALIAS_P (decl
))
13862 ++processing_template_decl
;
13863 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13864 --processing_template_decl
;
13865 if (new_type
== error_mark_node
)
13866 return error_mark_node
;
13868 TREE_TYPE (r
) = new_type
;
13869 /* For a partial specialization, we need to keep pointing to
13870 the primary template. */
13871 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
13872 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
13873 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
13874 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
13875 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
13880 ++processing_template_decl
;
13881 if (TREE_CODE (decl
) == FUNCTION_DECL
)
13882 new_decl
= tsubst_function_decl (decl
, args
, complain
, lambda_fntype
);
13884 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
13885 --processing_template_decl
;
13886 if (new_decl
== error_mark_node
)
13887 return error_mark_node
;
13889 DECL_TEMPLATE_RESULT (r
) = new_decl
;
13890 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
13891 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
13894 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (r
));
13895 DECL_TEMPLATE_INFO (new_decl
) = build_template_info (r
, args
);
13899 DECL_TI_TEMPLATE (new_decl
) = r
;
13900 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
13904 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
13905 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
13907 if (PRIMARY_TEMPLATE_P (t
))
13908 DECL_PRIMARY_TEMPLATE (r
) = r
;
13910 if (TREE_CODE (decl
) != TYPE_DECL
&& !VAR_P (decl
)
13912 /* Record this non-type partial instantiation. */
13913 register_specialization (r
, t
,
13914 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
13920 /* True if FN is the op() for a lambda in an uninstantiated template. */
13923 lambda_fn_in_template_p (tree fn
)
13925 if (!fn
|| !LAMBDA_FUNCTION_P (fn
))
13927 tree closure
= DECL_CONTEXT (fn
);
13928 return CLASSTYPE_TEMPLATE_INFO (closure
) != NULL_TREE
;
13931 /* True if FN is the substitution (via tsubst_lambda_expr) of a function for
13932 which the above is true. */
13935 instantiated_lambda_fn_p (tree fn
)
13937 if (!fn
|| !LAMBDA_FUNCTION_P (fn
))
13939 tree closure
= DECL_CONTEXT (fn
);
13940 tree lam
= CLASSTYPE_LAMBDA_EXPR (closure
);
13941 return LAMBDA_EXPR_INSTANTIATED (lam
);
13944 /* We're instantiating a variable from template function TCTX. Return the
13945 corresponding current enclosing scope. This gets complicated because lambda
13946 functions in templates are regenerated rather than instantiated, but generic
13947 lambda functions are subsequently instantiated. */
13950 enclosing_instantiation_of (tree otctx
)
13953 tree fn
= current_function_decl
;
13954 int lambda_count
= 0;
13956 for (; tctx
&& (lambda_fn_in_template_p (tctx
)
13957 || instantiated_lambda_fn_p (tctx
));
13958 tctx
= decl_function_context (tctx
))
13960 for (; fn
; fn
= decl_function_context (fn
))
13963 int flambda_count
= 0;
13964 for (; fn
&& instantiated_lambda_fn_p (fn
);
13965 fn
= decl_function_context (fn
))
13967 if ((fn
&& DECL_TEMPLATE_INFO (fn
))
13968 ? most_general_template (fn
) != most_general_template (tctx
)
13971 if (flambda_count
!= lambda_count
)
13973 gcc_assert (flambda_count
> lambda_count
);
13974 for (; flambda_count
> lambda_count
; --flambda_count
)
13975 ofn
= decl_function_context (ofn
);
13977 gcc_assert (DECL_NAME (ofn
) == DECL_NAME (otctx
)
13978 || DECL_CONV_FN_P (ofn
));
13981 gcc_unreachable ();
13984 /* Substitute the ARGS into the T, which is a _DECL. Return the
13985 result of the substitution. Issue error and warning messages under
13986 control of COMPLAIN. */
13989 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
13991 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13992 location_t saved_loc
;
13993 tree r
= NULL_TREE
;
13995 hashval_t hash
= 0;
13997 /* Set the filename and linenumber to improve error-reporting. */
13998 saved_loc
= input_location
;
13999 input_location
= DECL_SOURCE_LOCATION (t
);
14001 switch (TREE_CODE (t
))
14003 case TEMPLATE_DECL
:
14004 r
= tsubst_template_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
14007 case FUNCTION_DECL
:
14008 r
= tsubst_function_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
14013 tree type
= NULL_TREE
;
14015 tree expanded_types
= NULL_TREE
;
14016 tree prev_r
= NULL_TREE
;
14017 tree first_r
= NULL_TREE
;
14019 if (DECL_PACK_P (t
))
14021 /* If there is a local specialization that isn't a
14022 parameter pack, it means that we're doing a "simple"
14023 substitution from inside tsubst_pack_expansion. Just
14024 return the local specialization (which will be a single
14026 tree spec
= retrieve_local_specialization (t
);
14028 && TREE_CODE (spec
) == PARM_DECL
14029 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
14032 /* Expand the TYPE_PACK_EXPANSION that provides the types for
14033 the parameters in this function parameter pack. */
14034 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
14035 complain
, in_decl
);
14036 if (TREE_CODE (expanded_types
) == TREE_VEC
)
14038 len
= TREE_VEC_LENGTH (expanded_types
);
14040 /* Zero-length parameter packs are boring. Just substitute
14043 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
14048 /* All we did was update the type. Make a note of that. */
14049 type
= expanded_types
;
14050 expanded_types
= NULL_TREE
;
14054 /* Loop through all of the parameters we'll build. When T is
14055 a function parameter pack, LEN is the number of expanded
14056 types in EXPANDED_TYPES; otherwise, LEN is 1. */
14058 for (i
= 0; i
< len
; ++i
)
14062 if (DECL_TEMPLATE_PARM_P (t
))
14063 SET_DECL_TEMPLATE_PARM_P (r
);
14065 if (expanded_types
)
14066 /* We're on the Ith parameter of the function parameter
14069 /* Get the Ith type. */
14070 type
= TREE_VEC_ELT (expanded_types
, i
);
14072 /* Rename the parameter to include the index. */
14074 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
14077 /* We're dealing with a normal parameter. */
14078 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14080 type
= type_decays_to (type
);
14081 TREE_TYPE (r
) = type
;
14082 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
14084 if (DECL_INITIAL (r
))
14086 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
14087 DECL_INITIAL (r
) = TREE_TYPE (r
);
14089 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
14090 complain
, in_decl
);
14093 DECL_CONTEXT (r
) = NULL_TREE
;
14095 if (!DECL_TEMPLATE_PARM_P (r
))
14096 DECL_ARG_TYPE (r
) = type_passed_as (type
);
14098 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
14099 args
, complain
, in_decl
);
14101 /* Keep track of the first new parameter we
14102 generate. That's what will be returned to the
14107 /* Build a proper chain of parameters when substituting
14108 into a function parameter pack. */
14110 DECL_CHAIN (prev_r
) = r
;
14113 /* If cp_unevaluated_operand is set, we're just looking for a
14114 single dummy parameter, so don't keep going. */
14115 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
14116 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
14117 complain
, DECL_CHAIN (t
));
14119 /* FIRST_R contains the start of the chain we've built. */
14126 tree type
= NULL_TREE
;
14127 tree vec
= NULL_TREE
;
14128 tree expanded_types
= NULL_TREE
;
14131 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
14133 /* This field is a lambda capture pack. Return a TREE_VEC of
14134 the expanded fields to instantiate_class_template_1. */
14135 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
14136 complain
, in_decl
);
14137 if (TREE_CODE (expanded_types
) == TREE_VEC
)
14139 len
= TREE_VEC_LENGTH (expanded_types
);
14140 vec
= make_tree_vec (len
);
14144 /* All we did was update the type. Make a note of that. */
14145 type
= expanded_types
;
14146 expanded_types
= NULL_TREE
;
14150 for (int i
= 0; i
< len
; ++i
)
14153 if (expanded_types
)
14155 type
= TREE_VEC_ELT (expanded_types
, i
);
14157 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
14160 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14162 if (type
== error_mark_node
)
14163 RETURN (error_mark_node
);
14164 TREE_TYPE (r
) = type
;
14165 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
14167 if (DECL_C_BIT_FIELD (r
))
14168 /* For bit-fields, DECL_BIT_FIELD_REPRESENTATIVE gives the
14170 DECL_BIT_FIELD_REPRESENTATIVE (r
)
14171 = tsubst_expr (DECL_BIT_FIELD_REPRESENTATIVE (t
), args
,
14173 /*integral_constant_expression_p=*/true);
14174 if (DECL_INITIAL (t
))
14176 /* Set up DECL_TEMPLATE_INFO so that we can get at the
14177 NSDMI in perform_member_init. Still set DECL_INITIAL
14178 so that we know there is one. */
14179 DECL_INITIAL (r
) = void_node
;
14180 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
14181 retrofit_lang_decl (r
);
14182 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
14184 /* We don't have to set DECL_CONTEXT here; it is set by
14185 finish_member_declaration. */
14186 DECL_CHAIN (r
) = NULL_TREE
;
14188 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
14189 args
, complain
, in_decl
);
14192 TREE_VEC_ELT (vec
, i
) = r
;
14201 /* We reach here only for member using decls. We also need to check
14202 uses_template_parms because DECL_DEPENDENT_P is not set for a
14203 using-declaration that designates a member of the current
14204 instantiation (c++/53549). */
14205 if (DECL_DEPENDENT_P (t
)
14206 || uses_template_parms (USING_DECL_SCOPE (t
)))
14208 tree scope
= USING_DECL_SCOPE (t
);
14209 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
14210 if (PACK_EXPANSION_P (scope
))
14212 tree vec
= tsubst_pack_expansion (scope
, args
, complain
, in_decl
);
14213 int len
= TREE_VEC_LENGTH (vec
);
14214 r
= make_tree_vec (len
);
14215 for (int i
= 0; i
< len
; ++i
)
14217 tree escope
= TREE_VEC_ELT (vec
, i
);
14218 tree elt
= do_class_using_decl (escope
, name
);
14221 r
= error_mark_node
;
14226 TREE_PROTECTED (elt
) = TREE_PROTECTED (t
);
14227 TREE_PRIVATE (elt
) = TREE_PRIVATE (t
);
14229 TREE_VEC_ELT (r
, i
) = elt
;
14234 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
14235 complain
, in_decl
);
14236 r
= do_class_using_decl (inst_scope
, name
);
14238 r
= error_mark_node
;
14241 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
14242 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
14249 DECL_CHAIN (r
) = NULL_TREE
;
14256 tree argvec
= NULL_TREE
;
14257 tree gen_tmpl
= NULL_TREE
;
14259 tree tmpl
= NULL_TREE
;
14261 tree type
= NULL_TREE
;
14264 if (TREE_TYPE (t
) == error_mark_node
)
14265 RETURN (error_mark_node
);
14267 if (TREE_CODE (t
) == TYPE_DECL
14268 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
14270 /* If this is the canonical decl, we don't have to
14271 mess with instantiations, and often we can't (for
14272 typename, template type parms and such). Note that
14273 TYPE_NAME is not correct for the above test if
14274 we've copied the type for a typedef. */
14275 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14276 if (type
== error_mark_node
)
14277 RETURN (error_mark_node
);
14278 r
= TYPE_NAME (type
);
14282 /* Check to see if we already have the specialization we
14285 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
14287 /* T is a static data member or namespace-scope entity.
14288 We have to substitute into namespace-scope variables
14289 (not just variable templates) because of cases like:
14291 template <class T> void f() { extern T t; }
14293 where the entity referenced is not known until
14294 instantiation time. */
14296 ctx
= DECL_CONTEXT (t
);
14297 if (DECL_CLASS_SCOPE_P (t
))
14299 ctx
= tsubst_aggr_type (ctx
, args
,
14301 in_decl
, /*entering_scope=*/1);
14302 /* If CTX is unchanged, then T is in fact the
14303 specialization we want. That situation occurs when
14304 referencing a static data member within in its own
14305 class. We can use pointer equality, rather than
14306 same_type_p, because DECL_CONTEXT is always
14308 if (ctx
== DECL_CONTEXT (t
)
14309 /* ... unless T is a member template; in which
14310 case our caller can be willing to create a
14311 specialization of that template represented
14313 && !(DECL_TI_TEMPLATE (t
)
14314 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
14320 tmpl
= DECL_TI_TEMPLATE (t
);
14321 gen_tmpl
= most_general_template (tmpl
);
14322 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
14323 if (argvec
!= error_mark_node
)
14324 argvec
= (coerce_innermost_template_parms
14325 (DECL_TEMPLATE_PARMS (gen_tmpl
),
14326 argvec
, t
, complain
,
14327 /*all*/true, /*defarg*/true));
14328 if (argvec
== error_mark_node
)
14329 RETURN (error_mark_node
);
14330 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
14331 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
14336 /* A local variable. */
14338 /* Subsequent calls to pushdecl will fill this in. */
14340 /* Unless this is a reference to a static variable from an
14341 enclosing function, in which case we need to fill it in now. */
14342 if (TREE_STATIC (t
))
14344 tree fn
= enclosing_instantiation_of (DECL_CONTEXT (t
));
14345 if (fn
!= current_function_decl
)
14348 spec
= retrieve_local_specialization (t
);
14350 /* If we already have the specialization we need, there is
14351 nothing more to do. */
14358 /* Create a new node for the specialization we need. */
14359 if (type
== NULL_TREE
)
14361 if (is_typedef_decl (t
))
14362 type
= DECL_ORIGINAL_TYPE (t
);
14364 type
= TREE_TYPE (t
);
14366 && VAR_HAD_UNKNOWN_BOUND (t
)
14367 && type
!= error_mark_node
)
14368 type
= strip_array_domain (type
);
14369 tree sub_args
= args
;
14370 if (tree auto_node
= type_uses_auto (type
))
14372 /* Mask off any template args past the variable's context so we
14373 don't replace the auto with an unrelated argument. */
14374 int nouter
= TEMPLATE_TYPE_LEVEL (auto_node
) - 1;
14375 int extra
= TMPL_ARGS_DEPTH (args
) - nouter
;
14377 /* This should never happen with the new lambda instantiation
14378 model, but keep the handling just in case. */
14379 gcc_assert (!CHECKING_P
),
14380 sub_args
= strip_innermost_template_args (args
, extra
);
14382 type
= tsubst (type
, sub_args
, complain
, in_decl
);
14383 /* Substituting the type might have recursively instantiated this
14384 same alias (c++/86171). */
14385 if (gen_tmpl
&& DECL_ALIAS_TEMPLATE_P (gen_tmpl
)
14386 && (spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
)))
14395 DECL_INITIALIZED_P (r
) = 0;
14396 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
14397 if (type
== error_mark_node
)
14398 RETURN (error_mark_node
);
14399 if (TREE_CODE (type
) == FUNCTION_TYPE
)
14401 /* It may seem that this case cannot occur, since:
14406 declares a function, not a variable. However:
14409 template <typename T> void g() { T t; }
14410 template void g<f>();
14412 is an attempt to declare a variable with function
14414 error ("variable %qD has function type",
14415 /* R is not yet sufficiently initialized, so we
14416 just use its name. */
14418 RETURN (error_mark_node
);
14420 type
= complete_type (type
);
14421 /* Wait until cp_finish_decl to set this again, to handle
14422 circular dependency (template/instantiate6.C). */
14423 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
14424 type
= check_var_type (DECL_NAME (r
), type
,
14425 DECL_SOURCE_LOCATION (r
));
14426 if (DECL_HAS_VALUE_EXPR_P (t
))
14428 tree ve
= DECL_VALUE_EXPR (t
);
14429 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
14430 /*constant_expression_p=*/false);
14431 if (REFERENCE_REF_P (ve
))
14433 gcc_assert (TYPE_REF_P (type
));
14434 ve
= TREE_OPERAND (ve
, 0);
14436 SET_DECL_VALUE_EXPR (r
, ve
);
14438 if (CP_DECL_THREAD_LOCAL_P (r
)
14439 && !processing_template_decl
)
14440 set_decl_tls_model (r
, decl_default_tls_model (r
));
14442 else if (DECL_SELF_REFERENCE_P (t
))
14443 SET_DECL_SELF_REFERENCE_P (r
);
14444 TREE_TYPE (r
) = type
;
14445 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
14446 DECL_CONTEXT (r
) = ctx
;
14447 /* Clear out the mangled name and RTL for the instantiation. */
14448 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
14449 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
14450 SET_DECL_RTL (r
, NULL
);
14451 /* The initializer must not be expanded until it is required;
14452 see [temp.inst]. */
14453 DECL_INITIAL (r
) = NULL_TREE
;
14454 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
14457 if (DECL_LANG_SPECIFIC (r
))
14458 SET_DECL_DEPENDENT_INIT_P (r
, false);
14460 SET_DECL_MODE (r
, VOIDmode
);
14462 /* Possibly limit visibility based on template args. */
14463 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
14464 if (DECL_VISIBILITY_SPECIFIED (t
))
14466 DECL_VISIBILITY_SPECIFIED (r
) = 0;
14467 DECL_ATTRIBUTES (r
)
14468 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
14470 determine_visibility (r
);
14475 /* A static data member declaration is always marked
14476 external when it is declared in-class, even if an
14477 initializer is present. We mimic the non-template
14478 processing here. */
14479 DECL_EXTERNAL (r
) = 1;
14480 if (DECL_NAMESPACE_SCOPE_P (t
))
14481 DECL_NOT_REALLY_EXTERN (r
) = 1;
14483 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
14484 SET_DECL_IMPLICIT_INSTANTIATION (r
);
14485 /* Remember whether we require constant initialization of
14486 a non-constant template variable. */
14487 TINFO_VAR_DECLARED_CONSTINIT (DECL_TEMPLATE_INFO (r
))
14488 = TINFO_VAR_DECLARED_CONSTINIT (DECL_TEMPLATE_INFO (t
));
14489 if (!error_operand_p (r
) || (complain
& tf_error
))
14490 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
14494 if (DECL_LANG_SPECIFIC (r
))
14495 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
14496 if (!cp_unevaluated_operand
)
14497 register_local_specialization (r
, t
);
14500 DECL_CHAIN (r
) = NULL_TREE
;
14502 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
14504 args
, complain
, in_decl
);
14506 /* Preserve a typedef that names a type. */
14507 if (is_typedef_decl (r
) && type
!= error_mark_node
)
14509 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
14510 set_underlying_type (r
);
14511 if (TYPE_DECL_ALIAS_P (r
))
14512 /* An alias template specialization can be dependent
14513 even if its underlying type is not. */
14514 TYPE_DEPENDENT_P_VALID (TREE_TYPE (r
)) = false;
14517 layout_decl (r
, 0);
14522 gcc_unreachable ();
14527 /* Restore the file and line information. */
14528 input_location
= saved_loc
;
14533 /* Substitute into the complete parameter type list PARMS. */
14536 tsubst_function_parms (tree parms
,
14538 tsubst_flags_t complain
,
14541 return tsubst_arg_types (parms
, args
, NULL_TREE
, complain
, in_decl
);
14544 /* Substitute into the ARG_TYPES of a function type.
14545 If END is a TREE_CHAIN, leave it and any following types
14549 tsubst_arg_types (tree arg_types
,
14552 tsubst_flags_t complain
,
14555 tree remaining_arg_types
;
14556 tree type
= NULL_TREE
;
14558 tree expanded_args
= NULL_TREE
;
14561 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
14564 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
14565 args
, end
, complain
, in_decl
);
14566 if (remaining_arg_types
== error_mark_node
)
14567 return error_mark_node
;
14569 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
14571 /* For a pack expansion, perform substitution on the
14572 entire expression. Later on, we'll handle the arguments
14574 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
14575 args
, complain
, in_decl
);
14577 if (TREE_CODE (expanded_args
) == TREE_VEC
)
14578 /* So that we'll spin through the parameters, one by one. */
14579 i
= TREE_VEC_LENGTH (expanded_args
);
14582 /* We only partially substituted into the parameter
14583 pack. Our type is TYPE_PACK_EXPANSION. */
14584 type
= expanded_args
;
14585 expanded_args
= NULL_TREE
;
14593 type
= TREE_VEC_ELT (expanded_args
, i
);
14595 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
14597 if (type
== error_mark_node
)
14598 return error_mark_node
;
14599 if (VOID_TYPE_P (type
))
14601 if (complain
& tf_error
)
14603 error ("invalid parameter type %qT", type
);
14605 error ("in declaration %q+D", in_decl
);
14607 return error_mark_node
;
14610 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
14611 return error_mark_node
;
14613 /* Do array-to-pointer, function-to-pointer conversion, and ignore
14614 top-level qualifiers as required. */
14615 type
= cv_unqualified (type_decays_to (type
));
14617 /* We do not substitute into default arguments here. The standard
14618 mandates that they be instantiated only when needed, which is
14619 done in build_over_call. */
14620 default_arg
= TREE_PURPOSE (arg_types
);
14622 /* Except that we do substitute default arguments under tsubst_lambda_expr,
14623 since the new op() won't have any associated template arguments for us
14624 to refer to later. */
14625 if (lambda_fn_in_template_p (in_decl
))
14626 default_arg
= tsubst_copy_and_build (default_arg
, args
, complain
, in_decl
,
14627 false/*fn*/, false/*constexpr*/);
14629 if (default_arg
&& TREE_CODE (default_arg
) == DEFERRED_PARSE
)
14631 /* We've instantiated a template before its default arguments
14632 have been parsed. This can happen for a nested template
14633 class, and is not an error unless we require the default
14634 argument in a call of this function. */
14635 remaining_arg_types
=
14636 tree_cons (default_arg
, type
, remaining_arg_types
);
14637 vec_safe_push (DEFPARSE_INSTANTIATIONS (default_arg
),
14638 remaining_arg_types
);
14641 remaining_arg_types
=
14642 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
14645 return remaining_arg_types
;
14648 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
14649 *not* handle the exception-specification for FNTYPE, because the
14650 initial substitution of explicitly provided template parameters
14651 during argument deduction forbids substitution into the
14652 exception-specification:
14656 All references in the function type of the function template to the
14657 corresponding template parameters are replaced by the specified tem-
14658 plate argument values. If a substitution in a template parameter or
14659 in the function type of the function template results in an invalid
14660 type, type deduction fails. [Note: The equivalent substitution in
14661 exception specifications is done only when the function is instanti-
14662 ated, at which point a program is ill-formed if the substitution
14663 results in an invalid type.] */
14666 tsubst_function_type (tree t
,
14668 tsubst_flags_t complain
,
14672 tree arg_types
= NULL_TREE
;
14675 /* The TYPE_CONTEXT is not used for function/method types. */
14676 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
14678 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
14680 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
14682 if (late_return_type_p
)
14684 /* Substitute the argument types. */
14685 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
14686 complain
, in_decl
);
14687 if (arg_types
== error_mark_node
)
14688 return error_mark_node
;
14690 tree save_ccp
= current_class_ptr
;
14691 tree save_ccr
= current_class_ref
;
14692 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
14693 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
14694 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
14697 /* DR 1207: 'this' is in scope in the trailing return type. */
14698 inject_this_parameter (this_type
, cp_type_quals (this_type
));
14701 /* Substitute the return type. */
14702 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14706 current_class_ptr
= save_ccp
;
14707 current_class_ref
= save_ccr
;
14711 /* Substitute the return type. */
14712 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14714 if (return_type
== error_mark_node
)
14715 return error_mark_node
;
14716 /* DR 486 clarifies that creation of a function type with an
14717 invalid return type is a deduction failure. */
14718 if (TREE_CODE (return_type
) == ARRAY_TYPE
14719 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
14721 if (complain
& tf_error
)
14723 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
14724 error ("function returning an array");
14726 error ("function returning a function");
14728 return error_mark_node
;
14731 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
14732 return error_mark_node
;
14734 if (!late_return_type_p
)
14736 /* Substitute the argument types. */
14737 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
14738 complain
, in_decl
);
14739 if (arg_types
== error_mark_node
)
14740 return error_mark_node
;
14743 /* Construct a new type node and return it. */
14744 if (TREE_CODE (t
) == FUNCTION_TYPE
)
14746 fntype
= build_function_type (return_type
, arg_types
);
14747 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (t
));
14751 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
14752 /* Don't pick up extra function qualifiers from the basetype. */
14753 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
14754 if (! MAYBE_CLASS_TYPE_P (r
))
14758 Type deduction may fail for any of the following
14761 -- Attempting to create "pointer to member of T" when T
14762 is not a class type. */
14763 if (complain
& tf_error
)
14764 error ("creating pointer to member function of non-class type %qT",
14766 return error_mark_node
;
14769 fntype
= build_method_type_directly (r
, return_type
,
14770 TREE_CHAIN (arg_types
));
14772 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
14774 /* See comment above. */
14775 tree raises
= NULL_TREE
;
14776 cp_ref_qualifier rqual
= type_memfn_rqual (t
);
14777 fntype
= build_cp_fntype_variant (fntype
, rqual
, raises
, late_return_type_p
);
14782 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
14783 ARGS into that specification, and return the substituted
14784 specification. If there is no specification, return NULL_TREE. */
14787 tsubst_exception_specification (tree fntype
,
14789 tsubst_flags_t complain
,
14796 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
14797 new_specs
= NULL_TREE
;
14798 if (specs
&& TREE_PURPOSE (specs
))
14800 /* A noexcept-specifier. */
14801 tree expr
= TREE_PURPOSE (specs
);
14802 if (TREE_CODE (expr
) == INTEGER_CST
)
14806 /* Defer instantiation of noexcept-specifiers to avoid
14807 excessive instantiations (c++/49107). */
14808 new_specs
= make_node (DEFERRED_NOEXCEPT
);
14809 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
14811 /* We already partially instantiated this member template,
14812 so combine the new args with the old. */
14813 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
14814 = DEFERRED_NOEXCEPT_PATTERN (expr
);
14815 DEFERRED_NOEXCEPT_ARGS (new_specs
)
14816 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
14820 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
14821 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
14826 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
14828 args
= add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
),
14830 expr
= DEFERRED_NOEXCEPT_PATTERN (expr
);
14832 new_specs
= tsubst_copy_and_build
14833 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
14834 /*integral_constant_expression_p=*/true);
14836 new_specs
= build_noexcept_spec (new_specs
, complain
);
14840 if (! TREE_VALUE (specs
))
14847 tree expanded_specs
= NULL_TREE
;
14849 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
14851 /* Expand the pack expansion type. */
14852 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
14856 if (expanded_specs
== error_mark_node
)
14857 return error_mark_node
;
14858 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
14859 len
= TREE_VEC_LENGTH (expanded_specs
);
14862 /* We're substituting into a member template, so
14863 we got a TYPE_PACK_EXPANSION back. Add that
14864 expansion and move on. */
14865 gcc_assert (TREE_CODE (expanded_specs
)
14866 == TYPE_PACK_EXPANSION
);
14867 new_specs
= add_exception_specifier (new_specs
,
14870 specs
= TREE_CHAIN (specs
);
14875 for (i
= 0; i
< len
; ++i
)
14877 if (expanded_specs
)
14878 spec
= TREE_VEC_ELT (expanded_specs
, i
);
14880 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
14881 if (spec
== error_mark_node
)
14883 new_specs
= add_exception_specifier (new_specs
, spec
,
14887 specs
= TREE_CHAIN (specs
);
14893 /* Take the tree structure T and replace template parameters used
14894 therein with the argument vector ARGS. IN_DECL is an associated
14895 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
14896 Issue error and warning messages under control of COMPLAIN. Note
14897 that we must be relatively non-tolerant of extensions here, in
14898 order to preserve conformance; if we allow substitutions that
14899 should not be allowed, we may allow argument deductions that should
14900 not succeed, and therefore report ambiguous overload situations
14901 where there are none. In theory, we could allow the substitution,
14902 but indicate that it should have failed, and allow our caller to
14903 make sure that the right thing happens, but we don't try to do this
14906 This function is used for dealing with types, decls and the like;
14907 for expressions, use tsubst_expr or tsubst_copy. */
14910 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14912 enum tree_code code
;
14913 tree type
, r
= NULL_TREE
;
14915 if (t
== NULL_TREE
|| t
== error_mark_node
14916 || t
== integer_type_node
14917 || t
== void_type_node
14918 || t
== char_type_node
14919 || t
== unknown_type_node
14920 || TREE_CODE (t
) == NAMESPACE_DECL
14921 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
14925 return tsubst_decl (t
, args
, complain
);
14927 if (args
== NULL_TREE
)
14930 code
= TREE_CODE (t
);
14932 if (code
== IDENTIFIER_NODE
)
14933 type
= IDENTIFIER_TYPE_VALUE (t
);
14935 type
= TREE_TYPE (t
);
14937 gcc_assert (type
!= unknown_type_node
);
14939 /* Reuse typedefs. We need to do this to handle dependent attributes,
14940 such as attribute aligned. */
14942 && typedef_variant_p (t
))
14944 tree decl
= TYPE_NAME (t
);
14946 if (alias_template_specialization_p (t
, nt_opaque
))
14948 /* DECL represents an alias template and we want to
14950 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
14951 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
14952 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
14954 else if (DECL_CLASS_SCOPE_P (decl
)
14955 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
14956 && uses_template_parms (DECL_CONTEXT (decl
)))
14958 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
14959 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
14960 r
= retrieve_specialization (tmpl
, gen_args
, 0);
14962 else if (DECL_FUNCTION_SCOPE_P (decl
)
14963 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
14964 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
14965 r
= retrieve_local_specialization (decl
);
14967 /* The typedef is from a non-template context. */
14973 r
= cp_build_qualified_type_real
14974 (r
, cp_type_quals (t
) | cp_type_quals (r
),
14975 complain
| tf_ignore_bad_quals
);
14980 /* We don't have an instantiation yet, so drop the typedef. */
14981 int quals
= cp_type_quals (t
);
14982 t
= DECL_ORIGINAL_TYPE (decl
);
14983 t
= cp_build_qualified_type_real (t
, quals
,
14984 complain
| tf_ignore_bad_quals
);
14988 bool fndecl_type
= (complain
& tf_fndecl_type
);
14989 complain
&= ~tf_fndecl_type
;
14992 && code
!= TYPENAME_TYPE
14993 && code
!= TEMPLATE_TYPE_PARM
14994 && code
!= TEMPLATE_PARM_INDEX
14995 && code
!= IDENTIFIER_NODE
14996 && code
!= FUNCTION_TYPE
14997 && code
!= METHOD_TYPE
)
14998 type
= tsubst (type
, args
, complain
, in_decl
);
14999 if (type
== error_mark_node
)
15000 return error_mark_node
;
15006 case ENUMERAL_TYPE
:
15007 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
15008 /*entering_scope=*/0);
15011 case IDENTIFIER_NODE
:
15022 if (t
== integer_type_node
)
15025 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
15026 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
15030 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
15032 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
15033 /*integral_constant_expression_p=*/false);
15035 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
15037 if (TREE_CODE (max
) == NOP_EXPR
15038 && TREE_SIDE_EFFECTS (omax
)
15039 && !TREE_TYPE (max
))
15040 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
15042 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
15043 with TREE_SIDE_EFFECTS that indicates this is not an integral
15044 constant expression. */
15045 if (processing_template_decl
15046 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
15048 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
15049 TREE_SIDE_EFFECTS (max
) = 1;
15052 return compute_array_index_type (NULL_TREE
, max
, complain
);
15055 case TEMPLATE_TYPE_PARM
:
15056 case TEMPLATE_TEMPLATE_PARM
:
15057 case BOUND_TEMPLATE_TEMPLATE_PARM
:
15058 case TEMPLATE_PARM_INDEX
:
15063 tree arg
= NULL_TREE
;
15065 /* Early in template argument deduction substitution, we don't
15066 want to reduce the level of 'auto', or it will be confused
15067 with a normal template parm in subsequent deduction. */
15068 if (is_auto (t
) && (complain
& tf_partial
))
15073 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
15074 template_parm_level_and_index (t
, &level
, &idx
);
15076 levels
= TMPL_ARGS_DEPTH (args
);
15077 if (level
<= levels
15078 && TREE_VEC_LENGTH (TMPL_ARGS_LEVEL (args
, level
)) > 0)
15080 arg
= TMPL_ARG (args
, level
, idx
);
15082 /* See through ARGUMENT_PACK_SELECT arguments. */
15083 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
15084 arg
= argument_pack_select_arg (arg
);
15087 if (arg
== error_mark_node
)
15088 return error_mark_node
;
15089 else if (arg
!= NULL_TREE
)
15091 if (ARGUMENT_PACK_P (arg
))
15092 /* If ARG is an argument pack, we don't actually want to
15093 perform a substitution here, because substitutions
15094 for argument packs are only done
15095 element-by-element. We can get to this point when
15096 substituting the type of a non-type template
15097 parameter pack, when that type actually contains
15098 template parameter packs from an outer template, e.g.,
15100 template<typename... Types> struct A {
15101 template<Types... Values> struct B { };
15105 if (code
== TEMPLATE_TYPE_PARM
)
15109 /* When building concept checks for the purpose of
15110 deducing placeholders, we can end up with wildcards
15111 where types are expected. Adjust this to the deduced
15113 if (TREE_CODE (arg
) == WILDCARD_DECL
)
15114 arg
= TREE_TYPE (TREE_TYPE (arg
));
15116 gcc_assert (TYPE_P (arg
));
15118 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
15120 return cp_build_qualified_type_real
15121 (arg
, quals
, complain
| tf_ignore_bad_quals
);
15123 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
15125 /* We are processing a type constructed from a
15126 template template parameter. */
15127 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
15128 args
, complain
, in_decl
);
15129 if (argvec
== error_mark_node
)
15130 return error_mark_node
;
15132 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
15133 || TREE_CODE (arg
) == TEMPLATE_DECL
15134 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
15136 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
15137 /* Consider this code:
15139 template <template <class> class Template>
15141 template <class Arg> using Bind = Template<Arg>;
15144 template <template <class> class Template, class Arg>
15145 using Instantiate = Template<Arg>; //#0
15147 template <template <class> class Template,
15150 Instantiate<Internal<Template>::template Bind,
15153 When #1 is parsed, the
15154 BOUND_TEMPLATE_TEMPLATE_PARM representing the
15155 parameter `Template' in #0 matches the
15156 UNBOUND_CLASS_TEMPLATE representing the argument
15157 `Internal<Template>::template Bind'; We then want
15158 to assemble the type `Bind<Argument>' that can't
15159 be fully created right now, because
15160 `Internal<Template>' not being complete, the Bind
15161 template cannot be looked up in that context. So
15162 we need to "store" `Bind<Argument>' for later
15163 when the context of Bind becomes complete. Let's
15164 store that in a TYPENAME_TYPE. */
15165 return make_typename_type (TYPE_CONTEXT (arg
),
15166 build_nt (TEMPLATE_ID_EXPR
,
15167 TYPE_IDENTIFIER (arg
),
15172 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
15173 are resolving nested-types in the signature of a
15174 member function templates. Otherwise ARG is a
15175 TEMPLATE_DECL and is the real template to be
15177 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
15178 arg
= TYPE_NAME (arg
);
15180 r
= lookup_template_class (arg
,
15182 DECL_CONTEXT (arg
),
15183 /*entering_scope=*/0,
15185 return cp_build_qualified_type_real
15186 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
15188 else if (code
== TEMPLATE_TEMPLATE_PARM
)
15191 /* TEMPLATE_PARM_INDEX. */
15192 return convert_from_reference (unshare_expr (arg
));
15196 /* This can happen during the attempted tsubst'ing in
15197 unify. This means that we don't yet have any information
15198 about the template parameter in question. */
15201 /* If we get here, we must have been looking at a parm for a
15202 more deeply nested template. Make a new version of this
15203 template parameter, but with a lower level. */
15206 case TEMPLATE_TYPE_PARM
:
15207 case TEMPLATE_TEMPLATE_PARM
:
15208 case BOUND_TEMPLATE_TEMPLATE_PARM
:
15209 if (cp_type_quals (t
))
15211 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
15212 r
= cp_build_qualified_type_real
15213 (r
, cp_type_quals (t
),
15214 complain
| (code
== TEMPLATE_TYPE_PARM
15215 ? tf_ignore_bad_quals
: 0));
15217 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
15218 && PLACEHOLDER_TYPE_CONSTRAINTS (t
)
15219 && (r
= (TEMPLATE_PARM_DESCENDANTS
15220 (TEMPLATE_TYPE_PARM_INDEX (t
))))
15221 && (r
= TREE_TYPE (r
))
15222 && !PLACEHOLDER_TYPE_CONSTRAINTS (r
))
15223 /* Break infinite recursion when substituting the constraints
15224 of a constrained placeholder. */;
15225 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
15226 && !PLACEHOLDER_TYPE_CONSTRAINTS (t
)
15227 && !CLASS_PLACEHOLDER_TEMPLATE (t
)
15228 && (arg
= TEMPLATE_TYPE_PARM_INDEX (t
),
15229 r
= TEMPLATE_PARM_DESCENDANTS (arg
))
15230 && (TEMPLATE_PARM_LEVEL (r
)
15231 == TEMPLATE_PARM_LEVEL (arg
) - levels
))
15232 /* Cache the simple case of lowering a type parameter. */
15237 TEMPLATE_TYPE_PARM_INDEX (r
)
15238 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
15239 r
, levels
, args
, complain
);
15240 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
15241 TYPE_MAIN_VARIANT (r
) = r
;
15242 TYPE_POINTER_TO (r
) = NULL_TREE
;
15243 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
15245 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
15247 /* Propagate constraints on placeholders since they are
15248 only instantiated during satisfaction. */
15249 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
15250 PLACEHOLDER_TYPE_CONSTRAINTS (r
) = constr
;
15251 else if (tree pl
= CLASS_PLACEHOLDER_TEMPLATE (t
))
15253 pl
= tsubst_copy (pl
, args
, complain
, in_decl
);
15254 CLASS_PLACEHOLDER_TEMPLATE (r
) = pl
;
15258 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
15259 /* We have reduced the level of the template
15260 template parameter, but not the levels of its
15261 template parameters, so canonical_type_parameter
15262 will not be able to find the canonical template
15263 template parameter for this level. Thus, we
15264 require structural equality checking to compare
15265 TEMPLATE_TEMPLATE_PARMs. */
15266 SET_TYPE_STRUCTURAL_EQUALITY (r
);
15267 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
15268 SET_TYPE_STRUCTURAL_EQUALITY (r
);
15270 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
15272 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
15274 tree tinfo
= TYPE_TEMPLATE_INFO (t
);
15275 /* We might need to substitute into the types of non-type
15276 template parameters. */
15277 tree tmpl
= tsubst (TI_TEMPLATE (tinfo
), args
,
15278 complain
, in_decl
);
15279 if (tmpl
== error_mark_node
)
15280 return error_mark_node
;
15281 tree argvec
= tsubst (TI_ARGS (tinfo
), args
,
15282 complain
, in_decl
);
15283 if (argvec
== error_mark_node
)
15284 return error_mark_node
;
15286 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
15287 = build_template_info (tmpl
, argvec
);
15292 case TEMPLATE_PARM_INDEX
:
15293 /* OK, now substitute the type of the non-type parameter. We
15294 couldn't do it earlier because it might be an auto parameter,
15295 and we wouldn't need to if we had an argument. */
15296 type
= tsubst (type
, args
, complain
, in_decl
);
15297 if (type
== error_mark_node
)
15298 return error_mark_node
;
15299 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
15303 gcc_unreachable ();
15311 tree purpose
, value
, chain
;
15313 if (t
== void_list_node
)
15316 purpose
= TREE_PURPOSE (t
);
15319 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
15320 if (purpose
== error_mark_node
)
15321 return error_mark_node
;
15323 value
= TREE_VALUE (t
);
15326 value
= tsubst (value
, args
, complain
, in_decl
);
15327 if (value
== error_mark_node
)
15328 return error_mark_node
;
15330 chain
= TREE_CHAIN (t
);
15331 if (chain
&& chain
!= void_type_node
)
15333 chain
= tsubst (chain
, args
, complain
, in_decl
);
15334 if (chain
== error_mark_node
)
15335 return error_mark_node
;
15337 if (purpose
== TREE_PURPOSE (t
)
15338 && value
== TREE_VALUE (t
)
15339 && chain
== TREE_CHAIN (t
))
15341 return hash_tree_cons (purpose
, value
, chain
);
15345 /* We should never be tsubsting a binfo. */
15346 gcc_unreachable ();
15349 /* A vector of template arguments. */
15350 gcc_assert (!type
);
15351 return tsubst_template_args (t
, args
, complain
, in_decl
);
15354 case REFERENCE_TYPE
:
15356 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
15361 Type deduction may fail for any of the following
15364 -- Attempting to create a pointer to reference type.
15365 -- Attempting to create a reference to a reference type or
15366 a reference to void.
15368 Core issue 106 says that creating a reference to a reference
15369 during instantiation is no longer a cause for failure. We
15370 only enforce this check in strict C++98 mode. */
15371 if ((TYPE_REF_P (type
)
15372 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
15373 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
15375 static location_t last_loc
;
15377 /* We keep track of the last time we issued this error
15378 message to avoid spewing a ton of messages during a
15379 single bad template instantiation. */
15380 if (complain
& tf_error
15381 && last_loc
!= input_location
)
15383 if (VOID_TYPE_P (type
))
15384 error ("forming reference to void");
15385 else if (code
== POINTER_TYPE
)
15386 error ("forming pointer to reference type %qT", type
);
15388 error ("forming reference to reference type %qT", type
);
15389 last_loc
= input_location
;
15392 return error_mark_node
;
15394 else if (TREE_CODE (type
) == FUNCTION_TYPE
15395 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
15396 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
15398 if (complain
& tf_error
)
15400 if (code
== POINTER_TYPE
)
15401 error ("forming pointer to qualified function type %qT",
15404 error ("forming reference to qualified function type %qT",
15407 return error_mark_node
;
15409 else if (code
== POINTER_TYPE
)
15411 r
= build_pointer_type (type
);
15412 if (TREE_CODE (type
) == METHOD_TYPE
)
15413 r
= build_ptrmemfunc_type (r
);
15415 else if (TYPE_REF_P (type
))
15416 /* In C++0x, during template argument substitution, when there is an
15417 attempt to create a reference to a reference type, reference
15418 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
15420 "If a template-argument for a template-parameter T names a type
15421 that is a reference to a type A, an attempt to create the type
15422 'lvalue reference to cv T' creates the type 'lvalue reference to
15423 A,' while an attempt to create the type type rvalue reference to
15424 cv T' creates the type T"
15426 r
= cp_build_reference_type
15428 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
15430 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
15431 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
15433 if (r
!= error_mark_node
)
15434 /* Will this ever be needed for TYPE_..._TO values? */
15441 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
15442 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
15446 Type deduction may fail for any of the following
15449 -- Attempting to create "pointer to member of T" when T
15450 is not a class type. */
15451 if (complain
& tf_error
)
15452 error ("creating pointer to member of non-class type %qT", r
);
15453 return error_mark_node
;
15455 if (TYPE_REF_P (type
))
15457 if (complain
& tf_error
)
15458 error ("creating pointer to member reference type %qT", type
);
15459 return error_mark_node
;
15461 if (VOID_TYPE_P (type
))
15463 if (complain
& tf_error
)
15464 error ("creating pointer to member of type void");
15465 return error_mark_node
;
15467 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
15468 if (TREE_CODE (type
) == FUNCTION_TYPE
)
15470 /* The type of the implicit object parameter gets its
15471 cv-qualifiers from the FUNCTION_TYPE. */
15474 = build_memfn_type (type
, r
, type_memfn_quals (type
),
15475 type_memfn_rqual (type
));
15476 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
15477 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
15481 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
15485 case FUNCTION_TYPE
:
15490 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
15491 if (fntype
== error_mark_node
)
15492 return error_mark_node
;
15494 /* Substitute the exception specification. */
15495 specs
= tsubst_exception_specification (t
, args
, complain
, in_decl
,
15496 /*defer_ok*/fndecl_type
);
15497 if (specs
== error_mark_node
)
15498 return error_mark_node
;
15500 fntype
= build_exception_variant (fntype
, specs
);
15505 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
15506 if (domain
== error_mark_node
)
15507 return error_mark_node
;
15509 /* As an optimization, we avoid regenerating the array type if
15510 it will obviously be the same as T. */
15511 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
15514 /* These checks should match the ones in create_array_type_for_decl.
15518 The deduction may fail for any of the following reasons:
15520 -- Attempting to create an array with an element type that
15521 is void, a function type, or a reference type, or [DR337]
15522 an abstract class type. */
15523 if (VOID_TYPE_P (type
)
15524 || TREE_CODE (type
) == FUNCTION_TYPE
15525 || (TREE_CODE (type
) == ARRAY_TYPE
15526 && TYPE_DOMAIN (type
) == NULL_TREE
)
15527 || TYPE_REF_P (type
))
15529 if (complain
& tf_error
)
15530 error ("creating array of %qT", type
);
15531 return error_mark_node
;
15534 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
15535 return error_mark_node
;
15537 r
= build_cplus_array_type (type
, domain
);
15539 if (!valid_array_size_p (input_location
, r
, in_decl
,
15540 (complain
& tf_error
)))
15541 return error_mark_node
;
15543 if (TYPE_USER_ALIGN (t
))
15545 SET_TYPE_ALIGN (r
, TYPE_ALIGN (t
));
15546 TYPE_USER_ALIGN (r
) = 1;
15552 case TYPENAME_TYPE
:
15554 tree ctx
= TYPE_CONTEXT (t
);
15555 if (TREE_CODE (ctx
) == TYPE_PACK_EXPANSION
)
15557 ctx
= tsubst_pack_expansion (ctx
, args
, complain
, in_decl
);
15558 if (ctx
== error_mark_node
15559 || TREE_VEC_LENGTH (ctx
) > 1)
15560 return error_mark_node
;
15561 if (TREE_VEC_LENGTH (ctx
) == 0)
15563 if (complain
& tf_error
)
15564 error ("%qD is instantiated for an empty pack",
15565 TYPENAME_TYPE_FULLNAME (t
));
15566 return error_mark_node
;
15568 ctx
= TREE_VEC_ELT (ctx
, 0);
15571 ctx
= tsubst_aggr_type (ctx
, args
, complain
, in_decl
,
15572 /*entering_scope=*/1);
15573 if (ctx
== error_mark_node
)
15574 return error_mark_node
;
15576 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
15577 complain
, in_decl
);
15578 if (f
== error_mark_node
)
15579 return error_mark_node
;
15581 if (!MAYBE_CLASS_TYPE_P (ctx
))
15583 if (complain
& tf_error
)
15584 error ("%qT is not a class, struct, or union type", ctx
);
15585 return error_mark_node
;
15587 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
15589 /* Normally, make_typename_type does not require that the CTX
15590 have complete type in order to allow things like:
15592 template <class T> struct S { typename S<T>::X Y; };
15594 But, such constructs have already been resolved by this
15595 point, so here CTX really should have complete type, unless
15596 it's a partial instantiation. */
15597 ctx
= complete_type (ctx
);
15598 if (!COMPLETE_TYPE_P (ctx
))
15600 if (complain
& tf_error
)
15601 cxx_incomplete_type_error (NULL_TREE
, ctx
);
15602 return error_mark_node
;
15606 f
= make_typename_type (ctx
, f
, typename_type
,
15607 complain
| tf_keep_type_decl
);
15608 if (f
== error_mark_node
)
15610 if (TREE_CODE (f
) == TYPE_DECL
)
15612 complain
|= tf_ignore_bad_quals
;
15616 if (TREE_CODE (f
) != TYPENAME_TYPE
)
15618 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
15620 if (complain
& tf_error
)
15621 error ("%qT resolves to %qT, which is not an enumeration type",
15624 return error_mark_node
;
15626 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
15628 if (complain
& tf_error
)
15629 error ("%qT resolves to %qT, which is is not a class type",
15632 return error_mark_node
;
15636 return cp_build_qualified_type_real
15637 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
15640 case UNBOUND_CLASS_TEMPLATE
:
15642 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
15643 in_decl
, /*entering_scope=*/1);
15644 tree name
= TYPE_IDENTIFIER (t
);
15645 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
15647 if (ctx
== error_mark_node
|| name
== error_mark_node
)
15648 return error_mark_node
;
15651 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
15652 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
15659 ++cp_unevaluated_operand
;
15660 ++c_inhibit_evaluation_warnings
;
15662 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
15664 /*integral_constant_expression_p=*/false);
15666 --cp_unevaluated_operand
;
15667 --c_inhibit_evaluation_warnings
;
15669 type
= finish_typeof (type
);
15670 return cp_build_qualified_type_real (type
,
15672 | cp_type_quals (type
),
15676 case DECLTYPE_TYPE
:
15680 ++cp_unevaluated_operand
;
15681 ++c_inhibit_evaluation_warnings
;
15683 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
15684 complain
|tf_decltype
, in_decl
,
15685 /*function_p*/false,
15686 /*integral_constant_expression*/false);
15688 --cp_unevaluated_operand
;
15689 --c_inhibit_evaluation_warnings
;
15691 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
15692 type
= lambda_capture_field_type (type
,
15693 false /*explicit_init*/,
15694 DECLTYPE_FOR_REF_CAPTURE (t
));
15695 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
15696 type
= lambda_proxy_type (type
);
15699 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
15700 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
15702 /* In a template ~id could be either a complement expression
15703 or an unqualified-id naming a destructor; if instantiating
15704 it produces an expression, it's not an id-expression or
15707 type
= finish_decltype_type (type
, id
, complain
);
15709 return cp_build_qualified_type_real (type
,
15711 | cp_type_quals (type
),
15712 complain
| tf_ignore_bad_quals
);
15715 case UNDERLYING_TYPE
:
15717 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
15718 complain
, in_decl
);
15719 return finish_underlying_type (type
);
15722 case TYPE_ARGUMENT_PACK
:
15723 case NONTYPE_ARGUMENT_PACK
:
15727 if (code
== NONTYPE_ARGUMENT_PACK
)
15728 r
= make_node (code
);
15730 r
= cxx_make_type (code
);
15732 tree pack_args
= ARGUMENT_PACK_ARGS (t
);
15733 pack_args
= tsubst_template_args (pack_args
, args
, complain
, in_decl
);
15734 SET_ARGUMENT_PACK_ARGS (r
, pack_args
);
15752 /* We should use one of the expression tsubsts for these codes. */
15753 gcc_unreachable ();
15756 sorry ("use of %qs in template", get_tree_code_name (code
));
15757 return error_mark_node
;
15761 /* tsubst a BASELINK. OBJECT_TYPE, if non-NULL, is the type of the
15762 expression on the left-hand side of the "." or "->" operator. We
15763 only do the lookup if we had a dependent BASELINK. Otherwise we
15764 adjust it onto the instantiated heirarchy. */
15767 tsubst_baselink (tree baselink
, tree object_type
,
15768 tree args
, tsubst_flags_t complain
, tree in_decl
)
15770 bool qualified_p
= BASELINK_QUALIFIED_P (baselink
);
15771 tree qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
15772 qualifying_scope
= tsubst (qualifying_scope
, args
, complain
, in_decl
);
15774 tree optype
= BASELINK_OPTYPE (baselink
);
15775 optype
= tsubst (optype
, args
, complain
, in_decl
);
15777 tree template_args
= NULL_TREE
;
15778 bool template_id_p
= false;
15779 tree fns
= BASELINK_FUNCTIONS (baselink
);
15780 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
15782 template_id_p
= true;
15783 template_args
= TREE_OPERAND (fns
, 1);
15784 fns
= TREE_OPERAND (fns
, 0);
15786 template_args
= tsubst_template_args (template_args
, args
,
15787 complain
, in_decl
);
15790 tree binfo_type
= BINFO_TYPE (BASELINK_BINFO (baselink
));
15791 binfo_type
= tsubst (binfo_type
, args
, complain
, in_decl
);
15792 bool dependent_p
= binfo_type
!= BINFO_TYPE (BASELINK_BINFO (baselink
));
15796 tree name
= OVL_NAME (fns
);
15797 if (IDENTIFIER_CONV_OP_P (name
))
15798 name
= make_conv_op_name (optype
);
15800 if (name
== complete_dtor_identifier
)
15801 /* Treat as-if non-dependent below. */
15802 dependent_p
= false;
15804 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
15807 if ((complain
& tf_error
)
15808 && constructor_name_p (name
, qualifying_scope
))
15809 error ("cannot call constructor %<%T::%D%> directly",
15810 qualifying_scope
, name
);
15811 return error_mark_node
;
15814 if (BASELINK_P (baselink
))
15815 fns
= BASELINK_FUNCTIONS (baselink
);
15818 /* We're going to overwrite pieces below, make a duplicate. */
15819 baselink
= copy_node (baselink
);
15821 /* If lookup found a single function, mark it as used at this point.
15822 (If lookup found multiple functions the one selected later by
15823 overload resolution will be marked as used at that point.) */
15824 if (!template_id_p
&& !really_overloaded_fn (fns
))
15826 tree fn
= OVL_FIRST (fns
);
15827 bool ok
= mark_used (fn
, complain
);
15828 if (!ok
&& !(complain
& tf_error
))
15829 return error_mark_node
;
15830 if (ok
&& BASELINK_P (baselink
))
15831 /* We might have instantiated an auto function. */
15832 TREE_TYPE (baselink
) = TREE_TYPE (fn
);
15835 if (BASELINK_P (baselink
))
15837 /* Add back the template arguments, if present. */
15839 BASELINK_FUNCTIONS (baselink
)
15840 = build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fns
, template_args
);
15842 /* Update the conversion operator type. */
15843 BASELINK_OPTYPE (baselink
) = optype
;
15847 object_type
= current_class_type
;
15849 if (qualified_p
|| !dependent_p
)
15851 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
15855 /* We need to call adjust_result_of_qualified_name_lookup in case the
15856 destructor names a base class, but we unset BASELINK_QUALIFIED_P
15857 so that we still get virtual function binding. */
15858 BASELINK_QUALIFIED_P (baselink
) = false;
15864 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
15865 true if the qualified-id will be a postfix-expression in-and-of
15866 itself; false if more of the postfix-expression follows the
15867 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
15871 tsubst_qualified_id (tree qualified_id
, tree args
,
15872 tsubst_flags_t complain
, tree in_decl
,
15873 bool done
, bool address_p
)
15879 tree template_args
;
15880 location_t loc
= UNKNOWN_LOCATION
;
15882 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
15884 /* Figure out what name to look up. */
15885 name
= TREE_OPERAND (qualified_id
, 1);
15886 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
15888 is_template
= true;
15889 loc
= EXPR_LOCATION (name
);
15890 template_args
= TREE_OPERAND (name
, 1);
15892 template_args
= tsubst_template_args (template_args
, args
,
15893 complain
, in_decl
);
15894 if (template_args
== error_mark_node
)
15895 return error_mark_node
;
15896 name
= TREE_OPERAND (name
, 0);
15900 is_template
= false;
15901 template_args
= NULL_TREE
;
15904 /* Substitute into the qualifying scope. When there are no ARGS, we
15905 are just trying to simplify a non-dependent expression. In that
15906 case the qualifying scope may be dependent, and, in any case,
15907 substituting will not help. */
15908 scope
= TREE_OPERAND (qualified_id
, 0);
15911 scope
= tsubst (scope
, args
, complain
, in_decl
);
15912 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
15917 if (dependent_scope_p (scope
))
15920 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
15921 tree r
= build_qualified_name (NULL_TREE
, scope
, expr
,
15922 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
15923 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (qualified_id
);
15927 if (!BASELINK_P (name
) && !DECL_P (expr
))
15929 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
15931 /* A BIT_NOT_EXPR is used to represent a destructor. */
15932 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
15934 error ("qualifying type %qT does not match destructor name ~%qT",
15935 scope
, TREE_OPERAND (expr
, 0));
15936 expr
= error_mark_node
;
15939 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
15940 /*is_type_p=*/0, false);
15943 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
15944 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
15945 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
15947 if (complain
& tf_error
)
15949 error ("dependent-name %qE is parsed as a non-type, but "
15950 "instantiation yields a type", qualified_id
);
15951 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
15953 return error_mark_node
;
15959 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
15961 /* Remember that there was a reference to this entity. */
15962 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
15963 return error_mark_node
;
15966 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
15968 if (complain
& tf_error
)
15969 qualified_name_lookup_error (scope
,
15970 TREE_OPERAND (qualified_id
, 1),
15971 expr
, input_location
);
15972 return error_mark_node
;
15977 /* We may be repeating a check already done during parsing, but
15978 if it was well-formed and passed then, it will pass again
15979 now, and if it didn't, we wouldn't have got here. The case
15980 we want to catch is when we couldn't tell then, and can now,
15981 namely when templ prior to substitution was an
15983 if (flag_concepts
&& check_auto_in_tmpl_args (expr
, template_args
))
15984 return error_mark_node
;
15986 if (variable_template_p (expr
))
15987 expr
= lookup_and_finish_template_variable (expr
, template_args
,
15990 expr
= lookup_template_function (expr
, template_args
);
15993 if (expr
== error_mark_node
&& complain
& tf_error
)
15994 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
15995 expr
, input_location
);
15996 else if (TYPE_P (scope
))
15998 expr
= (adjust_result_of_qualified_name_lookup
15999 (expr
, scope
, current_nonlambda_class_type ()));
16000 expr
= (finish_qualified_id_expr
16001 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
16002 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
16003 /*template_arg_p=*/false, complain
));
16006 /* Expressions do not generally have reference type. */
16007 if (TREE_CODE (expr
) != SCOPE_REF
16008 /* However, if we're about to form a pointer-to-member, we just
16009 want the referenced member referenced. */
16010 && TREE_CODE (expr
) != OFFSET_REF
)
16011 expr
= convert_from_reference (expr
);
16013 if (REF_PARENTHESIZED_P (qualified_id
))
16014 expr
= force_paren_expr (expr
);
16019 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
16020 initializer, DECL is the substituted VAR_DECL. Other arguments are as
16024 tsubst_init (tree init
, tree decl
, tree args
,
16025 tsubst_flags_t complain
, tree in_decl
)
16030 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
16032 tree type
= TREE_TYPE (decl
);
16034 if (!init
&& type
!= error_mark_node
)
16036 if (tree auto_node
= type_uses_auto (type
))
16038 if (!CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
16040 if (complain
& tf_error
)
16041 error ("initializer for %q#D expands to an empty list "
16042 "of expressions", decl
);
16043 return error_mark_node
;
16046 else if (!dependent_type_p (type
))
16048 /* If we had an initializer but it
16049 instantiated to nothing,
16050 value-initialize the object. This will
16051 only occur when the initializer was a
16052 pack expansion where the parameter packs
16053 used in that expansion were of length
16055 init
= build_value_init (type
, complain
);
16056 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
16057 init
= get_target_expr_sfinae (init
, complain
);
16058 if (TREE_CODE (init
) == TARGET_EXPR
)
16059 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
16066 /* Like tsubst, but deals with expressions. This function just replaces
16067 template parms; to finish processing the resultant expression, use
16068 tsubst_copy_and_build or tsubst_expr. */
16071 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
16073 enum tree_code code
;
16076 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
16079 code
= TREE_CODE (t
);
16084 r
= retrieve_local_specialization (t
);
16086 if (r
== NULL_TREE
)
16088 /* We get here for a use of 'this' in an NSDMI. */
16089 if (DECL_NAME (t
) == this_identifier
&& current_class_ptr
)
16090 return current_class_ptr
;
16092 /* This can happen for a parameter name used later in a function
16093 declaration (such as in a late-specified return type). Just
16094 make a dummy decl, since it's only used for its type. */
16095 gcc_assert (cp_unevaluated_operand
!= 0);
16096 r
= tsubst_decl (t
, args
, complain
);
16097 /* Give it the template pattern as its context; its true context
16098 hasn't been instantiated yet and this is good enough for
16100 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
16103 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
16104 r
= argument_pack_select_arg (r
);
16105 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
16106 return error_mark_node
;
16114 if (DECL_TEMPLATE_PARM_P (t
))
16115 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
16116 /* There is no need to substitute into namespace-scope
16118 if (DECL_NAMESPACE_SCOPE_P (t
))
16120 /* If ARGS is NULL, then T is known to be non-dependent. */
16121 if (args
== NULL_TREE
)
16122 return scalar_constant_value (t
);
16124 /* Unfortunately, we cannot just call lookup_name here.
16127 template <int I> int f() {
16129 struct S { void g() { E e = a; } };
16132 When we instantiate f<7>::S::g(), say, lookup_name is not
16133 clever enough to find f<7>::a. */
16135 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
16136 /*entering_scope=*/0);
16138 for (v
= TYPE_VALUES (enum_type
);
16140 v
= TREE_CHAIN (v
))
16141 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
16142 return TREE_VALUE (v
);
16144 /* We didn't find the name. That should never happen; if
16145 name-lookup found it during preliminary parsing, we
16146 should find it again here during instantiation. */
16147 gcc_unreachable ();
16152 if (DECL_CONTEXT (t
))
16156 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
16157 /*entering_scope=*/1);
16158 if (ctx
!= DECL_CONTEXT (t
))
16160 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
16163 if (complain
& tf_error
)
16164 error ("using invalid field %qD", t
);
16165 return error_mark_node
;
16174 case FUNCTION_DECL
:
16175 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
16176 r
= tsubst (t
, args
, complain
, in_decl
);
16177 else if (local_variable_p (t
)
16178 && uses_template_parms (DECL_CONTEXT (t
)))
16180 r
= retrieve_local_specialization (t
);
16181 if (r
== NULL_TREE
)
16183 /* First try name lookup to find the instantiation. */
16184 r
= lookup_name (DECL_NAME (t
));
16189 /* During error-recovery we may find a non-variable,
16190 even an OVERLOAD: just bail out and avoid ICEs and
16191 duplicate diagnostics (c++/62207). */
16192 gcc_assert (seen_error ());
16193 return error_mark_node
;
16195 if (!is_capture_proxy (r
))
16197 /* Make sure the one we found is the one we want. */
16198 tree ctx
= enclosing_instantiation_of (DECL_CONTEXT (t
));
16199 if (ctx
!= DECL_CONTEXT (r
))
16208 /* This can happen for a variable used in a
16209 late-specified return type of a local lambda, or for a
16210 local static or constant. Building a new VAR_DECL
16211 should be OK in all those cases. */
16212 r
= tsubst_decl (t
, args
, complain
);
16213 if (local_specializations
)
16214 /* Avoid infinite recursion (79640). */
16215 register_local_specialization (r
, t
);
16216 if (decl_maybe_constant_var_p (r
))
16218 /* We can't call cp_finish_decl, so handle the
16219 initializer by hand. */
16220 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
16221 complain
, in_decl
);
16222 if (!processing_template_decl
)
16223 init
= maybe_constant_init (init
);
16224 if (processing_template_decl
16225 ? potential_constant_expression (init
)
16226 : reduced_constant_expression_p (init
))
16227 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
16228 = TREE_CONSTANT (r
) = true;
16229 DECL_INITIAL (r
) = init
;
16230 if (tree auto_node
= type_uses_auto (TREE_TYPE (r
)))
16232 = do_auto_deduction (TREE_TYPE (r
), init
, auto_node
,
16233 complain
, adc_variable_type
);
16235 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
16236 || decl_constant_var_p (r
)
16238 if (!processing_template_decl
16239 && !TREE_STATIC (r
))
16240 r
= process_outer_var_ref (r
, complain
);
16242 /* Remember this for subsequent uses. */
16243 if (local_specializations
)
16244 register_local_specialization (r
, t
);
16246 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
16247 r
= argument_pack_select_arg (r
);
16251 if (!mark_used (r
, complain
))
16252 return error_mark_node
;
16255 case NAMESPACE_DECL
:
16262 return tsubst_baselink (t
, current_nonlambda_class_type (),
16263 args
, complain
, in_decl
);
16265 case TEMPLATE_DECL
:
16266 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
16267 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
16268 args
, complain
, in_decl
);
16269 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
16270 return tsubst (t
, args
, complain
, in_decl
);
16271 else if (DECL_CLASS_SCOPE_P (t
)
16272 && uses_template_parms (DECL_CONTEXT (t
)))
16274 /* Template template argument like the following example need
16277 template <template <class> class TT> struct C {};
16278 template <class T> struct D {
16279 template <class U> struct E {};
16284 We are processing the template argument `E' in #1 for
16285 the template instantiation #2. Originally, `E' is a
16286 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
16287 have to substitute this with one having context `D<int>'. */
16289 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
16290 if (dependent_scope_p (context
))
16292 /* When rewriting a constructor into a deduction guide, a
16293 non-dependent name can become dependent, so memtmpl<args>
16294 becomes context::template memtmpl<args>. */
16295 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16296 return build_qualified_name (type
, context
, DECL_NAME (t
),
16299 return lookup_field (context
, DECL_NAME(t
), 0, false);
16302 /* Ordinary template template argument. */
16305 case NON_LVALUE_EXPR
:
16306 case VIEW_CONVERT_EXPR
:
16308 /* Handle location wrappers by substituting the wrapped node
16309 first, *then* reusing the resulting type. Doing the type
16310 first ensures that we handle template parameters and
16311 parameter pack expansions. */
16312 if (location_wrapper_p (t
))
16314 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
,
16315 complain
, in_decl
);
16316 return maybe_wrap_with_location (op0
, EXPR_LOCATION (t
));
16318 tree op
= TREE_OPERAND (t
, 0);
16319 if (code
== VIEW_CONVERT_EXPR
16320 && TREE_CODE (op
) == TEMPLATE_PARM_INDEX
)
16322 /* Wrapper to make a C++20 template parameter object const. */
16323 op
= tsubst_copy (op
, args
, complain
, in_decl
);
16324 if (TREE_CODE (op
) == TEMPLATE_PARM_INDEX
)
16326 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16327 return build1 (code
, type
, op
);
16331 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (op
)));
16335 /* We shouldn't see any other uses of these in templates. */
16336 gcc_unreachable ();
16340 case REINTERPRET_CAST_EXPR
:
16341 case CONST_CAST_EXPR
:
16342 case STATIC_CAST_EXPR
:
16343 case DYNAMIC_CAST_EXPR
:
16344 case IMPLICIT_CONV_EXPR
:
16348 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16349 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16350 return build1 (code
, type
, op0
);
16354 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
16355 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
16357 tree expanded
, op
= TREE_OPERAND (t
, 0);
16360 if (SIZEOF_EXPR_TYPE_P (t
))
16361 op
= TREE_TYPE (op
);
16363 ++cp_unevaluated_operand
;
16364 ++c_inhibit_evaluation_warnings
;
16365 /* We only want to compute the number of arguments. */
16366 if (PACK_EXPANSION_P (op
))
16367 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
16369 expanded
= tsubst_template_args (ARGUMENT_PACK_ARGS (op
),
16370 args
, complain
, in_decl
);
16371 --cp_unevaluated_operand
;
16372 --c_inhibit_evaluation_warnings
;
16374 if (TREE_CODE (expanded
) == TREE_VEC
)
16376 len
= TREE_VEC_LENGTH (expanded
);
16377 /* Set TREE_USED for the benefit of -Wunused. */
16378 for (int i
= 0; i
< len
; i
++)
16379 if (DECL_P (TREE_VEC_ELT (expanded
, i
)))
16380 TREE_USED (TREE_VEC_ELT (expanded
, i
)) = true;
16383 if (expanded
== error_mark_node
)
16384 return error_mark_node
;
16385 else if (PACK_EXPANSION_P (expanded
)
16386 || (TREE_CODE (expanded
) == TREE_VEC
16387 && pack_expansion_args_count (expanded
)))
16390 if (PACK_EXPANSION_P (expanded
))
16392 else if (TREE_VEC_LENGTH (expanded
) == 1)
16393 expanded
= TREE_VEC_ELT (expanded
, 0);
16395 expanded
= make_argument_pack (expanded
);
16397 if (TYPE_P (expanded
))
16398 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
16400 complain
& tf_error
);
16402 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
16403 complain
& tf_error
);
16406 return build_int_cst (size_type_node
, len
);
16408 if (SIZEOF_EXPR_TYPE_P (t
))
16410 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
16411 args
, complain
, in_decl
);
16412 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
16413 r
= build1 (SIZEOF_EXPR
,
16414 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
16415 SIZEOF_EXPR_TYPE_P (r
) = 1;
16422 case TRUTH_NOT_EXPR
:
16425 case UNARY_PLUS_EXPR
: /* Unary + */
16427 case AT_ENCODE_EXPR
:
16431 case REALPART_EXPR
:
16432 case IMAGPART_EXPR
:
16435 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16436 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16437 r
= build1 (code
, type
, op0
);
16438 if (code
== ALIGNOF_EXPR
)
16439 ALIGNOF_EXPR_STD_P (r
) = ALIGNOF_EXPR_STD_P (t
);
16443 case COMPONENT_REF
:
16448 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16449 name
= TREE_OPERAND (t
, 1);
16450 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
16452 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
16453 complain
, in_decl
);
16454 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
16456 else if (TREE_CODE (name
) == SCOPE_REF
16457 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
16459 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
16460 complain
, in_decl
);
16461 name
= TREE_OPERAND (name
, 1);
16462 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
16463 complain
, in_decl
);
16464 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
16465 name
= build_qualified_name (/*type=*/NULL_TREE
,
16467 /*template_p=*/false);
16469 else if (BASELINK_P (name
))
16470 name
= tsubst_baselink (name
,
16471 non_reference (TREE_TYPE (object
)),
16475 name
= tsubst_copy (name
, args
, complain
, in_decl
);
16476 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
16482 case TRUNC_DIV_EXPR
:
16483 case CEIL_DIV_EXPR
:
16484 case FLOOR_DIV_EXPR
:
16485 case ROUND_DIV_EXPR
:
16486 case EXACT_DIV_EXPR
:
16490 case TRUNC_MOD_EXPR
:
16491 case FLOOR_MOD_EXPR
:
16492 case TRUTH_ANDIF_EXPR
:
16493 case TRUTH_ORIF_EXPR
:
16494 case TRUTH_AND_EXPR
:
16495 case TRUTH_OR_EXPR
:
16506 case COMPOUND_EXPR
:
16509 case PREDECREMENT_EXPR
:
16510 case PREINCREMENT_EXPR
:
16511 case POSTDECREMENT_EXPR
:
16512 case POSTINCREMENT_EXPR
:
16514 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16515 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16516 return build_nt (code
, op0
, op1
);
16521 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16522 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16523 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
16524 QUALIFIED_NAME_IS_TEMPLATE (t
));
16529 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16530 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16531 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
16536 int n
= VL_EXP_OPERAND_LENGTH (t
);
16537 tree result
= build_vl_exp (CALL_EXPR
, n
);
16539 for (i
= 0; i
< n
; i
++)
16540 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
16541 complain
, in_decl
);
16547 case PSEUDO_DTOR_EXPR
:
16548 case VEC_PERM_EXPR
:
16550 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16551 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16552 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
16553 r
= build_nt (code
, op0
, op1
, op2
);
16554 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
16560 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16561 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16562 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
16563 r
= build_nt (code
, op0
, op1
, op2
);
16564 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
16570 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16571 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16572 r
= build_nt (code
, op0
, op1
);
16573 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
16574 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
16578 case TEMPLATE_ID_EXPR
:
16580 /* Substituted template arguments */
16581 tree fn
= TREE_OPERAND (t
, 0);
16582 tree targs
= TREE_OPERAND (t
, 1);
16584 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
16586 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
16588 return lookup_template_function (fn
, targs
);
16593 tree purpose
, value
, chain
;
16595 if (t
== void_list_node
)
16598 purpose
= TREE_PURPOSE (t
);
16600 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
16601 value
= TREE_VALUE (t
);
16603 value
= tsubst_copy (value
, args
, complain
, in_decl
);
16604 chain
= TREE_CHAIN (t
);
16605 if (chain
&& chain
!= void_type_node
)
16606 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
16607 if (purpose
== TREE_PURPOSE (t
)
16608 && value
== TREE_VALUE (t
)
16609 && chain
== TREE_CHAIN (t
))
16611 return tree_cons (purpose
, value
, chain
);
16616 case ENUMERAL_TYPE
:
16618 case TEMPLATE_TYPE_PARM
:
16619 case TEMPLATE_TEMPLATE_PARM
:
16620 case BOUND_TEMPLATE_TEMPLATE_PARM
:
16621 case TEMPLATE_PARM_INDEX
:
16623 case REFERENCE_TYPE
:
16625 case FUNCTION_TYPE
:
16628 case TYPENAME_TYPE
:
16629 case UNBOUND_CLASS_TEMPLATE
:
16631 case DECLTYPE_TYPE
:
16633 return tsubst (t
, args
, complain
, in_decl
);
16637 /* Fall through. */
16638 case IDENTIFIER_NODE
:
16639 if (IDENTIFIER_CONV_OP_P (t
))
16641 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16642 return make_conv_op_name (new_type
);
16648 /* This is handled by tsubst_copy_and_build. */
16649 gcc_unreachable ();
16653 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16654 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16655 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
16658 case CLEANUP_POINT_EXPR
:
16659 /* We shouldn't have built any of these during initial template
16660 generation. Instead, they should be built during instantiation
16661 in response to the saved STMT_IS_FULL_EXPR_P setting. */
16662 gcc_unreachable ();
16666 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16667 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
16668 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16669 r
= build2 (code
, type
, op0
, op1
);
16670 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
16671 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
16672 && !(complain
& tf_error
))
16673 return error_mark_node
;
16677 case EXPR_PACK_EXPANSION
:
16678 error ("invalid use of pack expansion expression");
16679 return error_mark_node
;
16681 case NONTYPE_ARGUMENT_PACK
:
16682 error ("use %<...%> to expand argument pack");
16683 return error_mark_node
;
16686 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
16694 /* Instantiate any typedefs in the type. */
16695 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16696 r
= fold_convert (type
, t
);
16697 gcc_assert (TREE_CODE (r
) == code
);
16702 /* These can sometimes show up in a partial instantiation, but never
16703 involve template parms. */
16704 gcc_assert (!uses_template_parms (t
));
16707 case UNARY_LEFT_FOLD_EXPR
:
16708 return tsubst_unary_left_fold (t
, args
, complain
, in_decl
);
16709 case UNARY_RIGHT_FOLD_EXPR
:
16710 return tsubst_unary_right_fold (t
, args
, complain
, in_decl
);
16711 case BINARY_LEFT_FOLD_EXPR
:
16712 return tsubst_binary_left_fold (t
, args
, complain
, in_decl
);
16713 case BINARY_RIGHT_FOLD_EXPR
:
16714 return tsubst_binary_right_fold (t
, args
, complain
, in_decl
);
16718 case DEBUG_BEGIN_STMT
:
16719 /* ??? There's no point in copying it for now, but maybe some
16720 day it will contain more information, such as a pointer back
16721 to the containing function, inlined copy or so. */
16725 /* We shouldn't get here, but keep going if !flag_checking. */
16727 gcc_unreachable ();
16732 /* Helper function for tsubst_omp_clauses, used for instantiation of
16733 OMP_CLAUSE_DECL of clauses. */
16736 tsubst_omp_clause_decl (tree decl
, tree args
, tsubst_flags_t complain
,
16737 tree in_decl
, tree
*iterator_cache
)
16739 if (decl
== NULL_TREE
)
16742 /* Handle OpenMP iterators. */
16743 if (TREE_CODE (decl
) == TREE_LIST
16744 && TREE_PURPOSE (decl
)
16745 && TREE_CODE (TREE_PURPOSE (decl
)) == TREE_VEC
)
16748 if (iterator_cache
[0] == TREE_PURPOSE (decl
))
16749 ret
= iterator_cache
[1];
16753 begin_scope (sk_omp
, NULL
);
16754 for (tree it
= TREE_PURPOSE (decl
); it
; it
= TREE_CHAIN (it
))
16756 *tp
= copy_node (it
);
16757 TREE_VEC_ELT (*tp
, 0)
16758 = tsubst_decl (TREE_VEC_ELT (it
, 0), args
, complain
);
16759 TREE_VEC_ELT (*tp
, 1)
16760 = tsubst_expr (TREE_VEC_ELT (it
, 1), args
, complain
, in_decl
,
16761 /*integral_constant_expression_p=*/false);
16762 TREE_VEC_ELT (*tp
, 2)
16763 = tsubst_expr (TREE_VEC_ELT (it
, 2), args
, complain
, in_decl
,
16764 /*integral_constant_expression_p=*/false);
16765 TREE_VEC_ELT (*tp
, 3)
16766 = tsubst_expr (TREE_VEC_ELT (it
, 3), args
, complain
, in_decl
,
16767 /*integral_constant_expression_p=*/false);
16768 TREE_CHAIN (*tp
) = NULL_TREE
;
16769 tp
= &TREE_CHAIN (*tp
);
16771 TREE_VEC_ELT (ret
, 5) = poplevel (1, 1, 0);
16772 iterator_cache
[0] = TREE_PURPOSE (decl
);
16773 iterator_cache
[1] = ret
;
16775 return build_tree_list (ret
, tsubst_omp_clause_decl (TREE_VALUE (decl
),
16780 /* Handle an OpenMP array section represented as a TREE_LIST (or
16781 OMP_CLAUSE_DEPEND_KIND). An OMP_CLAUSE_DEPEND (with a depend
16782 kind of OMP_CLAUSE_DEPEND_SINK) can also be represented as a
16783 TREE_LIST. We can handle it exactly the same as an array section
16784 (purpose, value, and a chain), even though the nomenclature
16785 (low_bound, length, etc) is different. */
16786 if (TREE_CODE (decl
) == TREE_LIST
)
16789 = tsubst_expr (TREE_PURPOSE (decl
), args
, complain
, in_decl
,
16790 /*integral_constant_expression_p=*/false);
16791 tree length
= tsubst_expr (TREE_VALUE (decl
), args
, complain
, in_decl
,
16792 /*integral_constant_expression_p=*/false);
16793 tree chain
= tsubst_omp_clause_decl (TREE_CHAIN (decl
), args
, complain
,
16795 if (TREE_PURPOSE (decl
) == low_bound
16796 && TREE_VALUE (decl
) == length
16797 && TREE_CHAIN (decl
) == chain
)
16799 tree ret
= tree_cons (low_bound
, length
, chain
);
16800 OMP_CLAUSE_DEPEND_SINK_NEGATIVE (ret
)
16801 = OMP_CLAUSE_DEPEND_SINK_NEGATIVE (decl
);
16804 tree ret
= tsubst_expr (decl
, args
, complain
, in_decl
,
16805 /*integral_constant_expression_p=*/false);
16806 /* Undo convert_from_reference tsubst_expr could have called. */
16808 && REFERENCE_REF_P (ret
)
16809 && !REFERENCE_REF_P (decl
))
16810 ret
= TREE_OPERAND (ret
, 0);
16814 /* Like tsubst_copy, but specifically for OpenMP clauses. */
16817 tsubst_omp_clauses (tree clauses
, enum c_omp_region_type ort
,
16818 tree args
, tsubst_flags_t complain
, tree in_decl
)
16820 tree new_clauses
= NULL_TREE
, nc
, oc
;
16821 tree linear_no_step
= NULL_TREE
;
16822 tree iterator_cache
[2] = { NULL_TREE
, NULL_TREE
};
16824 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
16826 nc
= copy_node (oc
);
16827 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
16830 switch (OMP_CLAUSE_CODE (nc
))
16832 case OMP_CLAUSE_LASTPRIVATE
:
16833 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
16835 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
16836 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
16837 in_decl
, /*integral_constant_expression_p=*/false);
16838 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
16839 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
16842 case OMP_CLAUSE_PRIVATE
:
16843 case OMP_CLAUSE_SHARED
:
16844 case OMP_CLAUSE_FIRSTPRIVATE
:
16845 case OMP_CLAUSE_COPYIN
:
16846 case OMP_CLAUSE_COPYPRIVATE
:
16847 case OMP_CLAUSE_UNIFORM
:
16848 case OMP_CLAUSE_DEPEND
:
16849 case OMP_CLAUSE_FROM
:
16850 case OMP_CLAUSE_TO
:
16851 case OMP_CLAUSE_MAP
:
16852 case OMP_CLAUSE_NONTEMPORAL
:
16853 case OMP_CLAUSE_USE_DEVICE_PTR
:
16854 case OMP_CLAUSE_USE_DEVICE_ADDR
:
16855 case OMP_CLAUSE_IS_DEVICE_PTR
:
16856 case OMP_CLAUSE_INCLUSIVE
:
16857 case OMP_CLAUSE_EXCLUSIVE
:
16858 OMP_CLAUSE_DECL (nc
)
16859 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16860 in_decl
, iterator_cache
);
16862 case OMP_CLAUSE_TILE
:
16863 case OMP_CLAUSE_IF
:
16864 case OMP_CLAUSE_NUM_THREADS
:
16865 case OMP_CLAUSE_SCHEDULE
:
16866 case OMP_CLAUSE_COLLAPSE
:
16867 case OMP_CLAUSE_FINAL
:
16868 case OMP_CLAUSE_DEVICE
:
16869 case OMP_CLAUSE_DIST_SCHEDULE
:
16870 case OMP_CLAUSE_NUM_TEAMS
:
16871 case OMP_CLAUSE_THREAD_LIMIT
:
16872 case OMP_CLAUSE_SAFELEN
:
16873 case OMP_CLAUSE_SIMDLEN
:
16874 case OMP_CLAUSE_NUM_TASKS
:
16875 case OMP_CLAUSE_GRAINSIZE
:
16876 case OMP_CLAUSE_PRIORITY
:
16877 case OMP_CLAUSE_ORDERED
:
16878 case OMP_CLAUSE_HINT
:
16879 case OMP_CLAUSE_NUM_GANGS
:
16880 case OMP_CLAUSE_NUM_WORKERS
:
16881 case OMP_CLAUSE_VECTOR_LENGTH
:
16882 case OMP_CLAUSE_WORKER
:
16883 case OMP_CLAUSE_VECTOR
:
16884 case OMP_CLAUSE_ASYNC
:
16885 case OMP_CLAUSE_WAIT
:
16886 OMP_CLAUSE_OPERAND (nc
, 0)
16887 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
16888 in_decl
, /*integral_constant_expression_p=*/false);
16890 case OMP_CLAUSE_REDUCTION
:
16891 case OMP_CLAUSE_IN_REDUCTION
:
16892 case OMP_CLAUSE_TASK_REDUCTION
:
16893 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
16895 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
16896 if (TREE_CODE (placeholder
) == SCOPE_REF
)
16898 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
16899 complain
, in_decl
);
16900 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
16901 = build_qualified_name (NULL_TREE
, scope
,
16902 TREE_OPERAND (placeholder
, 1),
16906 gcc_assert (identifier_p (placeholder
));
16908 OMP_CLAUSE_DECL (nc
)
16909 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16912 case OMP_CLAUSE_GANG
:
16913 case OMP_CLAUSE_ALIGNED
:
16914 OMP_CLAUSE_DECL (nc
)
16915 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16917 OMP_CLAUSE_OPERAND (nc
, 1)
16918 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
16919 in_decl
, /*integral_constant_expression_p=*/false);
16921 case OMP_CLAUSE_LINEAR
:
16922 OMP_CLAUSE_DECL (nc
)
16923 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16925 if (OMP_CLAUSE_LINEAR_STEP (oc
) == NULL_TREE
)
16927 gcc_assert (!linear_no_step
);
16928 linear_no_step
= nc
;
16930 else if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (oc
))
16931 OMP_CLAUSE_LINEAR_STEP (nc
)
16932 = tsubst_omp_clause_decl (OMP_CLAUSE_LINEAR_STEP (oc
), args
,
16933 complain
, in_decl
, NULL
);
16935 OMP_CLAUSE_LINEAR_STEP (nc
)
16936 = tsubst_expr (OMP_CLAUSE_LINEAR_STEP (oc
), args
, complain
,
16938 /*integral_constant_expression_p=*/false);
16940 case OMP_CLAUSE_NOWAIT
:
16941 case OMP_CLAUSE_DEFAULT
:
16942 case OMP_CLAUSE_UNTIED
:
16943 case OMP_CLAUSE_MERGEABLE
:
16944 case OMP_CLAUSE_INBRANCH
:
16945 case OMP_CLAUSE_NOTINBRANCH
:
16946 case OMP_CLAUSE_PROC_BIND
:
16947 case OMP_CLAUSE_FOR
:
16948 case OMP_CLAUSE_PARALLEL
:
16949 case OMP_CLAUSE_SECTIONS
:
16950 case OMP_CLAUSE_TASKGROUP
:
16951 case OMP_CLAUSE_NOGROUP
:
16952 case OMP_CLAUSE_THREADS
:
16953 case OMP_CLAUSE_SIMD
:
16954 case OMP_CLAUSE_DEFAULTMAP
:
16955 case OMP_CLAUSE_ORDER
:
16956 case OMP_CLAUSE_BIND
:
16957 case OMP_CLAUSE_INDEPENDENT
:
16958 case OMP_CLAUSE_AUTO
:
16959 case OMP_CLAUSE_SEQ
:
16960 case OMP_CLAUSE_IF_PRESENT
:
16961 case OMP_CLAUSE_FINALIZE
:
16964 gcc_unreachable ();
16966 if ((ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
)
16967 switch (OMP_CLAUSE_CODE (nc
))
16969 case OMP_CLAUSE_SHARED
:
16970 case OMP_CLAUSE_PRIVATE
:
16971 case OMP_CLAUSE_FIRSTPRIVATE
:
16972 case OMP_CLAUSE_LASTPRIVATE
:
16973 case OMP_CLAUSE_COPYPRIVATE
:
16974 case OMP_CLAUSE_LINEAR
:
16975 case OMP_CLAUSE_REDUCTION
:
16976 case OMP_CLAUSE_IN_REDUCTION
:
16977 case OMP_CLAUSE_TASK_REDUCTION
:
16978 case OMP_CLAUSE_USE_DEVICE_PTR
:
16979 case OMP_CLAUSE_USE_DEVICE_ADDR
:
16980 case OMP_CLAUSE_IS_DEVICE_PTR
:
16981 case OMP_CLAUSE_INCLUSIVE
:
16982 case OMP_CLAUSE_EXCLUSIVE
:
16983 /* tsubst_expr on SCOPE_REF results in returning
16984 finish_non_static_data_member result. Undo that here. */
16985 if (TREE_CODE (OMP_CLAUSE_DECL (oc
)) == SCOPE_REF
16986 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (oc
), 1))
16987 == IDENTIFIER_NODE
))
16989 tree t
= OMP_CLAUSE_DECL (nc
);
16992 switch (TREE_CODE (v
))
16994 case COMPONENT_REF
:
16998 case POINTER_PLUS_EXPR
:
16999 v
= TREE_OPERAND (v
, 0);
17002 if (DECL_CONTEXT (v
) == current_function_decl
17003 && DECL_ARTIFICIAL (v
)
17004 && DECL_NAME (v
) == this_identifier
)
17005 OMP_CLAUSE_DECL (nc
) = TREE_OPERAND (t
, 1);
17012 else if (VAR_P (OMP_CLAUSE_DECL (oc
))
17013 && DECL_HAS_VALUE_EXPR_P (OMP_CLAUSE_DECL (oc
))
17014 && DECL_ARTIFICIAL (OMP_CLAUSE_DECL (oc
))
17015 && DECL_LANG_SPECIFIC (OMP_CLAUSE_DECL (oc
))
17016 && DECL_OMP_PRIVATIZED_MEMBER (OMP_CLAUSE_DECL (oc
)))
17018 tree decl
= OMP_CLAUSE_DECL (nc
);
17021 retrofit_lang_decl (decl
);
17022 DECL_OMP_PRIVATIZED_MEMBER (decl
) = 1;
17031 new_clauses
= nreverse (new_clauses
);
17032 if (ort
!= C_ORT_OMP_DECLARE_SIMD
)
17034 new_clauses
= finish_omp_clauses (new_clauses
, ort
);
17035 if (linear_no_step
)
17036 for (nc
= new_clauses
; nc
; nc
= OMP_CLAUSE_CHAIN (nc
))
17037 if (nc
== linear_no_step
)
17039 OMP_CLAUSE_LINEAR_STEP (nc
) = NULL_TREE
;
17043 return new_clauses
;
17046 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
17049 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
17052 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
17054 tree purpose
, value
, chain
;
17059 if (TREE_CODE (t
) != TREE_LIST
)
17060 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
17061 /*function_p=*/false,
17062 /*integral_constant_expression_p=*/false);
17064 if (t
== void_list_node
)
17067 purpose
= TREE_PURPOSE (t
);
17069 purpose
= RECUR (purpose
);
17070 value
= TREE_VALUE (t
);
17073 if (TREE_CODE (value
) != LABEL_DECL
)
17074 value
= RECUR (value
);
17077 value
= lookup_label (DECL_NAME (value
));
17078 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
17079 TREE_USED (value
) = 1;
17082 chain
= TREE_CHAIN (t
);
17083 if (chain
&& chain
!= void_type_node
)
17084 chain
= RECUR (chain
);
17085 return tree_cons (purpose
, value
, chain
);
17089 /* Used to temporarily communicate the list of #pragma omp parallel
17090 clauses to #pragma omp for instantiation if they are combined
17093 static tree
*omp_parallel_combined_clauses
;
17095 static tree
tsubst_decomp_names (tree
, tree
, tree
, tsubst_flags_t
, tree
,
17096 tree
*, unsigned int *);
17098 /* Substitute one OMP_FOR iterator. */
17101 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree
&orig_declv
,
17102 tree initv
, tree condv
, tree incrv
, tree
*clauses
,
17103 tree args
, tsubst_flags_t complain
, tree in_decl
,
17104 bool integral_constant_expression_p
)
17106 #define RECUR(NODE) \
17107 tsubst_expr ((NODE), args, complain, in_decl, \
17108 integral_constant_expression_p)
17109 tree decl
, init
, cond
= NULL_TREE
, incr
= NULL_TREE
;
17112 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
17113 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
17115 decl
= TREE_OPERAND (init
, 0);
17116 init
= TREE_OPERAND (init
, 1);
17117 tree decl_expr
= NULL_TREE
;
17118 bool range_for
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
) == global_namespace
;
17121 bool decomp
= false;
17122 if (decl
!= error_mark_node
&& DECL_HAS_VALUE_EXPR_P (decl
))
17124 tree v
= DECL_VALUE_EXPR (decl
);
17125 if (TREE_CODE (v
) == ARRAY_REF
17126 && VAR_P (TREE_OPERAND (v
, 0))
17127 && DECL_DECOMPOSITION_P (TREE_OPERAND (v
, 0)))
17129 tree decomp_first
= NULL_TREE
;
17130 unsigned decomp_cnt
= 0;
17131 tree d
= tsubst_decl (TREE_OPERAND (v
, 0), args
, complain
);
17132 maybe_push_decl (d
);
17133 d
= tsubst_decomp_names (d
, TREE_OPERAND (v
, 0), args
, complain
,
17134 in_decl
, &decomp_first
, &decomp_cnt
);
17136 if (d
== error_mark_node
)
17137 decl
= error_mark_node
;
17139 for (unsigned int i
= 0; i
< decomp_cnt
; i
++)
17141 if (!DECL_HAS_VALUE_EXPR_P (decomp_first
))
17143 tree v
= build_nt (ARRAY_REF
, d
,
17144 size_int (decomp_cnt
- i
- 1),
17145 NULL_TREE
, NULL_TREE
);
17146 SET_DECL_VALUE_EXPR (decomp_first
, v
);
17147 DECL_HAS_VALUE_EXPR_P (decomp_first
) = 1;
17149 fit_decomposition_lang_decl (decomp_first
, d
);
17150 decomp_first
= DECL_CHAIN (decomp_first
);
17154 decl
= tsubst_decl (decl
, args
, complain
);
17156 maybe_push_decl (decl
);
17158 else if (init
&& TREE_CODE (init
) == DECL_EXPR
)
17160 /* We need to jump through some hoops to handle declarations in the
17161 init-statement, since we might need to handle auto deduction,
17162 but we need to keep control of initialization. */
17164 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
17165 decl
= tsubst_decl (decl
, args
, complain
);
17169 if (TREE_CODE (decl
) == SCOPE_REF
)
17171 decl
= RECUR (decl
);
17172 if (TREE_CODE (decl
) == COMPONENT_REF
)
17176 switch (TREE_CODE (v
))
17178 case COMPONENT_REF
:
17182 case POINTER_PLUS_EXPR
:
17183 v
= TREE_OPERAND (v
, 0);
17186 if (DECL_CONTEXT (v
) == current_function_decl
17187 && DECL_ARTIFICIAL (v
)
17188 && DECL_NAME (v
) == this_identifier
)
17190 decl
= TREE_OPERAND (decl
, 1);
17191 decl
= omp_privatize_field (decl
, false);
17201 decl
= RECUR (decl
);
17203 init
= RECUR (init
);
17205 if (orig_declv
&& OMP_FOR_ORIG_DECLS (t
))
17207 tree o
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t
), i
);
17208 if (TREE_CODE (o
) == TREE_LIST
)
17209 TREE_VEC_ELT (orig_declv
, i
)
17210 = tree_cons (RECUR (TREE_PURPOSE (o
)),
17211 RECUR (TREE_VALUE (o
)),
17214 TREE_VEC_ELT (orig_declv
, i
) = RECUR (o
);
17219 tree this_pre_body
= NULL_TREE
;
17220 tree orig_init
= NULL_TREE
;
17221 tree orig_decl
= NULL_TREE
;
17222 cp_convert_omp_range_for (this_pre_body
, NULL
, decl
, orig_decl
, init
,
17223 orig_init
, cond
, incr
);
17226 if (orig_declv
== NULL_TREE
)
17227 orig_declv
= copy_node (declv
);
17228 TREE_VEC_ELT (orig_declv
, i
) = orig_decl
;
17231 else if (orig_declv
)
17232 TREE_VEC_ELT (orig_declv
, i
) = decl
;
17235 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
17236 if (!range_for
&& auto_node
&& init
)
17238 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
, complain
);
17240 gcc_assert (!type_dependent_expression_p (decl
));
17242 if (!CLASS_TYPE_P (TREE_TYPE (decl
)) || range_for
)
17246 /* Declare the variable, but don't let that initialize it. */
17247 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
17248 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
17250 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
17255 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
17256 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
17257 if (TREE_CODE (incr
) == MODIFY_EXPR
)
17259 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
17260 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
17261 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
17262 NOP_EXPR
, rhs
, complain
);
17265 incr
= RECUR (incr
);
17266 if (orig_declv
&& !OMP_FOR_ORIG_DECLS (t
))
17267 TREE_VEC_ELT (orig_declv
, i
) = decl
;
17269 TREE_VEC_ELT (declv
, i
) = decl
;
17270 TREE_VEC_ELT (initv
, i
) = init
;
17271 TREE_VEC_ELT (condv
, i
) = cond
;
17272 TREE_VEC_ELT (incrv
, i
) = incr
;
17278 /* Declare and initialize the variable. */
17286 for (j
= ((omp_parallel_combined_clauses
== NULL
17287 || TREE_CODE (t
) == OMP_LOOP
) ? 1 : 0); j
< 2; j
++)
17289 for (pc
= j
? clauses
: omp_parallel_combined_clauses
; *pc
; )
17291 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
17292 && OMP_CLAUSE_DECL (*pc
) == decl
)
17294 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_LASTPRIVATE
17295 && OMP_CLAUSE_DECL (*pc
) == decl
)
17299 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
17301 *pc
= OMP_CLAUSE_CHAIN (c
);
17302 OMP_CLAUSE_CHAIN (c
) = *clauses
;
17305 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_FIRSTPRIVATE
17306 && OMP_CLAUSE_DECL (*pc
) == decl
)
17308 error ("iteration variable %qD should not be firstprivate",
17310 *pc
= OMP_CLAUSE_CHAIN (*pc
);
17312 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_REDUCTION
17313 && OMP_CLAUSE_DECL (*pc
) == decl
)
17315 error ("iteration variable %qD should not be reduction",
17317 *pc
= OMP_CLAUSE_CHAIN (*pc
);
17320 pc
= &OMP_CLAUSE_CHAIN (*pc
);
17325 if (*pc
== NULL_TREE
)
17327 tree c
= build_omp_clause (input_location
,
17328 TREE_CODE (t
) == OMP_LOOP
17329 ? OMP_CLAUSE_LASTPRIVATE
17330 : OMP_CLAUSE_PRIVATE
);
17331 OMP_CLAUSE_DECL (c
) = decl
;
17332 c
= finish_omp_clauses (c
, C_ORT_OMP
);
17335 OMP_CLAUSE_CHAIN (c
) = *clauses
;
17340 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
17341 if (COMPARISON_CLASS_P (cond
))
17343 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
17344 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
17345 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
17348 cond
= RECUR (cond
);
17349 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
17350 switch (TREE_CODE (incr
))
17352 case PREINCREMENT_EXPR
:
17353 case PREDECREMENT_EXPR
:
17354 case POSTINCREMENT_EXPR
:
17355 case POSTDECREMENT_EXPR
:
17356 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
17357 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
17360 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
17361 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
17363 tree rhs
= TREE_OPERAND (incr
, 1);
17364 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
17365 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
17366 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
17367 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
17368 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
17372 incr
= RECUR (incr
);
17375 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
17376 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
17378 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
17379 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
17380 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
17381 TREE_TYPE (decl
), lhs
,
17382 RECUR (TREE_OPERAND (incr
, 2))));
17384 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
17385 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
17386 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
17388 tree rhs
= TREE_OPERAND (incr
, 2);
17389 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
17390 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
17391 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
17392 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
17393 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
17397 incr
= RECUR (incr
);
17400 incr
= RECUR (incr
);
17404 if (orig_declv
&& !OMP_FOR_ORIG_DECLS (t
))
17405 TREE_VEC_ELT (orig_declv
, i
) = decl
;
17406 TREE_VEC_ELT (declv
, i
) = decl
;
17407 TREE_VEC_ELT (initv
, i
) = init
;
17408 TREE_VEC_ELT (condv
, i
) = cond
;
17409 TREE_VEC_ELT (incrv
, i
) = incr
;
17414 /* Helper function of tsubst_expr, find OMP_TEAMS inside
17415 of OMP_TARGET's body. */
17418 tsubst_find_omp_teams (tree
*tp
, int *walk_subtrees
, void *)
17420 *walk_subtrees
= 0;
17421 switch (TREE_CODE (*tp
))
17426 case STATEMENT_LIST
:
17427 *walk_subtrees
= 1;
17435 /* Helper function for tsubst_expr. For decomposition declaration
17436 artificial base DECL, which is tsubsted PATTERN_DECL, tsubst
17437 also the corresponding decls representing the identifiers
17438 of the decomposition declaration. Return DECL if successful
17439 or error_mark_node otherwise, set *FIRST to the first decl
17440 in the list chained through DECL_CHAIN and *CNT to the number
17444 tsubst_decomp_names (tree decl
, tree pattern_decl
, tree args
,
17445 tsubst_flags_t complain
, tree in_decl
, tree
*first
,
17448 tree decl2
, decl3
, prev
= decl
;
17450 gcc_assert (DECL_NAME (decl
) == NULL_TREE
);
17451 for (decl2
= DECL_CHAIN (pattern_decl
);
17454 && DECL_DECOMPOSITION_P (decl2
)
17455 && DECL_NAME (decl2
);
17456 decl2
= DECL_CHAIN (decl2
))
17458 if (TREE_TYPE (decl2
) == error_mark_node
&& *cnt
== 0)
17460 gcc_assert (errorcount
);
17461 return error_mark_node
;
17464 gcc_assert (DECL_DECOMP_BASE (decl2
) == pattern_decl
);
17465 gcc_assert (DECL_HAS_VALUE_EXPR_P (decl2
));
17466 tree v
= DECL_VALUE_EXPR (decl2
);
17467 DECL_HAS_VALUE_EXPR_P (decl2
) = 0;
17468 SET_DECL_VALUE_EXPR (decl2
, NULL_TREE
);
17469 decl3
= tsubst (decl2
, args
, complain
, in_decl
);
17470 SET_DECL_VALUE_EXPR (decl2
, v
);
17471 DECL_HAS_VALUE_EXPR_P (decl2
) = 1;
17473 DECL_TEMPLATE_INSTANTIATED (decl3
) = 1;
17476 gcc_assert (errorcount
);
17477 decl
= error_mark_node
;
17480 maybe_push_decl (decl3
);
17481 if (error_operand_p (decl3
))
17482 decl
= error_mark_node
;
17483 else if (decl
!= error_mark_node
17484 && DECL_CHAIN (decl3
) != prev
17487 gcc_assert (errorcount
);
17488 decl
= error_mark_node
;
17497 /* Return the proper local_specialization for init-capture pack DECL. */
17500 lookup_init_capture_pack (tree decl
)
17502 /* We handle normal pack captures by forwarding to the specialization of the
17503 captured parameter. We can't do that for pack init-captures; we need them
17504 to have their own local_specialization. We created the individual
17505 VAR_DECLs (if any) under build_capture_proxy, and we need to collect them
17506 when we process the DECL_EXPR for the pack init-capture in the template.
17507 So, how do we find them? We don't know the capture proxy pack when
17508 building the individual resulting proxies, and we don't know the
17509 individual proxies when instantiating the pack. What we have in common is
17512 So...when we instantiate the FIELD_DECL, we stick the result in
17513 local_specializations. Then at the DECL_EXPR we look up that result, see
17514 how many elements it has, synthesize the names, and look them up. */
17516 tree cname
= DECL_NAME (decl
);
17517 tree val
= DECL_VALUE_EXPR (decl
);
17518 tree field
= TREE_OPERAND (val
, 1);
17519 gcc_assert (TREE_CODE (field
) == FIELD_DECL
);
17520 tree fpack
= retrieve_local_specialization (field
);
17521 if (fpack
== error_mark_node
)
17522 return error_mark_node
;
17525 tree vec
= NULL_TREE
;
17526 tree r
= NULL_TREE
;
17527 if (TREE_CODE (fpack
) == TREE_VEC
)
17529 len
= TREE_VEC_LENGTH (fpack
);
17530 vec
= make_tree_vec (len
);
17531 r
= make_node (NONTYPE_ARGUMENT_PACK
);
17532 SET_ARGUMENT_PACK_ARGS (r
, vec
);
17534 for (int i
= 0; i
< len
; ++i
)
17536 tree ename
= vec
? make_ith_pack_parameter_name (cname
, i
) : cname
;
17537 tree elt
= lookup_name_real (ename
, 0, 0, true, 0, LOOKUP_NORMAL
);
17539 TREE_VEC_ELT (vec
, i
) = elt
;
17546 /* Like tsubst_copy for expressions, etc. but also does semantic
17550 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
17551 bool integral_constant_expression_p
)
17553 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
17554 #define RECUR(NODE) \
17555 tsubst_expr ((NODE), args, complain, in_decl, \
17556 integral_constant_expression_p)
17562 if (t
== NULL_TREE
|| t
== error_mark_node
)
17565 loc
= input_location
;
17566 if (location_t eloc
= cp_expr_location (t
))
17567 input_location
= eloc
;
17568 if (STATEMENT_CODE_P (TREE_CODE (t
)))
17569 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
17571 switch (TREE_CODE (t
))
17573 case STATEMENT_LIST
:
17575 tree_stmt_iterator i
;
17576 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
17577 RECUR (tsi_stmt (i
));
17581 case CTOR_INITIALIZER
:
17582 finish_mem_initializers (tsubst_initializer_list
17583 (TREE_OPERAND (t
, 0), args
));
17587 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
17591 tmp
= RECUR (EXPR_STMT_EXPR (t
));
17592 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
17593 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
17595 finish_expr_stmt (tmp
);
17599 finish_using_directive (USING_STMT_NAMESPACE (t
), /*attribs=*/NULL_TREE
);
17604 tree decl
, pattern_decl
;
17607 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
17608 if (TREE_CODE (decl
) == LABEL_DECL
)
17609 finish_label_decl (DECL_NAME (decl
));
17610 else if (TREE_CODE (decl
) == USING_DECL
)
17612 tree scope
= USING_DECL_SCOPE (decl
);
17613 tree name
= DECL_NAME (decl
);
17615 scope
= tsubst (scope
, args
, complain
, in_decl
);
17616 finish_nonmember_using_decl (scope
, name
);
17618 else if (is_capture_proxy (decl
)
17619 && !DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
17621 /* We're in tsubst_lambda_expr, we've already inserted a new
17622 capture proxy, so look it up and register it. */
17624 if (!DECL_PACK_P (decl
))
17626 inst
= lookup_name_real (DECL_NAME (decl
), /*prefer_type*/0,
17627 /*nonclass*/1, /*block_p=*/true,
17628 /*ns_only*/0, LOOKUP_HIDDEN
);
17629 gcc_assert (inst
!= decl
&& is_capture_proxy (inst
));
17631 else if (is_normal_capture_proxy (decl
))
17633 inst
= (retrieve_local_specialization
17634 (DECL_CAPTURED_VARIABLE (decl
)));
17635 gcc_assert (TREE_CODE (inst
) == NONTYPE_ARGUMENT_PACK
);
17638 inst
= lookup_init_capture_pack (decl
);
17640 register_local_specialization (inst
, decl
);
17643 else if (DECL_PRETTY_FUNCTION_P (decl
))
17644 decl
= make_fname_decl (DECL_SOURCE_LOCATION (decl
),
17646 true/*DECL_PRETTY_FUNCTION_P (decl)*/);
17647 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
17648 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
17649 /* Don't copy the old closure; we'll create a new one in
17650 tsubst_lambda_expr. */
17654 init
= DECL_INITIAL (decl
);
17655 /* The following tsubst call will clear the DECL_TEMPLATE_INFO
17656 for local variables, so save if DECL was declared constinit. */
17657 const bool constinit_p
17659 && DECL_LANG_SPECIFIC (decl
)
17660 && DECL_TEMPLATE_INFO (decl
)
17661 && TINFO_VAR_DECLARED_CONSTINIT (DECL_TEMPLATE_INFO (decl
)));
17662 decl
= tsubst (decl
, args
, complain
, in_decl
);
17663 if (decl
!= error_mark_node
)
17665 /* By marking the declaration as instantiated, we avoid
17666 trying to instantiate it. Since instantiate_decl can't
17667 handle local variables, and since we've already done
17668 all that needs to be done, that's the right thing to
17671 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
17672 if (VAR_P (decl
) && !DECL_NAME (decl
)
17673 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
17674 /* Anonymous aggregates are a special case. */
17675 finish_anon_union (decl
);
17676 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
17678 DECL_CONTEXT (decl
) = current_function_decl
;
17679 if (DECL_NAME (decl
) == this_identifier
)
17681 tree lam
= DECL_CONTEXT (current_function_decl
);
17682 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
17683 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
17685 insert_capture_proxy (decl
);
17687 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
17688 /* We already did a pushtag. */;
17689 else if (TREE_CODE (decl
) == FUNCTION_DECL
17690 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
17691 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
17693 DECL_CONTEXT (decl
) = NULL_TREE
;
17695 DECL_CONTEXT (decl
) = current_function_decl
;
17696 cp_check_omp_declare_reduction (decl
);
17700 bool const_init
= false;
17701 unsigned int cnt
= 0;
17702 tree first
= NULL_TREE
, ndecl
= error_mark_node
;
17703 maybe_push_decl (decl
);
17706 && DECL_DECOMPOSITION_P (decl
)
17707 && TREE_TYPE (pattern_decl
) != error_mark_node
)
17708 ndecl
= tsubst_decomp_names (decl
, pattern_decl
, args
,
17709 complain
, in_decl
, &first
,
17712 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
17715 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
17718 if (ndecl
!= error_mark_node
)
17719 cp_maybe_mangle_decomp (ndecl
, first
, cnt
);
17721 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
,
17722 constinit_p
? LOOKUP_CONSTINIT
: 0);
17724 if (ndecl
!= error_mark_node
)
17725 cp_finish_decomp (ndecl
, first
, cnt
);
17734 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
17735 RECUR (FOR_INIT_STMT (t
));
17736 finish_init_stmt (stmt
);
17737 tmp
= RECUR (FOR_COND (t
));
17738 finish_for_cond (tmp
, stmt
, false, 0);
17739 tmp
= RECUR (FOR_EXPR (t
));
17740 finish_for_expr (tmp
, stmt
);
17742 bool prev
= note_iteration_stmt_body_start ();
17743 RECUR (FOR_BODY (t
));
17744 note_iteration_stmt_body_end (prev
);
17746 finish_for_stmt (stmt
);
17749 case RANGE_FOR_STMT
:
17751 /* Construct another range_for, if this is not a final
17752 substitution (for inside inside a generic lambda of a
17753 template). Otherwise convert to a regular for. */
17755 stmt
= (processing_template_decl
17756 ? begin_range_for_stmt (NULL_TREE
, NULL_TREE
)
17757 : begin_for_stmt (NULL_TREE
, NULL_TREE
));
17758 RECUR (RANGE_FOR_INIT_STMT (t
));
17759 decl
= RANGE_FOR_DECL (t
);
17760 decl
= tsubst (decl
, args
, complain
, in_decl
);
17761 maybe_push_decl (decl
);
17762 expr
= RECUR (RANGE_FOR_EXPR (t
));
17764 tree decomp_first
= NULL_TREE
;
17765 unsigned decomp_cnt
= 0;
17766 if (VAR_P (decl
) && DECL_DECOMPOSITION_P (decl
))
17767 decl
= tsubst_decomp_names (decl
, RANGE_FOR_DECL (t
), args
,
17769 &decomp_first
, &decomp_cnt
);
17771 if (processing_template_decl
)
17773 RANGE_FOR_IVDEP (stmt
) = RANGE_FOR_IVDEP (t
);
17774 RANGE_FOR_UNROLL (stmt
) = RANGE_FOR_UNROLL (t
);
17775 finish_range_for_decl (stmt
, decl
, expr
);
17776 if (decomp_first
&& decl
!= error_mark_node
)
17777 cp_finish_decomp (decl
, decomp_first
, decomp_cnt
);
17781 unsigned short unroll
= (RANGE_FOR_UNROLL (t
)
17782 ? tree_to_uhwi (RANGE_FOR_UNROLL (t
)) : 0);
17783 stmt
= cp_convert_range_for (stmt
, decl
, expr
,
17784 decomp_first
, decomp_cnt
,
17785 RANGE_FOR_IVDEP (t
), unroll
);
17788 bool prev
= note_iteration_stmt_body_start ();
17789 RECUR (RANGE_FOR_BODY (t
));
17790 note_iteration_stmt_body_end (prev
);
17791 finish_for_stmt (stmt
);
17796 stmt
= begin_while_stmt ();
17797 tmp
= RECUR (WHILE_COND (t
));
17798 finish_while_stmt_cond (tmp
, stmt
, false, 0);
17800 bool prev
= note_iteration_stmt_body_start ();
17801 RECUR (WHILE_BODY (t
));
17802 note_iteration_stmt_body_end (prev
);
17804 finish_while_stmt (stmt
);
17808 stmt
= begin_do_stmt ();
17810 bool prev
= note_iteration_stmt_body_start ();
17811 RECUR (DO_BODY (t
));
17812 note_iteration_stmt_body_end (prev
);
17814 finish_do_body (stmt
);
17815 tmp
= RECUR (DO_COND (t
));
17816 finish_do_stmt (tmp
, stmt
, false, 0);
17820 stmt
= begin_if_stmt ();
17821 IF_STMT_CONSTEXPR_P (stmt
) = IF_STMT_CONSTEXPR_P (t
);
17822 if (IF_STMT_CONSTEXPR_P (t
))
17823 args
= add_extra_args (IF_STMT_EXTRA_ARGS (t
), args
);
17824 tmp
= RECUR (IF_COND (t
));
17825 tmp
= finish_if_stmt_cond (tmp
, stmt
);
17826 if (IF_STMT_CONSTEXPR_P (t
)
17827 && instantiation_dependent_expression_p (tmp
))
17829 /* We're partially instantiating a generic lambda, but the condition
17830 of the constexpr if is still dependent. Don't substitute into the
17831 branches now, just remember the template arguments. */
17832 do_poplevel (IF_SCOPE (stmt
));
17833 IF_COND (stmt
) = IF_COND (t
);
17834 THEN_CLAUSE (stmt
) = THEN_CLAUSE (t
);
17835 ELSE_CLAUSE (stmt
) = ELSE_CLAUSE (t
);
17836 IF_STMT_EXTRA_ARGS (stmt
) = build_extra_args (t
, args
, complain
);
17840 if (IF_STMT_CONSTEXPR_P (t
) && integer_zerop (tmp
))
17841 /* Don't instantiate the THEN_CLAUSE. */;
17844 tree folded
= fold_non_dependent_expr (tmp
, complain
);
17845 bool inhibit
= integer_zerop (folded
);
17847 ++c_inhibit_evaluation_warnings
;
17848 RECUR (THEN_CLAUSE (t
));
17850 --c_inhibit_evaluation_warnings
;
17852 finish_then_clause (stmt
);
17854 if (IF_STMT_CONSTEXPR_P (t
) && integer_nonzerop (tmp
))
17855 /* Don't instantiate the ELSE_CLAUSE. */;
17856 else if (ELSE_CLAUSE (t
))
17858 tree folded
= fold_non_dependent_expr (tmp
, complain
);
17859 bool inhibit
= integer_nonzerop (folded
);
17860 begin_else_clause (stmt
);
17862 ++c_inhibit_evaluation_warnings
;
17863 RECUR (ELSE_CLAUSE (t
));
17865 --c_inhibit_evaluation_warnings
;
17866 finish_else_clause (stmt
);
17869 finish_if_stmt (stmt
);
17873 if (BIND_EXPR_BODY_BLOCK (t
))
17874 stmt
= begin_function_body ();
17876 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
17877 ? BCS_TRY_BLOCK
: 0);
17879 RECUR (BIND_EXPR_BODY (t
));
17881 if (BIND_EXPR_BODY_BLOCK (t
))
17882 finish_function_body (stmt
);
17884 finish_compound_stmt (stmt
);
17888 finish_break_stmt ();
17891 case CONTINUE_STMT
:
17892 finish_continue_stmt ();
17896 stmt
= begin_switch_stmt ();
17897 tmp
= RECUR (SWITCH_STMT_COND (t
));
17898 finish_switch_cond (tmp
, stmt
);
17899 RECUR (SWITCH_STMT_BODY (t
));
17900 finish_switch_stmt (stmt
);
17903 case CASE_LABEL_EXPR
:
17905 tree decl
= CASE_LABEL (t
);
17906 tree low
= RECUR (CASE_LOW (t
));
17907 tree high
= RECUR (CASE_HIGH (t
));
17908 tree l
= finish_case_label (EXPR_LOCATION (t
), low
, high
);
17909 if (l
&& TREE_CODE (l
) == CASE_LABEL_EXPR
)
17911 tree label
= CASE_LABEL (l
);
17912 FALLTHROUGH_LABEL_P (label
) = FALLTHROUGH_LABEL_P (decl
);
17913 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
17914 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
17921 tree decl
= LABEL_EXPR_LABEL (t
);
17924 label
= finish_label_stmt (DECL_NAME (decl
));
17925 if (TREE_CODE (label
) == LABEL_DECL
)
17926 FALLTHROUGH_LABEL_P (label
) = FALLTHROUGH_LABEL_P (decl
);
17927 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
17928 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
17933 tmp
= GOTO_DESTINATION (t
);
17934 if (TREE_CODE (tmp
) != LABEL_DECL
)
17935 /* Computed goto's must be tsubst'd into. On the other hand,
17936 non-computed gotos must not be; the identifier in question
17937 will have no binding. */
17940 tmp
= DECL_NAME (tmp
);
17941 finish_goto_stmt (tmp
);
17946 tree string
= RECUR (ASM_STRING (t
));
17947 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
17948 complain
, in_decl
);
17949 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
17950 complain
, in_decl
);
17951 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
17952 complain
, in_decl
);
17953 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
17954 complain
, in_decl
);
17955 tmp
= finish_asm_stmt (EXPR_LOCATION (t
), ASM_VOLATILE_P (t
), string
,
17956 outputs
, inputs
, clobbers
, labels
,
17958 tree asm_expr
= tmp
;
17959 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
17960 asm_expr
= TREE_OPERAND (asm_expr
, 0);
17961 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
17968 stmt
= begin_try_block ();
17969 RECUR (TRY_STMTS (t
));
17970 finish_cleanup_try_block (stmt
);
17971 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
17975 tree compound_stmt
= NULL_TREE
;
17977 if (FN_TRY_BLOCK_P (t
))
17978 stmt
= begin_function_try_block (&compound_stmt
);
17980 stmt
= begin_try_block ();
17982 RECUR (TRY_STMTS (t
));
17984 if (FN_TRY_BLOCK_P (t
))
17985 finish_function_try_block (stmt
);
17987 finish_try_block (stmt
);
17989 RECUR (TRY_HANDLERS (t
));
17990 if (FN_TRY_BLOCK_P (t
))
17991 finish_function_handler_sequence (stmt
, compound_stmt
);
17993 finish_handler_sequence (stmt
);
17999 tree decl
= HANDLER_PARMS (t
);
18003 decl
= tsubst (decl
, args
, complain
, in_decl
);
18004 /* Prevent instantiate_decl from trying to instantiate
18005 this variable. We've already done all that needs to be
18007 if (decl
!= error_mark_node
)
18008 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
18010 stmt
= begin_handler ();
18011 finish_handler_parms (decl
, stmt
);
18012 RECUR (HANDLER_BODY (t
));
18013 finish_handler (stmt
);
18018 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
18019 if (CLASS_TYPE_P (tmp
))
18021 /* Local classes are not independent templates; they are
18022 instantiated along with their containing function. And this
18023 way we don't have to deal with pushing out of one local class
18024 to instantiate a member of another local class. */
18025 /* Closures are handled by the LAMBDA_EXPR. */
18026 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
18027 complete_type (tmp
);
18028 for (tree fld
= TYPE_FIELDS (tmp
); fld
; fld
= DECL_CHAIN (fld
))
18030 || (TREE_CODE (fld
) == FUNCTION_DECL
18031 && !DECL_ARTIFICIAL (fld
)))
18032 && DECL_TEMPLATE_INSTANTIATION (fld
))
18033 instantiate_decl (fld
, /*defer_ok=*/false,
18034 /*expl_inst_class=*/false);
18038 case STATIC_ASSERT
:
18042 ++c_inhibit_evaluation_warnings
;
18044 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
18047 /*integral_constant_expression_p=*/true);
18048 --c_inhibit_evaluation_warnings
;
18050 finish_static_assert (condition
,
18051 STATIC_ASSERT_MESSAGE (t
),
18052 STATIC_ASSERT_SOURCE_LOCATION (t
),
18053 /*member_p=*/false);
18058 case OACC_PARALLEL
:
18060 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_ACC
, args
, complain
,
18062 stmt
= begin_omp_parallel ();
18063 RECUR (OMP_BODY (t
));
18064 finish_omp_construct (TREE_CODE (t
), stmt
, tmp
);
18068 r
= push_omp_privatization_clauses (OMP_PARALLEL_COMBINED (t
));
18069 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), C_ORT_OMP
, args
,
18070 complain
, in_decl
);
18071 if (OMP_PARALLEL_COMBINED (t
))
18072 omp_parallel_combined_clauses
= &tmp
;
18073 stmt
= begin_omp_parallel ();
18074 RECUR (OMP_PARALLEL_BODY (t
));
18075 gcc_assert (omp_parallel_combined_clauses
== NULL
);
18076 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
18077 = OMP_PARALLEL_COMBINED (t
);
18078 pop_omp_privatization_clauses (r
);
18082 if (OMP_TASK_BODY (t
) == NULL_TREE
)
18084 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), C_ORT_OMP
, args
,
18085 complain
, in_decl
);
18087 OMP_TASK_CLAUSES (t
) = tmp
;
18091 r
= push_omp_privatization_clauses (false);
18092 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), C_ORT_OMP
, args
,
18093 complain
, in_decl
);
18094 stmt
= begin_omp_task ();
18095 RECUR (OMP_TASK_BODY (t
));
18096 finish_omp_task (tmp
, stmt
);
18097 pop_omp_privatization_clauses (r
);
18103 case OMP_DISTRIBUTE
:
18107 tree clauses
, body
, pre_body
;
18108 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
18109 tree orig_declv
= NULL_TREE
;
18110 tree incrv
= NULL_TREE
;
18111 enum c_omp_region_type ort
= C_ORT_OMP
;
18112 bool any_range_for
= false;
18115 if (TREE_CODE (t
) == OACC_LOOP
)
18118 r
= push_omp_privatization_clauses (OMP_FOR_INIT (t
) == NULL_TREE
);
18119 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), ort
, args
, complain
,
18121 if (OMP_FOR_INIT (t
) != NULL_TREE
)
18123 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
18124 if (OMP_FOR_ORIG_DECLS (t
))
18125 orig_declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
18126 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
18127 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
18128 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
18131 keep_next_level (true);
18132 stmt
= begin_omp_structured_block ();
18134 pre_body
= push_stmt_list ();
18135 RECUR (OMP_FOR_PRE_BODY (t
));
18136 pre_body
= pop_stmt_list (pre_body
);
18138 if (OMP_FOR_INIT (t
) != NULL_TREE
)
18139 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
18141 |= tsubst_omp_for_iterator (t
, i
, declv
, orig_declv
, initv
,
18142 condv
, incrv
, &clauses
, args
,
18144 integral_constant_expression_p
);
18145 omp_parallel_combined_clauses
= NULL
;
18149 gcc_assert (orig_declv
);
18150 body
= begin_omp_structured_block ();
18151 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
18152 if (TREE_VEC_ELT (orig_declv
, i
) != TREE_VEC_ELT (declv
, i
)
18153 && TREE_CODE (TREE_VEC_ELT (orig_declv
, i
)) == TREE_LIST
18154 && TREE_CHAIN (TREE_VEC_ELT (orig_declv
, i
)))
18155 cp_finish_omp_range_for (TREE_VEC_ELT (orig_declv
, i
),
18156 TREE_VEC_ELT (declv
, i
));
18159 body
= push_stmt_list ();
18160 RECUR (OMP_FOR_BODY (t
));
18162 body
= finish_omp_structured_block (body
);
18164 body
= pop_stmt_list (body
);
18166 if (OMP_FOR_INIT (t
) != NULL_TREE
)
18167 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
,
18168 orig_declv
, initv
, condv
, incrv
, body
, pre_body
,
18172 t
= make_node (TREE_CODE (t
));
18173 TREE_TYPE (t
) = void_type_node
;
18174 OMP_FOR_BODY (t
) = body
;
18175 OMP_FOR_PRE_BODY (t
) = pre_body
;
18176 OMP_FOR_CLAUSES (t
) = clauses
;
18177 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
18181 add_stmt (finish_omp_for_block (finish_omp_structured_block (stmt
),
18183 pop_omp_privatization_clauses (r
);
18188 omp_parallel_combined_clauses
= NULL
;
18193 case OMP_TASKGROUP
:
18195 r
= push_omp_privatization_clauses (TREE_CODE (t
) == OMP_TEAMS
18196 && OMP_TEAMS_COMBINED (t
));
18197 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_OMP
, args
, complain
,
18199 if (TREE_CODE (t
) == OMP_TEAMS
)
18201 keep_next_level (true);
18202 stmt
= begin_omp_structured_block ();
18203 RECUR (OMP_BODY (t
));
18204 stmt
= finish_omp_structured_block (stmt
);
18208 stmt
= push_stmt_list ();
18209 RECUR (OMP_BODY (t
));
18210 stmt
= pop_stmt_list (stmt
);
18214 OMP_BODY (t
) = stmt
;
18215 OMP_CLAUSES (t
) = tmp
;
18217 pop_omp_privatization_clauses (r
);
18221 r
= RECUR (OMP_DEPOBJ_DEPOBJ (t
));
18222 if (OMP_DEPOBJ_CLAUSES (t
) && OMP_DEPOBJ_CLAUSES (t
) != error_mark_node
)
18224 enum omp_clause_depend_kind kind
= OMP_CLAUSE_DEPEND_SOURCE
;
18225 if (TREE_CODE (OMP_DEPOBJ_CLAUSES (t
)) == OMP_CLAUSE
)
18227 tmp
= tsubst_omp_clauses (OMP_DEPOBJ_CLAUSES (t
), C_ORT_OMP
,
18228 args
, complain
, in_decl
);
18229 if (tmp
== NULL_TREE
)
18230 tmp
= error_mark_node
;
18234 kind
= (enum omp_clause_depend_kind
)
18235 tree_to_uhwi (OMP_DEPOBJ_CLAUSES (t
));
18238 finish_omp_depobj (EXPR_LOCATION (t
), r
, kind
, tmp
);
18241 finish_omp_depobj (EXPR_LOCATION (t
), r
,
18242 OMP_CLAUSE_DEPEND_SOURCE
,
18243 OMP_DEPOBJ_CLAUSES (t
));
18247 case OMP_TARGET_DATA
:
18249 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), (TREE_CODE (t
) == OACC_DATA
)
18250 ? C_ORT_ACC
: C_ORT_OMP
, args
, complain
,
18252 keep_next_level (true);
18253 stmt
= begin_omp_structured_block ();
18255 RECUR (OMP_BODY (t
));
18256 stmt
= finish_omp_structured_block (stmt
);
18259 OMP_BODY (t
) = stmt
;
18260 OMP_CLAUSES (t
) = tmp
;
18261 if (TREE_CODE (t
) == OMP_TARGET
&& OMP_TARGET_COMBINED (t
))
18263 tree teams
= cp_walk_tree (&stmt
, tsubst_find_omp_teams
, NULL
, NULL
);
18266 /* For combined target teams, ensure the num_teams and
18267 thread_limit clause expressions are evaluated on the host,
18268 before entering the target construct. */
18270 for (c
= OMP_TEAMS_CLAUSES (teams
);
18271 c
; c
= OMP_CLAUSE_CHAIN (c
))
18272 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
18273 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
18274 && TREE_CODE (OMP_CLAUSE_OPERAND (c
, 0)) != INTEGER_CST
)
18276 tree expr
= OMP_CLAUSE_OPERAND (c
, 0);
18277 expr
= force_target_expr (TREE_TYPE (expr
), expr
, tf_none
);
18278 if (expr
== error_mark_node
)
18280 tmp
= TARGET_EXPR_SLOT (expr
);
18282 OMP_CLAUSE_OPERAND (c
, 0) = expr
;
18283 tree tc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
18284 OMP_CLAUSE_FIRSTPRIVATE
);
18285 OMP_CLAUSE_DECL (tc
) = tmp
;
18286 OMP_CLAUSE_CHAIN (tc
) = OMP_TARGET_CLAUSES (t
);
18287 OMP_TARGET_CLAUSES (t
) = tc
;
18296 tmp
= tsubst_omp_clauses (OACC_DECLARE_CLAUSES (t
), C_ORT_ACC
, args
,
18297 complain
, in_decl
);
18298 OACC_DECLARE_CLAUSES (t
) = tmp
;
18302 case OMP_TARGET_UPDATE
:
18303 case OMP_TARGET_ENTER_DATA
:
18304 case OMP_TARGET_EXIT_DATA
:
18305 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_OMP
, args
,
18306 complain
, in_decl
);
18308 OMP_STANDALONE_CLAUSES (t
) = tmp
;
18312 case OACC_ENTER_DATA
:
18313 case OACC_EXIT_DATA
:
18315 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_ACC
, args
,
18316 complain
, in_decl
);
18318 OMP_STANDALONE_CLAUSES (t
) = tmp
;
18323 tmp
= tsubst_omp_clauses (OMP_ORDERED_CLAUSES (t
), C_ORT_OMP
, args
,
18324 complain
, in_decl
);
18325 stmt
= push_stmt_list ();
18326 RECUR (OMP_BODY (t
));
18327 stmt
= pop_stmt_list (stmt
);
18330 OMP_BODY (t
) = stmt
;
18331 OMP_ORDERED_CLAUSES (t
) = tmp
;
18337 stmt
= push_stmt_list ();
18338 RECUR (OMP_BODY (t
));
18339 stmt
= pop_stmt_list (stmt
);
18342 OMP_BODY (t
) = stmt
;
18347 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
18349 if (TREE_CODE (TREE_OPERAND (t
, 0)) == OMP_CLAUSE
)
18350 tmp
= tsubst_omp_clauses (TREE_OPERAND (t
, 0), C_ORT_OMP
, args
,
18351 complain
, in_decl
);
18352 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
18354 tree op1
= TREE_OPERAND (t
, 1);
18355 tree rhs1
= NULL_TREE
;
18357 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
18359 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
18360 op1
= TREE_OPERAND (op1
, 1);
18362 lhs
= RECUR (TREE_OPERAND (op1
, 0));
18363 rhs
= RECUR (TREE_OPERAND (op1
, 1));
18364 finish_omp_atomic (EXPR_LOCATION (t
), OMP_ATOMIC
, TREE_CODE (op1
),
18365 lhs
, rhs
, NULL_TREE
, NULL_TREE
, rhs1
, tmp
,
18366 OMP_ATOMIC_MEMORY_ORDER (t
));
18370 tree op1
= TREE_OPERAND (t
, 1);
18371 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
18372 tree rhs1
= NULL_TREE
;
18373 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
18374 enum tree_code opcode
= NOP_EXPR
;
18375 if (code
== OMP_ATOMIC_READ
)
18377 v
= RECUR (TREE_OPERAND (op1
, 0));
18378 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
18380 else if (code
== OMP_ATOMIC_CAPTURE_OLD
18381 || code
== OMP_ATOMIC_CAPTURE_NEW
)
18383 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
18384 v
= RECUR (TREE_OPERAND (op1
, 0));
18385 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
18386 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
18388 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
18389 op11
= TREE_OPERAND (op11
, 1);
18391 lhs
= RECUR (TREE_OPERAND (op11
, 0));
18392 rhs
= RECUR (TREE_OPERAND (op11
, 1));
18393 opcode
= TREE_CODE (op11
);
18394 if (opcode
== MODIFY_EXPR
)
18400 lhs
= RECUR (TREE_OPERAND (op1
, 0));
18401 rhs
= RECUR (TREE_OPERAND (op1
, 1));
18403 finish_omp_atomic (EXPR_LOCATION (t
), code
, opcode
, lhs
, rhs
, v
,
18404 lhs1
, rhs1
, tmp
, OMP_ATOMIC_MEMORY_ORDER (t
));
18408 case TRANSACTION_EXPR
:
18411 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
18412 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
18414 if (TRANSACTION_EXPR_IS_STMT (t
))
18416 tree body
= TRANSACTION_EXPR_BODY (t
);
18417 tree noex
= NULL_TREE
;
18418 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
18420 noex
= MUST_NOT_THROW_COND (body
);
18421 if (noex
== NULL_TREE
)
18422 noex
= boolean_true_node
;
18423 body
= TREE_OPERAND (body
, 0);
18425 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
18427 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
18431 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
18432 RECUR (TRANSACTION_EXPR_BODY (t
)),
18439 case MUST_NOT_THROW_EXPR
:
18441 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18442 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
18443 RETURN (build_must_not_throw_expr (op0
, cond
));
18446 case EXPR_PACK_EXPANSION
:
18447 error ("invalid use of pack expansion expression");
18448 RETURN (error_mark_node
);
18450 case NONTYPE_ARGUMENT_PACK
:
18451 error ("use %<...%> to expand argument pack");
18452 RETURN (error_mark_node
);
18454 case COMPOUND_EXPR
:
18455 tmp
= RECUR (TREE_OPERAND (t
, 0));
18456 if (tmp
== NULL_TREE
)
18457 /* If the first operand was a statement, we're done with it. */
18458 RETURN (RECUR (TREE_OPERAND (t
, 1)));
18459 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
18460 RECUR (TREE_OPERAND (t
, 1)),
18463 case ANNOTATE_EXPR
:
18464 tmp
= RECUR (TREE_OPERAND (t
, 0));
18465 RETURN (build3_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
18466 TREE_TYPE (tmp
), tmp
,
18467 RECUR (TREE_OPERAND (t
, 1)),
18468 RECUR (TREE_OPERAND (t
, 2))));
18471 RETURN (add_stmt (copy_node (t
)));
18474 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
18476 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
18477 /*function_p=*/false,
18478 integral_constant_expression_p
));
18481 RETURN (NULL_TREE
);
18483 input_location
= loc
;
18489 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
18490 function. For description of the body see comment above
18491 cp_parser_omp_declare_reduction_exprs. */
18494 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
18496 if (t
== NULL_TREE
|| t
== error_mark_node
)
18499 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
18501 tree_stmt_iterator tsi
;
18504 memset (stmts
, 0, sizeof stmts
);
18505 for (i
= 0, tsi
= tsi_start (t
);
18506 i
< 7 && !tsi_end_p (tsi
);
18507 i
++, tsi_next (&tsi
))
18508 stmts
[i
] = tsi_stmt (tsi
);
18509 gcc_assert (tsi_end_p (tsi
));
18513 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
18514 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
18515 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
18516 args
, complain
, in_decl
);
18517 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
18518 args
, complain
, in_decl
);
18519 DECL_CONTEXT (omp_out
) = current_function_decl
;
18520 DECL_CONTEXT (omp_in
) = current_function_decl
;
18521 keep_next_level (true);
18522 tree block
= begin_omp_structured_block ();
18523 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
18524 block
= finish_omp_structured_block (block
);
18525 block
= maybe_cleanup_point_expr_void (block
);
18526 add_decl_expr (omp_out
);
18527 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
18528 TREE_NO_WARNING (omp_out
) = 1;
18529 add_decl_expr (omp_in
);
18530 finish_expr_stmt (block
);
18534 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
18535 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
18536 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
18537 args
, complain
, in_decl
);
18538 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
18539 args
, complain
, in_decl
);
18540 DECL_CONTEXT (omp_priv
) = current_function_decl
;
18541 DECL_CONTEXT (omp_orig
) = current_function_decl
;
18542 keep_next_level (true);
18543 tree block
= begin_omp_structured_block ();
18544 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
18545 block
= finish_omp_structured_block (block
);
18546 block
= maybe_cleanup_point_expr_void (block
);
18547 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
18548 add_decl_expr (omp_priv
);
18549 add_decl_expr (omp_orig
);
18550 finish_expr_stmt (block
);
18552 add_decl_expr (omp_orig
);
18556 /* T is a postfix-expression that is not being used in a function
18557 call. Return the substituted version of T. */
18560 tsubst_non_call_postfix_expression (tree t
, tree args
,
18561 tsubst_flags_t complain
,
18564 if (TREE_CODE (t
) == SCOPE_REF
)
18565 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
18566 /*done=*/false, /*address_p=*/false);
18568 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
18569 /*function_p=*/false,
18570 /*integral_constant_expression_p=*/false);
18575 /* Subroutine of tsubst_lambda_expr: add the FIELD/INIT capture pair to the
18576 LAMBDA_EXPR_CAPTURE_LIST passed in LIST. Do deduction for a previously
18577 dependent init-capture. */
18580 prepend_one_capture (tree field
, tree init
, tree
&list
,
18581 tsubst_flags_t complain
)
18583 if (tree auto_node
= type_uses_auto (TREE_TYPE (field
)))
18585 tree type
= NULL_TREE
;
18588 if (complain
& tf_error
)
18589 error ("empty initializer in lambda init-capture");
18590 init
= error_mark_node
;
18592 else if (TREE_CODE (init
) == TREE_LIST
)
18593 init
= build_x_compound_expr_from_list (init
, ELK_INIT
, complain
);
18595 type
= do_auto_deduction (TREE_TYPE (field
), init
, auto_node
, complain
);
18596 TREE_TYPE (field
) = type
;
18597 cp_apply_type_quals_to_decl (cp_type_quals (type
), field
);
18599 list
= tree_cons (field
, init
, list
);
18602 /* T is a LAMBDA_EXPR. Generate a new LAMBDA_EXPR for the current
18603 instantiation context. Instantiating a pack expansion containing a lambda
18604 might result in multiple lambdas all based on the same lambda in the
18608 tsubst_lambda_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
18610 tree oldfn
= lambda_function (t
);
18613 tree r
= build_lambda_expr ();
18615 LAMBDA_EXPR_LOCATION (r
)
18616 = LAMBDA_EXPR_LOCATION (t
);
18617 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
18618 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
18619 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
18620 LAMBDA_EXPR_INSTANTIATED (r
) = true;
18622 if (LAMBDA_EXPR_EXTRA_SCOPE (t
) == NULL_TREE
)
18623 /* A lambda in a default argument outside a class gets no
18624 LAMBDA_EXPR_EXTRA_SCOPE, as specified by the ABI. But
18625 tsubst_default_argument calls start_lambda_scope, so we need to
18626 specifically ignore it here, and use the global scope. */
18627 record_null_lambda_scope (r
);
18629 record_lambda_scope (r
);
18631 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
18632 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
18634 vec
<tree
,va_gc
>* field_packs
= NULL
;
18636 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
); cap
;
18637 cap
= TREE_CHAIN (cap
))
18639 tree ofield
= TREE_PURPOSE (cap
);
18640 if (PACK_EXPANSION_P (ofield
))
18641 ofield
= PACK_EXPANSION_PATTERN (ofield
);
18642 tree field
= tsubst_decl (ofield
, args
, complain
);
18644 if (DECL_PACK_P (ofield
) && !DECL_NORMAL_CAPTURE_P (ofield
))
18646 /* Remember these for when we've pushed local_specializations. */
18647 vec_safe_push (field_packs
, ofield
);
18648 vec_safe_push (field_packs
, field
);
18651 if (field
== error_mark_node
)
18652 return error_mark_node
;
18654 tree init
= TREE_VALUE (cap
);
18655 if (PACK_EXPANSION_P (init
))
18656 init
= tsubst_pack_expansion (init
, args
, complain
, in_decl
);
18658 init
= tsubst_copy_and_build (init
, args
, complain
, in_decl
,
18659 /*fn*/false, /*constexpr*/false);
18661 if (TREE_CODE (field
) == TREE_VEC
)
18663 int len
= TREE_VEC_LENGTH (field
);
18664 gcc_assert (TREE_CODE (init
) == TREE_VEC
18665 && TREE_VEC_LENGTH (init
) == len
);
18666 for (int i
= 0; i
< len
; ++i
)
18667 prepend_one_capture (TREE_VEC_ELT (field
, i
),
18668 TREE_VEC_ELT (init
, i
),
18669 LAMBDA_EXPR_CAPTURE_LIST (r
),
18674 prepend_one_capture (field
, init
, LAMBDA_EXPR_CAPTURE_LIST (r
),
18677 if (id_equal (DECL_NAME (field
), "__this"))
18678 LAMBDA_EXPR_THIS_CAPTURE (r
) = field
;
18682 tree type
= begin_lambda_type (r
);
18683 if (type
== error_mark_node
)
18684 return error_mark_node
;
18686 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
18687 determine_visibility (TYPE_NAME (type
));
18689 register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (r
));
18691 tree oldtmpl
= (generic_lambda_fn_p (oldfn
)
18692 ? DECL_TI_TEMPLATE (oldfn
)
18695 tree fntype
= static_fn_type (oldfn
);
18697 ++processing_template_decl
;
18698 fntype
= tsubst (fntype
, args
, complain
, in_decl
);
18700 --processing_template_decl
;
18702 if (fntype
== error_mark_node
)
18703 r
= error_mark_node
;
18706 /* The body of a lambda-expression is not a subexpression of the
18707 enclosing expression. Parms are to have DECL_CHAIN tsubsted,
18708 which would be skipped if cp_unevaluated_operand. */
18711 /* Fix the type of 'this'. */
18712 fntype
= build_memfn_type (fntype
, type
,
18713 type_memfn_quals (fntype
),
18714 type_memfn_rqual (fntype
));
18718 tmpl
= tsubst_template_decl (oldtmpl
, args
, complain
, fntype
);
18719 fn
= DECL_TEMPLATE_RESULT (tmpl
);
18720 finish_member_declaration (tmpl
);
18725 fn
= tsubst_function_decl (oldfn
, args
, complain
, fntype
);
18726 finish_member_declaration (fn
);
18729 /* Let finish_function set this. */
18730 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
18732 bool nested
= cfun
;
18734 push_function_context ();
18736 /* Still increment function_depth so that we don't GC in the
18737 middle of an expression. */
18740 local_specialization_stack
s (lss_copy
);
18742 tree body
= start_lambda_function (fn
, r
);
18744 /* Now record them for lookup_init_capture_pack. */
18745 int fplen
= vec_safe_length (field_packs
);
18746 for (int i
= 0; i
< fplen
; )
18748 tree pack
= (*field_packs
)[i
++];
18749 tree inst
= (*field_packs
)[i
++];
18750 register_local_specialization (inst
, pack
);
18752 release_tree_vector (field_packs
);
18754 register_parameter_specializations (oldfn
, fn
);
18758 /* We might not partially instantiate some parts of the function, so
18759 copy these flags from the original template. */
18760 language_function
*ol
= DECL_STRUCT_FUNCTION (oldfn
)->language
;
18761 current_function_returns_value
= ol
->returns_value
;
18762 current_function_returns_null
= ol
->returns_null
;
18763 current_function_returns_abnormally
= ol
->returns_abnormally
;
18764 current_function_infinite_loop
= ol
->infinite_loop
;
18767 /* [temp.deduct] A lambda-expression appearing in a function type or a
18768 template parameter is not considered part of the immediate context for
18769 the purposes of template argument deduction. */
18770 complain
= tf_warning_or_error
;
18772 tsubst_expr (DECL_SAVED_TREE (oldfn
), args
, complain
, r
,
18773 /*constexpr*/false);
18775 finish_lambda_function (body
);
18778 pop_function_context ();
18782 /* The capture list was built up in reverse order; fix that now. */
18783 LAMBDA_EXPR_CAPTURE_LIST (r
)
18784 = nreverse (LAMBDA_EXPR_CAPTURE_LIST (r
));
18786 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
18788 maybe_add_lambda_conv_op (type
);
18791 finish_struct (type
, /*attr*/NULL_TREE
);
18793 insert_pending_capture_proxies ();
18798 /* Like tsubst but deals with expressions and performs semantic
18799 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
18802 tsubst_copy_and_build (tree t
,
18804 tsubst_flags_t complain
,
18807 bool integral_constant_expression_p
)
18809 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
18810 #define RECUR(NODE) \
18811 tsubst_copy_and_build (NODE, args, complain, in_decl, \
18812 /*function_p=*/false, \
18813 integral_constant_expression_p)
18818 if (t
== NULL_TREE
|| t
== error_mark_node
)
18821 loc
= input_location
;
18822 if (location_t eloc
= cp_expr_location (t
))
18823 input_location
= eloc
;
18825 /* N3276 decltype magic only applies to calls at the top level or on the
18826 right side of a comma. */
18827 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
18828 complain
&= ~tf_decltype
;
18830 switch (TREE_CODE (t
))
18834 /* Fall through. */
18835 case IDENTIFIER_NODE
:
18839 bool non_integral_constant_expression_p
;
18840 const char *error_msg
;
18842 if (IDENTIFIER_CONV_OP_P (t
))
18844 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18845 t
= make_conv_op_name (new_type
);
18848 /* Look up the name. */
18849 decl
= lookup_name (t
);
18851 /* By convention, expressions use ERROR_MARK_NODE to indicate
18852 failure, not NULL_TREE. */
18853 if (decl
== NULL_TREE
)
18854 decl
= error_mark_node
;
18856 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
18858 integral_constant_expression_p
,
18859 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
18860 &non_integral_constant_expression_p
,
18861 /*template_p=*/false,
18863 /*address_p=*/false,
18864 /*template_arg_p=*/false,
18869 if (!function_p
&& identifier_p (decl
))
18871 if (complain
& tf_error
)
18872 unqualified_name_lookup_error (decl
);
18873 decl
= error_mark_node
;
18878 case TEMPLATE_ID_EXPR
:
18881 tree templ
= RECUR (TREE_OPERAND (t
, 0));
18882 tree targs
= TREE_OPERAND (t
, 1);
18885 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
18886 if (targs
== error_mark_node
)
18887 RETURN (error_mark_node
);
18889 if (TREE_CODE (templ
) == SCOPE_REF
)
18891 tree name
= TREE_OPERAND (templ
, 1);
18892 tree tid
= lookup_template_function (name
, targs
);
18893 TREE_OPERAND (templ
, 1) = tid
;
18897 if (concept_definition_p (templ
))
18899 tree check
= build_concept_check (templ
, targs
, complain
);
18900 if (check
== error_mark_node
)
18901 RETURN (error_mark_node
);
18903 tree id
= unpack_concept_check (check
);
18905 /* If we built a function concept check, return the underlying
18906 template-id. So we can evaluate it as a function call. */
18907 if (function_concept_p (TREE_OPERAND (id
, 0)))
18913 if (variable_template_p (templ
))
18915 tree r
= lookup_and_finish_template_variable (templ
, targs
,
18917 r
= maybe_wrap_with_location (r
, EXPR_LOCATION (t
));
18921 if (TREE_CODE (templ
) == COMPONENT_REF
)
18923 object
= TREE_OPERAND (templ
, 0);
18924 templ
= TREE_OPERAND (templ
, 1);
18927 object
= NULL_TREE
;
18928 templ
= lookup_template_function (templ
, targs
);
18931 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
18932 object
, templ
, NULL_TREE
));
18934 RETURN (baselink_for_fns (templ
));
18939 tree r
= RECUR (TREE_OPERAND (t
, 0));
18941 if (REFERENCE_REF_P (t
))
18943 /* A type conversion to reference type will be enclosed in
18944 such an indirect ref, but the substitution of the cast
18945 will have also added such an indirect ref. */
18946 r
= convert_from_reference (r
);
18949 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
18950 complain
|decltype_flag
);
18952 if (REF_PARENTHESIZED_P (t
))
18953 r
= force_paren_expr (r
);
18960 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18961 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18962 RETURN (build_nop (type
, op0
));
18965 case IMPLICIT_CONV_EXPR
:
18967 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18968 tree expr
= RECUR (TREE_OPERAND (t
, 0));
18969 if (dependent_type_p (type
) || type_dependent_expression_p (expr
))
18971 retval
= copy_node (t
);
18972 TREE_TYPE (retval
) = type
;
18973 TREE_OPERAND (retval
, 0) = expr
;
18976 if (IMPLICIT_CONV_EXPR_NONTYPE_ARG (t
))
18977 /* We'll pass this to convert_nontype_argument again, we don't need
18978 to actually perform any conversion here. */
18980 int flags
= LOOKUP_IMPLICIT
;
18981 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
18982 flags
= LOOKUP_NORMAL
;
18983 if (IMPLICIT_CONV_EXPR_BRACED_INIT (t
))
18984 flags
|= LOOKUP_NO_NARROWING
;
18985 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
18991 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18992 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18993 if (op0
== error_mark_node
)
18994 RETURN (error_mark_node
);
18995 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
18999 case REINTERPRET_CAST_EXPR
:
19000 case CONST_CAST_EXPR
:
19001 case DYNAMIC_CAST_EXPR
:
19002 case STATIC_CAST_EXPR
:
19005 tree op
, r
= NULL_TREE
;
19007 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
19008 if (integral_constant_expression_p
19009 && !cast_valid_in_integral_constant_expression_p (type
))
19011 if (complain
& tf_error
)
19012 error ("a cast to a type other than an integral or "
19013 "enumeration type cannot appear in a constant-expression");
19014 RETURN (error_mark_node
);
19017 op
= RECUR (TREE_OPERAND (t
, 0));
19019 warning_sentinel
s(warn_useless_cast
);
19020 warning_sentinel
s2(warn_ignored_qualifiers
);
19021 switch (TREE_CODE (t
))
19024 r
= build_functional_cast (input_location
, type
, op
, complain
);
19026 case REINTERPRET_CAST_EXPR
:
19027 r
= build_reinterpret_cast (input_location
, type
, op
, complain
);
19029 case CONST_CAST_EXPR
:
19030 r
= build_const_cast (input_location
, type
, op
, complain
);
19032 case DYNAMIC_CAST_EXPR
:
19033 r
= build_dynamic_cast (input_location
, type
, op
, complain
);
19035 case STATIC_CAST_EXPR
:
19036 r
= build_static_cast (input_location
, type
, op
, complain
);
19039 gcc_unreachable ();
19045 case POSTDECREMENT_EXPR
:
19046 case POSTINCREMENT_EXPR
:
19047 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
19048 args
, complain
, in_decl
);
19049 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
19050 complain
|decltype_flag
));
19052 case PREDECREMENT_EXPR
:
19053 case PREINCREMENT_EXPR
:
19057 case TRUTH_NOT_EXPR
:
19058 case UNARY_PLUS_EXPR
: /* Unary + */
19059 case REALPART_EXPR
:
19060 case IMAGPART_EXPR
:
19061 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
19062 RECUR (TREE_OPERAND (t
, 0)),
19063 complain
|decltype_flag
));
19065 case FIX_TRUNC_EXPR
:
19066 gcc_unreachable ();
19069 op1
= TREE_OPERAND (t
, 0);
19070 if (TREE_CODE (op1
) == LABEL_DECL
)
19071 RETURN (finish_label_address_expr (DECL_NAME (op1
),
19072 EXPR_LOCATION (op1
)));
19073 if (TREE_CODE (op1
) == SCOPE_REF
)
19074 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
19075 /*done=*/true, /*address_p=*/true);
19077 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
19079 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
19080 complain
|decltype_flag
));
19085 case TRUNC_DIV_EXPR
:
19086 case CEIL_DIV_EXPR
:
19087 case FLOOR_DIV_EXPR
:
19088 case ROUND_DIV_EXPR
:
19089 case EXACT_DIV_EXPR
:
19093 case TRUNC_MOD_EXPR
:
19094 case FLOOR_MOD_EXPR
:
19095 case TRUTH_ANDIF_EXPR
:
19096 case TRUTH_ORIF_EXPR
:
19097 case TRUTH_AND_EXPR
:
19098 case TRUTH_OR_EXPR
:
19109 case SPACESHIP_EXPR
:
19113 warning_sentinel
s1(warn_type_limits
);
19114 warning_sentinel
s2(warn_div_by_zero
);
19115 warning_sentinel
s3(warn_logical_op
);
19116 warning_sentinel
s4(warn_tautological_compare
);
19117 tree op0
= RECUR (TREE_OPERAND (t
, 0));
19118 tree op1
= RECUR (TREE_OPERAND (t
, 1));
19119 tree r
= build_x_binary_op
19120 (input_location
, TREE_CODE (t
),
19122 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
19124 : TREE_CODE (TREE_OPERAND (t
, 0))),
19126 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
19128 : TREE_CODE (TREE_OPERAND (t
, 1))),
19130 complain
|decltype_flag
);
19131 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
19132 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
19137 case POINTER_PLUS_EXPR
:
19139 tree op0
= RECUR (TREE_OPERAND (t
, 0));
19140 tree op1
= RECUR (TREE_OPERAND (t
, 1));
19141 RETURN (fold_build_pointer_plus (op0
, op1
));
19145 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
19146 /*address_p=*/false));
19148 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
19149 args
, complain
, in_decl
);
19150 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
19151 RECUR (TREE_OPERAND (t
, 1)),
19152 complain
|decltype_flag
));
19155 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
19156 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
19157 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
19164 op1
= TREE_OPERAND (t
, 0);
19165 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
19166 op1
= TREE_TYPE (op1
);
19167 bool std_alignof
= (TREE_CODE (t
) == ALIGNOF_EXPR
19168 && ALIGNOF_EXPR_STD_P (t
));
19171 /* When there are no ARGS, we are trying to evaluate a
19172 non-dependent expression from the parser. Trying to do
19173 the substitutions may not work. */
19175 op1
= TREE_TYPE (op1
);
19179 ++cp_unevaluated_operand
;
19180 ++c_inhibit_evaluation_warnings
;
19182 op1
= tsubst (op1
, args
, complain
, in_decl
);
19184 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
19185 /*function_p=*/false,
19186 /*integral_constant_expression_p=*/
19188 --cp_unevaluated_operand
;
19189 --c_inhibit_evaluation_warnings
;
19192 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
), std_alignof
,
19193 complain
& tf_error
);
19195 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
19196 complain
& tf_error
);
19197 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
19199 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
19201 if (!processing_template_decl
&& TYPE_P (op1
))
19203 r
= build_min (SIZEOF_EXPR
, size_type_node
,
19204 build1 (NOP_EXPR
, op1
, error_mark_node
));
19205 SIZEOF_EXPR_TYPE_P (r
) = 1;
19208 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
19209 TREE_SIDE_EFFECTS (r
) = 0;
19210 TREE_READONLY (r
) = 1;
19212 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
19217 case AT_ENCODE_EXPR
:
19219 op1
= TREE_OPERAND (t
, 0);
19220 ++cp_unevaluated_operand
;
19221 ++c_inhibit_evaluation_warnings
;
19222 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
19223 /*function_p=*/false,
19224 /*integral_constant_expression_p=*/false);
19225 --cp_unevaluated_operand
;
19226 --c_inhibit_evaluation_warnings
;
19227 RETURN (objc_build_encode_expr (op1
));
19230 case NOEXCEPT_EXPR
:
19231 op1
= TREE_OPERAND (t
, 0);
19232 ++cp_unevaluated_operand
;
19233 ++c_inhibit_evaluation_warnings
;
19234 ++cp_noexcept_operand
;
19235 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
19236 /*function_p=*/false,
19237 /*integral_constant_expression_p=*/false);
19238 --cp_unevaluated_operand
;
19239 --c_inhibit_evaluation_warnings
;
19240 --cp_noexcept_operand
;
19241 RETURN (finish_noexcept_expr (op1
, complain
));
19245 warning_sentinel
s(warn_div_by_zero
);
19246 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
19247 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
19248 tree r
= build_x_modify_expr
19249 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
19250 complain
|decltype_flag
);
19251 /* TREE_NO_WARNING must be set if either the expression was
19252 parenthesized or it uses an operator such as >>= rather
19253 than plain assignment. In the former case, it was already
19254 set and must be copied. In the latter case,
19255 build_x_modify_expr sets it and it must not be reset
19257 if (TREE_NO_WARNING (t
))
19258 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
19264 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
19265 args
, complain
, in_decl
);
19266 /* Remember that there was a reference to this entity. */
19268 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
19269 RETURN (error_mark_node
);
19270 RETURN (build_x_arrow (input_location
, op1
, complain
));
19274 tree placement
= RECUR (TREE_OPERAND (t
, 0));
19275 tree init
= RECUR (TREE_OPERAND (t
, 3));
19276 vec
<tree
, va_gc
> *placement_vec
;
19277 vec
<tree
, va_gc
> *init_vec
;
19280 if (placement
== NULL_TREE
)
19281 placement_vec
= NULL
;
19284 placement_vec
= make_tree_vector ();
19285 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
19286 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
19289 /* If there was an initializer in the original tree, but it
19290 instantiated to an empty list, then we should pass a
19291 non-NULL empty vector to tell build_new that it was an
19292 empty initializer() rather than no initializer. This can
19293 only happen when the initializer is a pack expansion whose
19294 parameter packs are of length zero. */
19295 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
19299 init_vec
= make_tree_vector ();
19300 if (init
== void_node
)
19301 gcc_assert (init_vec
!= NULL
);
19304 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
19305 vec_safe_push (init_vec
, TREE_VALUE (init
));
19309 /* Avoid passing an enclosing decl to valid_array_size_p. */
19310 in_decl
= NULL_TREE
;
19312 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
19313 tree op2
= RECUR (TREE_OPERAND (t
, 2));
19314 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
19315 NEW_EXPR_USE_GLOBAL (t
),
19318 if (placement_vec
!= NULL
)
19319 release_tree_vector (placement_vec
);
19320 if (init_vec
!= NULL
)
19321 release_tree_vector (init_vec
);
19328 tree op0
= RECUR (TREE_OPERAND (t
, 0));
19329 tree op1
= RECUR (TREE_OPERAND (t
, 1));
19330 RETURN (delete_sanity (op0
, op1
,
19331 DELETE_EXPR_USE_VEC (t
),
19332 DELETE_EXPR_USE_GLOBAL (t
),
19336 case COMPOUND_EXPR
:
19338 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
19339 complain
& ~tf_decltype
, in_decl
,
19340 /*function_p=*/false,
19341 integral_constant_expression_p
);
19342 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
19344 RECUR (TREE_OPERAND (t
, 1)),
19345 complain
|decltype_flag
));
19351 unsigned int nargs
, i
;
19356 function
= CALL_EXPR_FN (t
);
19357 /* Internal function with no arguments. */
19358 if (function
== NULL_TREE
&& call_expr_nargs (t
) == 0)
19361 /* When we parsed the expression, we determined whether or
19362 not Koenig lookup should be performed. */
19363 koenig_p
= KOENIG_LOOKUP_P (t
);
19364 if (function
== NULL_TREE
)
19367 qualified_p
= false;
19369 else if (TREE_CODE (function
) == SCOPE_REF
)
19371 qualified_p
= true;
19372 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
19374 /*address_p=*/false);
19376 else if (koenig_p
&& identifier_p (function
))
19378 /* Do nothing; calling tsubst_copy_and_build on an identifier
19379 would incorrectly perform unqualified lookup again.
19381 Note that we can also have an IDENTIFIER_NODE if the earlier
19382 unqualified lookup found a member function; in that case
19383 koenig_p will be false and we do want to do the lookup
19384 again to find the instantiated member function.
19386 FIXME but doing that causes c++/15272, so we need to stop
19387 using IDENTIFIER_NODE in that situation. */
19388 qualified_p
= false;
19392 if (TREE_CODE (function
) == COMPONENT_REF
)
19394 tree op
= TREE_OPERAND (function
, 1);
19396 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
19397 || (BASELINK_P (op
)
19398 && BASELINK_QUALIFIED_P (op
)));
19401 qualified_p
= false;
19403 if (TREE_CODE (function
) == ADDR_EXPR
19404 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
19405 /* Avoid error about taking the address of a constructor. */
19406 function
= TREE_OPERAND (function
, 0);
19408 function
= tsubst_copy_and_build (function
, args
, complain
,
19411 integral_constant_expression_p
);
19413 if (BASELINK_P (function
))
19414 qualified_p
= true;
19417 nargs
= call_expr_nargs (t
);
19418 releasing_vec call_args
;
19419 for (i
= 0; i
< nargs
; ++i
)
19421 tree arg
= CALL_EXPR_ARG (t
, i
);
19423 if (!PACK_EXPANSION_P (arg
))
19424 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
19427 /* Expand the pack expansion and push each entry onto
19429 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
19430 if (TREE_CODE (arg
) == TREE_VEC
)
19432 unsigned int len
, j
;
19434 len
= TREE_VEC_LENGTH (arg
);
19435 for (j
= 0; j
< len
; ++j
)
19437 tree value
= TREE_VEC_ELT (arg
, j
);
19438 if (value
!= NULL_TREE
)
19439 value
= convert_from_reference (value
);
19440 vec_safe_push (call_args
, value
);
19445 /* A partial substitution. Add one entry. */
19446 vec_safe_push (call_args
, arg
);
19451 /* Stripped-down processing for a call in a thunk. Specifically, in
19452 the thunk template for a generic lambda. */
19453 if (CALL_FROM_THUNK_P (t
))
19455 /* Now that we've expanded any packs, the number of call args
19456 might be different. */
19457 unsigned int cargs
= call_args
->length ();
19458 tree thisarg
= NULL_TREE
;
19459 if (TREE_CODE (function
) == COMPONENT_REF
)
19461 thisarg
= TREE_OPERAND (function
, 0);
19462 if (TREE_CODE (thisarg
) == INDIRECT_REF
)
19463 thisarg
= TREE_OPERAND (thisarg
, 0);
19464 function
= TREE_OPERAND (function
, 1);
19465 if (TREE_CODE (function
) == BASELINK
)
19466 function
= BASELINK_FUNCTIONS (function
);
19468 /* We aren't going to do normal overload resolution, so force the
19469 template-id to resolve. */
19470 function
= resolve_nondeduced_context (function
, complain
);
19471 for (unsigned i
= 0; i
< cargs
; ++i
)
19473 /* In a thunk, pass through args directly, without any
19475 tree arg
= (*call_args
)[i
];
19476 while (TREE_CODE (arg
) != PARM_DECL
)
19477 arg
= TREE_OPERAND (arg
, 0);
19478 (*call_args
)[i
] = arg
;
19482 /* If there are no other args, just push 'this'. */
19484 vec_safe_push (call_args
, thisarg
);
19487 /* Otherwise, shift the other args over to make room. */
19488 tree last
= (*call_args
)[cargs
- 1];
19489 vec_safe_push (call_args
, last
);
19490 for (int i
= cargs
- 1; i
> 0; --i
)
19491 (*call_args
)[i
] = (*call_args
)[i
- 1];
19492 (*call_args
)[0] = thisarg
;
19495 ret
= build_call_a (function
, call_args
->length (),
19496 call_args
->address ());
19497 /* The thunk location is not interesting. */
19498 SET_EXPR_LOCATION (ret
, UNKNOWN_LOCATION
);
19499 CALL_FROM_THUNK_P (ret
) = true;
19500 if (CLASS_TYPE_P (TREE_TYPE (ret
)))
19501 CALL_EXPR_RETURN_SLOT_OPT (ret
) = true;
19506 /* We do not perform argument-dependent lookup if normal
19507 lookup finds a non-function, in accordance with the
19508 expected resolution of DR 218. */
19510 && ((is_overloaded_fn (function
)
19511 /* If lookup found a member function, the Koenig lookup is
19512 not appropriate, even if an unqualified-name was used
19513 to denote the function. */
19514 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
19515 || identifier_p (function
))
19516 /* Only do this when substitution turns a dependent call
19517 into a non-dependent call. */
19518 && type_dependent_expression_p_push (t
)
19519 && !any_type_dependent_arguments_p (call_args
))
19520 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
19522 if (function
!= NULL_TREE
19523 && identifier_p (function
)
19524 && !any_type_dependent_arguments_p (call_args
))
19526 if (koenig_p
&& (complain
& tf_warning_or_error
))
19528 /* For backwards compatibility and good diagnostics, try
19529 the unqualified lookup again if we aren't in SFINAE
19531 tree unq
= (tsubst_copy_and_build
19532 (function
, args
, complain
, in_decl
, true,
19533 integral_constant_expression_p
));
19534 if (unq
== error_mark_node
)
19535 RETURN (error_mark_node
);
19537 if (unq
!= function
)
19539 /* In a lambda fn, we have to be careful to not
19540 introduce new this captures. Legacy code can't
19541 be using lambdas anyway, so it's ok to be
19543 bool in_lambda
= (current_class_type
19544 && LAMBDA_TYPE_P (current_class_type
));
19545 char const *const msg
19546 = G_("%qD was not declared in this scope, "
19547 "and no declarations were found by "
19548 "argument-dependent lookup at the point "
19549 "of instantiation");
19553 error_at (cp_expr_loc_or_input_loc (t
),
19556 diag
= permerror (cp_expr_loc_or_input_loc (t
),
19562 if (INDIRECT_REF_P (fn
))
19563 fn
= TREE_OPERAND (fn
, 0);
19564 if (is_overloaded_fn (fn
))
19565 fn
= get_first_fn (fn
);
19568 /* Can't say anything more. */;
19569 else if (DECL_CLASS_SCOPE_P (fn
))
19571 location_t loc
= cp_expr_loc_or_input_loc (t
);
19573 "declarations in dependent base %qT are "
19574 "not found by unqualified lookup",
19575 DECL_CLASS_CONTEXT (fn
));
19576 if (current_class_ptr
)
19578 "use %<this->%D%> instead", function
);
19581 "use %<%T::%D%> instead",
19582 current_class_name
, function
);
19585 inform (DECL_SOURCE_LOCATION (fn
),
19586 "%qD declared here, later in the "
19587 "translation unit", fn
);
19589 RETURN (error_mark_node
);
19595 if (identifier_p (function
))
19597 if (complain
& tf_error
)
19598 unqualified_name_lookup_error (function
);
19599 RETURN (error_mark_node
);
19603 /* Remember that there was a reference to this entity. */
19604 if (function
!= NULL_TREE
19605 && DECL_P (function
)
19606 && !mark_used (function
, complain
) && !(complain
& tf_error
))
19607 RETURN (error_mark_node
);
19609 /* Put back tf_decltype for the actual call. */
19610 complain
|= decltype_flag
;
19612 if (function
== NULL_TREE
)
19613 switch (CALL_EXPR_IFN (t
))
19616 gcc_assert (nargs
== 1);
19617 if (vec_safe_length (call_args
) != 1)
19619 error_at (cp_expr_loc_or_input_loc (t
),
19620 "wrong number of arguments to "
19621 "%<__builtin_launder%>");
19622 ret
= error_mark_node
;
19625 ret
= finish_builtin_launder (cp_expr_loc_or_input_loc (t
),
19626 (*call_args
)[0], complain
);
19629 case IFN_VEC_CONVERT
:
19630 gcc_assert (nargs
== 1);
19631 if (vec_safe_length (call_args
) != 1)
19633 error_at (cp_expr_loc_or_input_loc (t
),
19634 "wrong number of arguments to "
19635 "%<__builtin_convertvector%>");
19636 ret
= error_mark_node
;
19639 ret
= cp_build_vec_convert ((*call_args
)[0], input_location
,
19640 tsubst (TREE_TYPE (t
), args
,
19641 complain
, in_decl
),
19643 if (TREE_CODE (ret
) == VIEW_CONVERT_EXPR
)
19648 /* Unsupported internal function with arguments. */
19649 gcc_unreachable ();
19651 else if (TREE_CODE (function
) == OFFSET_REF
19652 || TREE_CODE (function
) == DOTSTAR_EXPR
19653 || TREE_CODE (function
) == MEMBER_REF
)
19654 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
19656 else if (TREE_CODE (function
) == COMPONENT_REF
)
19658 tree instance
= TREE_OPERAND (function
, 0);
19659 tree fn
= TREE_OPERAND (function
, 1);
19661 if (processing_template_decl
19662 && (type_dependent_expression_p (instance
)
19663 || (!BASELINK_P (fn
)
19664 && TREE_CODE (fn
) != FIELD_DECL
)
19665 || type_dependent_expression_p (fn
)
19666 || any_type_dependent_arguments_p (call_args
)))
19667 ret
= build_min_nt_call_vec (function
, call_args
);
19668 else if (!BASELINK_P (fn
))
19669 ret
= finish_call_expr (function
, &call_args
,
19670 /*disallow_virtual=*/false,
19671 /*koenig_p=*/false,
19674 ret
= (build_new_method_call
19676 &call_args
, NULL_TREE
,
19677 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
19681 else if (concept_check_p (function
))
19683 /* FUNCTION is a template-id referring to a concept definition. */
19684 tree id
= unpack_concept_check (function
);
19685 tree tmpl
= TREE_OPERAND (id
, 0);
19686 tree args
= TREE_OPERAND (id
, 1);
19688 /* Calls to standard and variable concepts should have been
19689 previously diagnosed. */
19690 gcc_assert (function_concept_p (tmpl
));
19692 /* Ensure the result is wrapped as a call expression. */
19693 ret
= build_concept_check (tmpl
, args
, tf_warning_or_error
);
19696 ret
= finish_call_expr (function
, &call_args
,
19697 /*disallow_virtual=*/qualified_p
,
19701 if (ret
!= error_mark_node
)
19703 bool op
= CALL_EXPR_OPERATOR_SYNTAX (t
);
19704 bool ord
= CALL_EXPR_ORDERED_ARGS (t
);
19705 bool rev
= CALL_EXPR_REVERSE_ARGS (t
);
19706 if (op
|| ord
|| rev
)
19708 function
= extract_call_expr (ret
);
19709 CALL_EXPR_OPERATOR_SYNTAX (function
) = op
;
19710 CALL_EXPR_ORDERED_ARGS (function
) = ord
;
19711 CALL_EXPR_REVERSE_ARGS (function
) = rev
;
19720 tree cond
= RECUR (TREE_OPERAND (t
, 0));
19721 cond
= mark_rvalue_use (cond
);
19722 tree folded_cond
= fold_non_dependent_expr (cond
, complain
);
19725 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
19727 if (integer_zerop (folded_cond
))
19729 ++c_inhibit_evaluation_warnings
;
19730 exp1
= RECUR (TREE_OPERAND (t
, 1));
19731 --c_inhibit_evaluation_warnings
;
19732 exp2
= RECUR (TREE_OPERAND (t
, 2));
19736 exp1
= RECUR (TREE_OPERAND (t
, 1));
19737 ++c_inhibit_evaluation_warnings
;
19738 exp2
= RECUR (TREE_OPERAND (t
, 2));
19739 --c_inhibit_evaluation_warnings
;
19741 cond
= folded_cond
;
19745 exp1
= RECUR (TREE_OPERAND (t
, 1));
19746 exp2
= RECUR (TREE_OPERAND (t
, 2));
19749 warning_sentinel
s(warn_duplicated_branches
);
19750 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
19751 cond
, exp1
, exp2
, complain
));
19754 case PSEUDO_DTOR_EXPR
:
19756 tree op0
= RECUR (TREE_OPERAND (t
, 0));
19757 tree op1
= RECUR (TREE_OPERAND (t
, 1));
19758 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
19759 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
19765 tree purpose
, value
, chain
;
19767 if (t
== void_list_node
)
19770 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
19771 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
19773 /* We have pack expansions, so expand those and
19774 create a new list out of it. */
19775 tree purposevec
= NULL_TREE
;
19776 tree valuevec
= NULL_TREE
;
19780 /* Expand the argument expressions. */
19781 if (TREE_PURPOSE (t
))
19782 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
19783 complain
, in_decl
);
19784 if (TREE_VALUE (t
))
19785 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
19786 complain
, in_decl
);
19788 /* Build the rest of the list. */
19789 chain
= TREE_CHAIN (t
);
19790 if (chain
&& chain
!= void_type_node
)
19791 chain
= RECUR (chain
);
19793 /* Determine the number of arguments. */
19794 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
19796 len
= TREE_VEC_LENGTH (purposevec
);
19797 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
19799 else if (TREE_CODE (valuevec
) == TREE_VEC
)
19800 len
= TREE_VEC_LENGTH (valuevec
);
19803 /* Since we only performed a partial substitution into
19804 the argument pack, we only RETURN (a single list
19806 if (purposevec
== TREE_PURPOSE (t
)
19807 && valuevec
== TREE_VALUE (t
)
19808 && chain
== TREE_CHAIN (t
))
19811 RETURN (tree_cons (purposevec
, valuevec
, chain
));
19814 /* Convert the argument vectors into a TREE_LIST */
19818 /* Grab the Ith values. */
19820 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
19823 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
19826 /* Build the list (backwards). */
19827 chain
= tree_cons (purpose
, value
, chain
);
19833 purpose
= TREE_PURPOSE (t
);
19835 purpose
= RECUR (purpose
);
19836 value
= TREE_VALUE (t
);
19838 value
= RECUR (value
);
19839 chain
= TREE_CHAIN (t
);
19840 if (chain
&& chain
!= void_type_node
)
19841 chain
= RECUR (chain
);
19842 if (purpose
== TREE_PURPOSE (t
)
19843 && value
== TREE_VALUE (t
)
19844 && chain
== TREE_CHAIN (t
))
19846 RETURN (tree_cons (purpose
, value
, chain
));
19849 case COMPONENT_REF
:
19856 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
19857 args
, complain
, in_decl
);
19858 /* Remember that there was a reference to this entity. */
19859 if (DECL_P (object
)
19860 && !mark_used (object
, complain
) && !(complain
& tf_error
))
19861 RETURN (error_mark_node
);
19862 object_type
= TREE_TYPE (object
);
19864 member
= TREE_OPERAND (t
, 1);
19865 if (BASELINK_P (member
))
19866 member
= tsubst_baselink (member
,
19867 non_reference (TREE_TYPE (object
)),
19868 args
, complain
, in_decl
);
19870 member
= tsubst_copy (member
, args
, complain
, in_decl
);
19871 if (member
== error_mark_node
)
19872 RETURN (error_mark_node
);
19874 if (TREE_CODE (member
) == FIELD_DECL
)
19876 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
19877 if (TREE_CODE (r
) == COMPONENT_REF
)
19878 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
19881 else if (type_dependent_expression_p (object
))
19882 /* We can't do much here. */;
19883 else if (!CLASS_TYPE_P (object_type
))
19885 if (scalarish_type_p (object_type
))
19887 tree s
= NULL_TREE
;
19888 tree dtor
= member
;
19890 if (TREE_CODE (dtor
) == SCOPE_REF
)
19892 s
= TREE_OPERAND (dtor
, 0);
19893 dtor
= TREE_OPERAND (dtor
, 1);
19895 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
19897 dtor
= TREE_OPERAND (dtor
, 0);
19899 RETURN (finish_pseudo_destructor_expr
19900 (object
, s
, dtor
, input_location
));
19904 else if (TREE_CODE (member
) == SCOPE_REF
19905 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
19907 /* Lookup the template functions now that we know what the
19909 tree scope
= TREE_OPERAND (member
, 0);
19910 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
19911 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
19912 member
= lookup_qualified_name (scope
, tmpl
,
19913 /*is_type_p=*/false,
19914 /*complain=*/false);
19915 if (BASELINK_P (member
))
19917 BASELINK_FUNCTIONS (member
)
19918 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
19920 member
= (adjust_result_of_qualified_name_lookup
19921 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
19926 qualified_name_lookup_error (scope
, tmpl
, member
,
19928 RETURN (error_mark_node
);
19931 else if (TREE_CODE (member
) == SCOPE_REF
19932 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
19933 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
19935 if (complain
& tf_error
)
19937 if (TYPE_P (TREE_OPERAND (member
, 0)))
19938 error ("%qT is not a class or namespace",
19939 TREE_OPERAND (member
, 0));
19941 error ("%qD is not a class or namespace",
19942 TREE_OPERAND (member
, 0));
19944 RETURN (error_mark_node
);
19947 r
= finish_class_member_access_expr (object
, member
,
19948 /*template_p=*/false,
19950 if (TREE_CODE (r
) == COMPONENT_REF
)
19951 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
19956 RETURN (build_throw
19957 (RECUR (TREE_OPERAND (t
, 0))));
19961 vec
<constructor_elt
, va_gc
> *n
;
19962 constructor_elt
*ce
;
19963 unsigned HOST_WIDE_INT idx
;
19964 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
19965 bool process_index_p
;
19967 bool need_copy_p
= false;
19970 if (type
== error_mark_node
)
19971 RETURN (error_mark_node
);
19973 /* We do not want to process the index of aggregate
19974 initializers as they are identifier nodes which will be
19975 looked up by digest_init. */
19976 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
19978 if (null_member_pointer_value_p (t
))
19980 gcc_assert (same_type_p (type
, TREE_TYPE (t
)));
19984 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
19985 newlen
= vec_safe_length (n
);
19986 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
19988 if (ce
->index
&& process_index_p
19989 /* An identifier index is looked up in the type
19990 being initialized, not the current scope. */
19991 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
19992 ce
->index
= RECUR (ce
->index
);
19994 if (PACK_EXPANSION_P (ce
->value
))
19996 /* Substitute into the pack expansion. */
19997 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
20000 if (ce
->value
== error_mark_node
20001 || PACK_EXPANSION_P (ce
->value
))
20003 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
20004 /* Just move the argument into place. */
20005 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
20008 /* Update the length of the final CONSTRUCTOR
20009 arguments vector, and note that we will need to
20011 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
20012 need_copy_p
= true;
20016 ce
->value
= RECUR (ce
->value
);
20021 vec
<constructor_elt
, va_gc
> *old_n
= n
;
20023 vec_alloc (n
, newlen
);
20024 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
20026 if (TREE_CODE (ce
->value
) == TREE_VEC
)
20028 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
20029 for (i
= 0; i
< len
; ++i
)
20030 CONSTRUCTOR_APPEND_ELT (n
, 0,
20031 TREE_VEC_ELT (ce
->value
, i
));
20034 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
20038 r
= build_constructor (init_list_type_node
, n
);
20039 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
20040 CONSTRUCTOR_IS_DESIGNATED_INIT (r
)
20041 = CONSTRUCTOR_IS_DESIGNATED_INIT (t
);
20043 if (TREE_HAS_CONSTRUCTOR (t
))
20045 fcl_t cl
= fcl_functional
;
20046 if (CONSTRUCTOR_C99_COMPOUND_LITERAL (t
))
20048 RETURN (finish_compound_literal (type
, r
, complain
, cl
));
20051 TREE_TYPE (r
) = type
;
20057 tree operand_0
= TREE_OPERAND (t
, 0);
20058 if (TYPE_P (operand_0
))
20060 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
20061 RETURN (get_typeid (operand_0
, complain
));
20065 operand_0
= RECUR (operand_0
);
20066 RETURN (build_typeid (operand_0
, complain
));
20077 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
20078 /* ??? We're doing a subset of finish_id_expression here. */
20079 if (tree wrap
= maybe_get_tls_wrapper_call (r
))
20080 /* Replace an evaluated use of the thread_local variable with
20081 a call to its wrapper. */
20083 else if (outer_automatic_var_p (r
))
20084 r
= process_outer_var_ref (r
, complain
);
20086 if (!TYPE_REF_P (TREE_TYPE (t
)))
20087 /* If the original type was a reference, we'll be wrapped in
20088 the appropriate INDIRECT_REF. */
20089 r
= convert_from_reference (r
);
20095 tree op0
= RECUR (TREE_OPERAND (t
, 0));
20096 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
20097 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
20100 case OFFSETOF_EXPR
:
20103 = tsubst_copy_and_build (TREE_OPERAND (t
, 1), args
, complain
,
20104 in_decl
, /*function_p=*/false,
20105 /*integral_constant_expression_p=*/false);
20106 RETURN (finish_offsetof (object_ptr
,
20107 RECUR (TREE_OPERAND (t
, 0)),
20108 EXPR_LOCATION (t
)));
20111 case ADDRESSOF_EXPR
:
20112 RETURN (cp_build_addressof (EXPR_LOCATION (t
),
20113 RECUR (TREE_OPERAND (t
, 0)), complain
));
20117 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
20118 complain
, in_decl
);
20120 tree type2
= TRAIT_EXPR_TYPE2 (t
);
20121 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
20122 type2
= RECUR (type2
);
20124 type2
= tsubst (type2
, args
, complain
, in_decl
);
20126 RETURN (finish_trait_expr (TRAIT_EXPR_LOCATION (t
),
20127 TRAIT_EXPR_KIND (t
), type1
, type2
));
20132 tree old_stmt_expr
= cur_stmt_expr
;
20133 tree stmt_expr
= begin_stmt_expr ();
20135 cur_stmt_expr
= stmt_expr
;
20136 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
20137 integral_constant_expression_p
);
20138 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
20139 cur_stmt_expr
= old_stmt_expr
;
20141 /* If the resulting list of expression statement is empty,
20142 fold it further into void_node. */
20143 if (empty_expr_stmt_p (stmt_expr
))
20144 stmt_expr
= void_node
;
20146 RETURN (stmt_expr
);
20151 if (complain
& tf_partial
)
20153 /* We don't have a full set of template arguments yet; don't touch
20154 the lambda at all. */
20155 gcc_assert (processing_template_decl
);
20158 tree r
= tsubst_lambda_expr (t
, args
, complain
, in_decl
);
20160 RETURN (build_lambda_object (r
));
20164 /* We can get here for a constant initializer of non-dependent type.
20165 FIXME stop folding in cp_parser_initializer_clause. */
20167 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
20172 case TRANSACTION_EXPR
:
20173 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
20174 integral_constant_expression_p
));
20177 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
20179 case VEC_PERM_EXPR
:
20181 tree op0
= RECUR (TREE_OPERAND (t
, 0));
20182 tree op1
= RECUR (TREE_OPERAND (t
, 1));
20183 tree op2
= RECUR (TREE_OPERAND (t
, 2));
20184 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
20188 case REQUIRES_EXPR
:
20190 tree r
= tsubst_requires_expr (t
, args
, tf_none
, in_decl
);
20191 if (r
== error_mark_node
&& (complain
& tf_error
))
20192 tsubst_requires_expr (t
, args
, complain
, in_decl
);
20197 /* No need to substitute further, a RANGE_EXPR will always be built
20198 with constant operands. */
20201 case NON_LVALUE_EXPR
:
20202 case VIEW_CONVERT_EXPR
:
20203 if (location_wrapper_p (t
))
20204 /* We need to do this here as well as in tsubst_copy so we get the
20205 other tsubst_copy_and_build semantics for a PARM_DECL operand. */
20206 RETURN (maybe_wrap_with_location (RECUR (TREE_OPERAND (t
, 0)),
20207 EXPR_LOCATION (t
)));
20211 /* Handle Objective-C++ constructs, if appropriate. */
20214 = objcp_tsubst_copy_and_build (t
, args
, complain
,
20215 in_decl
, /*function_p=*/false);
20219 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
20225 input_location
= loc
;
20229 /* Verify that the instantiated ARGS are valid. For type arguments,
20230 make sure that the type's linkage is ok. For non-type arguments,
20231 make sure they are constants if they are integral or enumerations.
20232 Emit an error under control of COMPLAIN, and return TRUE on error. */
20235 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
20237 if (dependent_template_arg_p (t
))
20239 if (ARGUMENT_PACK_P (t
))
20241 tree vec
= ARGUMENT_PACK_ARGS (t
);
20242 int len
= TREE_VEC_LENGTH (vec
);
20243 bool result
= false;
20246 for (i
= 0; i
< len
; ++i
)
20247 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
20251 else if (TYPE_P (t
))
20253 /* [basic.link]: A name with no linkage (notably, the name
20254 of a class or enumeration declared in a local scope)
20255 shall not be used to declare an entity with linkage.
20256 This implies that names with no linkage cannot be used as
20259 DR 757 relaxes this restriction for C++0x. */
20260 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
20261 : no_linkage_check (t
, /*relaxed_p=*/false));
20265 /* DR 488 makes use of a type with no linkage cause
20266 type deduction to fail. */
20267 if (complain
& tf_error
)
20269 if (TYPE_UNNAMED_P (nt
))
20270 error ("%qT is/uses unnamed type", t
);
20272 error ("template argument for %qD uses local type %qT",
20277 /* In order to avoid all sorts of complications, we do not
20278 allow variably-modified types as template arguments. */
20279 else if (variably_modified_type_p (t
, NULL_TREE
))
20281 if (complain
& tf_error
)
20282 error ("%qT is a variably modified type", t
);
20286 /* Class template and alias template arguments should be OK. */
20287 else if (DECL_TYPE_TEMPLATE_P (t
))
20289 /* A non-type argument of integral or enumerated type must be a
20291 else if (TREE_TYPE (t
)
20292 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
20293 && !REFERENCE_REF_P (t
)
20294 && !TREE_CONSTANT (t
))
20296 if (complain
& tf_error
)
20297 error ("integral expression %qE is not constant", t
);
20304 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
20306 int ix
, len
= DECL_NTPARMS (tmpl
);
20307 bool result
= false;
20309 for (ix
= 0; ix
!= len
; ix
++)
20311 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
20314 if (result
&& (complain
& tf_error
))
20315 error (" trying to instantiate %qD", tmpl
);
20319 /* We're out of SFINAE context now, so generate diagnostics for the access
20320 errors we saw earlier when instantiating D from TMPL and ARGS. */
20323 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
20325 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
20326 tree type
= TREE_TYPE (pattern
);
20327 location_t loc
= input_location
;
20329 push_access_scope (d
);
20330 push_deferring_access_checks (dk_no_deferred
);
20331 input_location
= DECL_SOURCE_LOCATION (pattern
);
20332 tsubst (type
, args
, tf_warning_or_error
, d
);
20333 input_location
= loc
;
20334 pop_deferring_access_checks ();
20335 pop_access_scope (d
);
20338 /* Instantiate the indicated variable, function, or alias template TMPL with
20339 the template arguments in TARG_PTR. */
20342 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
20344 tree targ_ptr
= orig_args
;
20348 bool access_ok
= true;
20350 if (tmpl
== error_mark_node
)
20351 return error_mark_node
;
20353 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
20355 /* If this function is a clone, handle it specially. */
20356 if (DECL_CLONED_FUNCTION_P (tmpl
))
20361 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
20362 DECL_CLONED_FUNCTION. */
20363 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
20364 targ_ptr
, complain
);
20365 if (spec
== error_mark_node
)
20366 return error_mark_node
;
20368 /* Look for the clone. */
20369 FOR_EACH_CLONE (clone
, spec
)
20370 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
20372 /* We should always have found the clone by now. */
20373 gcc_unreachable ();
20377 if (targ_ptr
== error_mark_node
)
20378 return error_mark_node
;
20380 /* Check to see if we already have this specialization. */
20381 gen_tmpl
= most_general_template (tmpl
);
20382 if (TMPL_ARGS_DEPTH (targ_ptr
)
20383 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
)))
20384 /* targ_ptr only has the innermost template args, so add the outer ones
20385 from tmpl, which could be either a partial instantiation or gen_tmpl (in
20386 the case of a non-dependent call within a template definition). */
20387 targ_ptr
= (add_outermost_template_args
20388 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (tmpl
)),
20391 /* It would be nice to avoid hashing here and then again in tsubst_decl,
20392 but it doesn't seem to be on the hot path. */
20393 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
20395 gcc_assert (tmpl
== gen_tmpl
20396 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
20398 || fndecl
== NULL_TREE
);
20400 if (spec
!= NULL_TREE
)
20402 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
20404 if (complain
& tf_error
)
20405 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
20406 return error_mark_node
;
20411 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
20413 return error_mark_node
;
20415 /* We are building a FUNCTION_DECL, during which the access of its
20416 parameters and return types have to be checked. However this
20417 FUNCTION_DECL which is the desired context for access checking
20418 is not built yet. We solve this chicken-and-egg problem by
20419 deferring all checks until we have the FUNCTION_DECL. */
20420 push_deferring_access_checks (dk_deferred
);
20422 /* Instantiation of the function happens in the context of the function
20423 template, not the context of the overload resolution we're doing. */
20424 push_to_top_level ();
20425 /* If there are dependent arguments, e.g. because we're doing partial
20426 ordering, make sure processing_template_decl stays set. */
20427 if (uses_template_parms (targ_ptr
))
20428 ++processing_template_decl
;
20429 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
20431 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
20432 complain
, gen_tmpl
, true);
20433 push_nested_class (ctx
);
20436 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
20438 fndecl
= NULL_TREE
;
20439 if (VAR_P (pattern
))
20441 /* We need to determine if we're using a partial or explicit
20442 specialization now, because the type of the variable could be
20444 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
20445 tree elt
= most_specialized_partial_spec (tid
, complain
);
20446 if (elt
== error_mark_node
)
20447 pattern
= error_mark_node
;
20450 tree partial_tmpl
= TREE_VALUE (elt
);
20451 tree partial_args
= TREE_PURPOSE (elt
);
20452 tree partial_pat
= DECL_TEMPLATE_RESULT (partial_tmpl
);
20453 fndecl
= tsubst (partial_pat
, partial_args
, complain
, gen_tmpl
);
20457 /* Substitute template parameters to obtain the specialization. */
20458 if (fndecl
== NULL_TREE
)
20459 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
20460 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
20461 pop_nested_class ();
20462 pop_from_top_level ();
20464 if (fndecl
== error_mark_node
)
20466 pop_deferring_access_checks ();
20467 return error_mark_node
;
20470 /* The DECL_TI_TEMPLATE should always be the immediate parent
20471 template, not the most general template. */
20472 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
20473 DECL_TI_ARGS (fndecl
) = targ_ptr
;
20475 /* Now we know the specialization, compute access previously
20476 deferred. Do no access control for inheriting constructors,
20477 as we already checked access for the inherited constructor. */
20478 if (!(flag_new_inheriting_ctors
20479 && DECL_INHERITED_CTOR (fndecl
)))
20481 push_access_scope (fndecl
);
20482 if (!perform_deferred_access_checks (complain
))
20484 pop_access_scope (fndecl
);
20486 pop_deferring_access_checks ();
20488 /* If we've just instantiated the main entry point for a function,
20489 instantiate all the alternate entry points as well. We do this
20490 by cloning the instantiation of the main entry point, not by
20491 instantiating the template clones. */
20492 if (tree chain
= DECL_CHAIN (gen_tmpl
))
20493 if (DECL_P (chain
) && DECL_CLONED_FUNCTION_P (chain
))
20494 clone_function_decl (fndecl
, /*update_methods=*/false);
20498 if (!(complain
& tf_error
))
20500 /* Remember to reinstantiate when we're out of SFINAE so the user
20501 can see the errors. */
20502 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
20504 return error_mark_node
;
20509 /* Wrapper for instantiate_template_1. */
20512 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
20515 timevar_push (TV_TEMPLATE_INST
);
20516 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
20517 timevar_pop (TV_TEMPLATE_INST
);
20521 /* Instantiate the alias template TMPL with ARGS. Also push a template
20522 instantiation level, which instantiate_template doesn't do because
20523 functions and variables have sufficient context established by the
20527 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
20529 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
20530 return error_mark_node
;
20533 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
20534 args
, tmpl
, complain
,
20535 /*require_all_args=*/true,
20536 /*use_default_args=*/true);
20538 /* FIXME check for satisfaction in check_instantiated_args. */
20540 && !any_dependent_template_arguments_p (args
)
20541 && !constraints_satisfied_p (tmpl
, args
))
20543 if (complain
& tf_error
)
20545 auto_diagnostic_group d
;
20546 error ("template constraint failure for %qD", tmpl
);
20547 diagnose_constraints (input_location
, tmpl
, args
);
20549 return error_mark_node
;
20552 if (!push_tinst_level (tmpl
, args
))
20553 return error_mark_node
;
20554 tree r
= instantiate_template (tmpl
, args
, complain
);
20555 pop_tinst_level ();
20560 /* PARM is a template parameter pack for FN. Returns true iff
20561 PARM is used in a deducible way in the argument list of FN. */
20564 pack_deducible_p (tree parm
, tree fn
)
20566 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
20567 for (; t
; t
= TREE_CHAIN (t
))
20569 tree type
= TREE_VALUE (t
);
20571 if (!PACK_EXPANSION_P (type
))
20573 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
20574 packs
; packs
= TREE_CHAIN (packs
))
20575 if (template_args_equal (TREE_VALUE (packs
), parm
))
20577 /* The template parameter pack is used in a function parameter
20578 pack. If this is the end of the parameter list, the
20579 template parameter pack is deducible. */
20580 if (TREE_CHAIN (t
) == void_list_node
)
20583 /* Otherwise, not. Well, it could be deduced from
20584 a non-pack parameter, but doing so would end up with
20585 a deduction mismatch, so don't bother. */
20589 /* The template parameter pack isn't used in any function parameter
20590 packs, but it might be used deeper, e.g. tuple<Args...>. */
20594 /* Subroutine of fn_type_unification: check non-dependent parms for
20598 check_non_deducible_conversions (tree parms
, const tree
*args
, unsigned nargs
,
20599 tree fn
, unification_kind_t strict
, int flags
,
20600 struct conversion
**convs
, bool explain_p
)
20602 /* Non-constructor methods need to leave a conversion for 'this', which
20603 isn't included in nargs here. */
20604 unsigned offset
= (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
20605 && !DECL_CONSTRUCTOR_P (fn
));
20607 for (unsigned ia
= 0;
20608 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
20610 tree parm
= TREE_VALUE (parms
);
20612 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
20613 && (!TREE_CHAIN (parms
)
20614 || TREE_CHAIN (parms
) == void_list_node
))
20615 /* For a function parameter pack that occurs at the end of the
20616 parameter-declaration-list, the type A of each remaining
20617 argument of the call is compared with the type P of the
20618 declarator-id of the function parameter pack. */
20621 parms
= TREE_CHAIN (parms
);
20623 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
20624 /* For a function parameter pack that does not occur at the
20625 end of the parameter-declaration-list, the type of the
20626 parameter pack is a non-deduced context. */
20629 if (!uses_template_parms (parm
))
20631 tree arg
= args
[ia
];
20632 conversion
**conv_p
= convs
? &convs
[ia
+offset
] : NULL
;
20633 int lflags
= conv_flags (ia
, nargs
, fn
, arg
, flags
);
20635 if (check_non_deducible_conversion (parm
, arg
, strict
, lflags
,
20636 conv_p
, explain_p
))
20646 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
20647 NARGS elements of the arguments that are being used when calling
20648 it. TARGS is a vector into which the deduced template arguments
20651 Returns either a FUNCTION_DECL for the matching specialization of FN or
20652 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
20653 true, diagnostics will be printed to explain why it failed.
20655 If FN is a conversion operator, or we are trying to produce a specific
20656 specialization, RETURN_TYPE is the return type desired.
20658 The EXPLICIT_TARGS are explicit template arguments provided via a
20661 The parameter STRICT is one of:
20664 We are deducing arguments for a function call, as in
20665 [temp.deduct.call]. If RETURN_TYPE is non-null, we are
20666 deducing arguments for a call to the result of a conversion
20667 function template, as in [over.call.object].
20670 We are deducing arguments for a conversion function, as in
20671 [temp.deduct.conv].
20674 We are deducing arguments when doing an explicit instantiation
20675 as in [temp.explicit], when determining an explicit specialization
20676 as in [temp.expl.spec], or when taking the address of a function
20677 template, as in [temp.deduct.funcaddr]. */
20680 fn_type_unification (tree fn
,
20681 tree explicit_targs
,
20684 unsigned int nargs
,
20686 unification_kind_t strict
,
20688 struct conversion
**convs
,
20694 tree decl
= NULL_TREE
;
20695 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
20697 static int deduction_depth
;
20698 /* type_unification_real will pass back any access checks from default
20699 template argument substitution. */
20700 vec
<deferred_access_check
, va_gc
> *checks
= NULL
;
20701 /* We don't have all the template args yet. */
20702 bool incomplete
= true;
20705 if (flag_new_inheriting_ctors
)
20706 fn
= strip_inheriting_ctors (fn
);
20708 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
20709 tree r
= error_mark_node
;
20711 tree full_targs
= targs
;
20712 if (TMPL_ARGS_DEPTH (targs
)
20713 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (fn
)))
20714 full_targs
= (add_outermost_template_args
20715 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (fn
)),
20719 complain
|= tf_decltype
;
20721 /* In C++0x, it's possible to have a function template whose type depends
20722 on itself recursively. This is most obvious with decltype, but can also
20723 occur with enumeration scope (c++/48969). So we need to catch infinite
20724 recursion and reject the substitution at deduction time; this function
20725 will return error_mark_node for any repeated substitution.
20727 This also catches excessive recursion such as when f<N> depends on
20728 f<N-1> across all integers, and returns error_mark_node for all the
20729 substitutions back up to the initial one.
20731 This is, of course, not reentrant. */
20732 if (excessive_deduction_depth
)
20733 return error_mark_node
;
20736 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
20738 fntype
= TREE_TYPE (fn
);
20739 if (explicit_targs
)
20743 The specified template arguments must match the template
20744 parameters in kind (i.e., type, nontype, template), and there
20745 must not be more arguments than there are parameters;
20746 otherwise type deduction fails.
20748 Nontype arguments must match the types of the corresponding
20749 nontype template parameters, or must be convertible to the
20750 types of the corresponding nontype parameters as specified in
20751 _temp.arg.nontype_, otherwise type deduction fails.
20753 All references in the function type of the function template
20754 to the corresponding template parameters are replaced by the
20755 specified template argument values. If a substitution in a
20756 template parameter or in the function type of the function
20757 template results in an invalid type, type deduction fails. */
20758 int i
, len
= TREE_VEC_LENGTH (tparms
);
20759 location_t loc
= input_location
;
20760 incomplete
= false;
20762 if (explicit_targs
== error_mark_node
)
20765 if (TMPL_ARGS_DEPTH (explicit_targs
)
20766 < TMPL_ARGS_DEPTH (full_targs
))
20767 explicit_targs
= add_outermost_template_args (full_targs
,
20770 /* Adjust any explicit template arguments before entering the
20771 substitution context. */
20773 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
20774 complain
|tf_partial
,
20775 /*require_all_args=*/false,
20776 /*use_default_args=*/false));
20777 if (explicit_targs
== error_mark_node
)
20780 /* Substitute the explicit args into the function type. This is
20781 necessary so that, for instance, explicitly declared function
20782 arguments can match null pointed constants. If we were given
20783 an incomplete set of explicit args, we must not do semantic
20784 processing during substitution as we could create partial
20786 for (i
= 0; i
< len
; i
++)
20788 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
20789 bool parameter_pack
= false;
20790 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
20792 /* Dig out the actual parm. */
20793 if (TREE_CODE (parm
) == TYPE_DECL
20794 || TREE_CODE (parm
) == TEMPLATE_DECL
)
20796 parm
= TREE_TYPE (parm
);
20797 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
20799 else if (TREE_CODE (parm
) == PARM_DECL
)
20801 parm
= DECL_INITIAL (parm
);
20802 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
20805 if (targ
== NULL_TREE
)
20806 /* No explicit argument for this template parameter. */
20808 else if (parameter_pack
&& pack_deducible_p (parm
, fn
))
20810 /* Mark the argument pack as "incomplete". We could
20811 still deduce more arguments during unification.
20812 We remove this mark in type_unification_real. */
20813 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
20814 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
20815 = ARGUMENT_PACK_ARGS (targ
);
20817 /* We have some incomplete argument packs. */
20824 if (!push_tinst_level (fn
, explicit_targs
))
20826 excessive_deduction_depth
= true;
20829 ++processing_template_decl
;
20830 input_location
= DECL_SOURCE_LOCATION (fn
);
20831 /* Ignore any access checks; we'll see them again in
20832 instantiate_template and they might have the wrong
20833 access path at this point. */
20834 push_deferring_access_checks (dk_deferred
);
20835 tsubst_flags_t ecomplain
= complain
| tf_partial
| tf_fndecl_type
;
20836 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
, ecomplain
, NULL_TREE
);
20837 pop_deferring_access_checks ();
20838 input_location
= loc
;
20839 --processing_template_decl
;
20840 pop_tinst_level ();
20842 if (fntype
== error_mark_node
)
20846 /* Place the explicitly specified arguments in TARGS. */
20847 explicit_targs
= INNERMOST_TEMPLATE_ARGS (explicit_targs
);
20848 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
20849 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
20850 if (!incomplete
&& CHECKING_P
20851 && !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
20852 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
20853 (targs
, NUM_TMPL_ARGS (explicit_targs
));
20856 if (return_type
&& strict
!= DEDUCE_CALL
)
20858 tree
*new_args
= XALLOCAVEC (tree
, nargs
+ 1);
20859 new_args
[0] = return_type
;
20860 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
20868 /* Never do unification on the 'this' parameter. */
20869 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
20871 if (return_type
&& strict
== DEDUCE_CALL
)
20873 /* We're deducing for a call to the result of a template conversion
20874 function. The parms we really want are in return_type. */
20875 if (INDIRECT_TYPE_P (return_type
))
20876 return_type
= TREE_TYPE (return_type
);
20877 parms
= TYPE_ARG_TYPES (return_type
);
20879 else if (return_type
)
20881 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
20884 /* We allow incomplete unification without an error message here
20885 because the standard doesn't seem to explicitly prohibit it. Our
20886 callers must be ready to deal with unification failures in any
20889 /* If we aren't explaining yet, push tinst context so we can see where
20890 any errors (e.g. from class instantiations triggered by instantiation
20891 of default template arguments) come from. If we are explaining, this
20892 context is redundant. */
20893 if (!explain_p
&& !push_tinst_level (fn
, targs
))
20895 excessive_deduction_depth
= true;
20899 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
20900 full_targs
, parms
, args
, nargs
, /*subr=*/0,
20901 strict
, &checks
, explain_p
);
20903 pop_tinst_level ();
20907 /* Now that we have bindings for all of the template arguments,
20908 ensure that the arguments deduced for the template template
20909 parameters have compatible template parameter lists. We cannot
20910 check this property before we have deduced all template
20911 arguments, because the template parameter types of a template
20912 template parameter might depend on prior template parameters
20913 deduced after the template template parameter. The following
20914 ill-formed example illustrates this issue:
20916 template<typename T, template<T> class C> void f(C<5>, T);
20918 template<int N> struct X {};
20921 f(X<5>(), 5l); // error: template argument deduction fails
20924 The template parameter list of 'C' depends on the template type
20925 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
20926 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
20927 time that we deduce 'C'. */
20928 if (!template_template_parm_bindings_ok_p
20929 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
20931 unify_inconsistent_template_template_parameters (explain_p
);
20935 /* DR 1391: All parameters have args, now check non-dependent parms for
20937 if (check_non_deducible_conversions (parms
, args
, nargs
, fn
, strict
, flags
,
20942 /* All is well so far. Now, check:
20946 When all template arguments have been deduced, all uses of
20947 template parameters in nondeduced contexts are replaced with
20948 the corresponding deduced argument values. If the
20949 substitution results in an invalid type, as described above,
20950 type deduction fails. */
20951 if (!push_tinst_level (fn
, targs
))
20953 excessive_deduction_depth
= true;
20957 /* Also collect access checks from the instantiation. */
20958 reopen_deferring_access_checks (checks
);
20960 decl
= instantiate_template (fn
, targs
, complain
);
20962 checks
= get_deferred_access_checks ();
20963 pop_deferring_access_checks ();
20965 pop_tinst_level ();
20967 if (decl
== error_mark_node
)
20970 /* Now perform any access checks encountered during substitution. */
20971 push_access_scope (decl
);
20972 ok
= perform_access_checks (checks
, complain
);
20973 pop_access_scope (decl
);
20977 /* If we're looking for an exact match, check that what we got
20978 is indeed an exact match. It might not be if some template
20979 parameters are used in non-deduced contexts. But don't check
20980 for an exact match if we have dependent template arguments;
20981 in that case we're doing partial ordering, and we already know
20982 that we have two candidates that will provide the actual type. */
20983 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
20985 tree substed
= TREE_TYPE (decl
);
20989 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
20991 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
20992 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
20993 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
20995 unify_type_mismatch (explain_p
, args
[i
],
20996 TREE_VALUE (sarg
));
21001 /* After doing deduction with the inherited constructor, actually return an
21002 instantiation of the inheriting constructor. */
21004 decl
= instantiate_template (orig_fn
, targs
, complain
);
21010 if (excessive_deduction_depth
)
21012 if (deduction_depth
== 0)
21013 /* Reset once we're all the way out. */
21014 excessive_deduction_depth
= false;
21020 /* Adjust types before performing type deduction, as described in
21021 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
21022 sections are symmetric. PARM is the type of a function parameter
21023 or the return type of the conversion function. ARG is the type of
21024 the argument passed to the call, or the type of the value
21025 initialized with the result of the conversion function.
21026 ARG_EXPR is the original argument expression, which may be null. */
21029 maybe_adjust_types_for_deduction (unification_kind_t strict
,
21042 /* Swap PARM and ARG throughout the remainder of this
21043 function; the handling is precisely symmetric since PARM
21044 will initialize ARG rather than vice versa. */
21045 std::swap (parm
, arg
);
21049 /* Core issue #873: Do the DR606 thing (see below) for these cases,
21050 too, but here handle it by stripping the reference from PARM
21051 rather than by adding it to ARG. */
21052 if (TYPE_REF_P (*parm
)
21053 && TYPE_REF_IS_RVALUE (*parm
)
21054 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
21055 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
21056 && TYPE_REF_P (*arg
)
21057 && !TYPE_REF_IS_RVALUE (*arg
))
21058 *parm
= TREE_TYPE (*parm
);
21059 /* Nothing else to do in this case. */
21063 gcc_unreachable ();
21066 if (!TYPE_REF_P (*parm
))
21068 /* [temp.deduct.call]
21070 If P is not a reference type:
21072 --If A is an array type, the pointer type produced by the
21073 array-to-pointer standard conversion (_conv.array_) is
21074 used in place of A for type deduction; otherwise,
21076 --If A is a function type, the pointer type produced by
21077 the function-to-pointer standard conversion
21078 (_conv.func_) is used in place of A for type deduction;
21081 --If A is a cv-qualified type, the top level
21082 cv-qualifiers of A's type are ignored for type
21084 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
21085 *arg
= build_pointer_type (TREE_TYPE (*arg
));
21086 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
21087 *arg
= build_pointer_type (*arg
);
21089 *arg
= TYPE_MAIN_VARIANT (*arg
);
21092 /* [14.8.2.1/3 temp.deduct.call], "A forwarding reference is an rvalue
21093 reference to a cv-unqualified template parameter that does not represent a
21094 template parameter of a class template (during class template argument
21095 deduction (13.3.1.8)). If P is a forwarding reference and the argument is
21096 an lvalue, the type "lvalue reference to A" is used in place of A for type
21098 if (TYPE_REF_P (*parm
)
21099 && TYPE_REF_IS_RVALUE (*parm
)
21100 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
21101 && !TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (*parm
))
21102 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
21103 && (arg_expr
? lvalue_p (arg_expr
)
21104 /* try_one_overload doesn't provide an arg_expr, but
21105 functions are always lvalues. */
21106 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
21107 *arg
= build_reference_type (*arg
);
21109 /* [temp.deduct.call]
21111 If P is a cv-qualified type, the top level cv-qualifiers
21112 of P's type are ignored for type deduction. If P is a
21113 reference type, the type referred to by P is used for
21115 *parm
= TYPE_MAIN_VARIANT (*parm
);
21116 if (TYPE_REF_P (*parm
))
21118 *parm
= TREE_TYPE (*parm
);
21119 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
21122 /* DR 322. For conversion deduction, remove a reference type on parm
21123 too (which has been swapped into ARG). */
21124 if (strict
== DEDUCE_CONV
&& TYPE_REF_P (*arg
))
21125 *arg
= TREE_TYPE (*arg
);
21130 /* Subroutine of fn_type_unification. PARM is a function parameter of a
21131 template which doesn't contain any deducible template parameters; check if
21132 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
21133 unify_one_argument. */
21136 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
21137 int flags
, struct conversion
**conv_p
,
21143 type
= TREE_TYPE (arg
);
21147 if (same_type_p (parm
, type
))
21148 return unify_success (explain_p
);
21150 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
21151 if (strict
== DEDUCE_CONV
)
21153 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
, complain
))
21154 return unify_success (explain_p
);
21156 else if (strict
!= DEDUCE_EXACT
)
21159 tree conv_arg
= TYPE_P (arg
) ? NULL_TREE
: arg
;
21161 /* Avoid recalculating this in add_function_candidate. */
21163 = good_conversion (parm
, type
, conv_arg
, flags
, complain
));
21165 ok
= can_convert_arg (parm
, type
, conv_arg
, flags
, complain
);
21167 return unify_success (explain_p
);
21170 if (strict
== DEDUCE_EXACT
)
21171 return unify_type_mismatch (explain_p
, parm
, arg
);
21173 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
21176 static bool uses_deducible_template_parms (tree type
);
21178 /* Returns true iff the expression EXPR is one from which a template
21179 argument can be deduced. In other words, if it's an undecorated
21180 use of a template non-type parameter. */
21183 deducible_expression (tree expr
)
21185 /* Strip implicit conversions. */
21186 while (CONVERT_EXPR_P (expr
))
21187 expr
= TREE_OPERAND (expr
, 0);
21188 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
21191 /* Returns true iff the array domain DOMAIN uses a template parameter in a
21192 deducible way; that is, if it has a max value of <PARM> - 1. */
21195 deducible_array_bound (tree domain
)
21197 if (domain
== NULL_TREE
)
21200 tree max
= TYPE_MAX_VALUE (domain
);
21201 if (TREE_CODE (max
) != MINUS_EXPR
)
21204 return deducible_expression (TREE_OPERAND (max
, 0));
21207 /* Returns true iff the template arguments ARGS use a template parameter
21208 in a deducible way. */
21211 deducible_template_args (tree args
)
21213 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
21216 tree elt
= TREE_VEC_ELT (args
, i
);
21217 if (ARGUMENT_PACK_P (elt
))
21218 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
21221 if (PACK_EXPANSION_P (elt
))
21222 elt
= PACK_EXPANSION_PATTERN (elt
);
21223 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
21225 else if (TYPE_P (elt
))
21226 deducible
= uses_deducible_template_parms (elt
);
21228 deducible
= deducible_expression (elt
);
21236 /* Returns true iff TYPE contains any deducible references to template
21237 parameters, as per 14.8.2.5. */
21240 uses_deducible_template_parms (tree type
)
21242 if (PACK_EXPANSION_P (type
))
21243 type
= PACK_EXPANSION_PATTERN (type
);
21250 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
21251 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21257 if (INDIRECT_TYPE_P (type
))
21258 return uses_deducible_template_parms (TREE_TYPE (type
));
21260 /* T[integer-constant ]
21262 if (TREE_CODE (type
) == ARRAY_TYPE
)
21263 return (uses_deducible_template_parms (TREE_TYPE (type
))
21264 || deducible_array_bound (TYPE_DOMAIN (type
)));
21276 if (TYPE_PTRMEM_P (type
))
21277 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
21278 || (uses_deducible_template_parms
21279 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
21281 /* template-name <T> (where template-name refers to a class template)
21282 template-name <i> (where template-name refers to a class template) */
21283 if (CLASS_TYPE_P (type
)
21284 && CLASSTYPE_TEMPLATE_INFO (type
)
21285 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
21286 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
21287 (CLASSTYPE_TI_ARGS (type
)));
21292 if (FUNC_OR_METHOD_TYPE_P (type
))
21294 if (uses_deducible_template_parms (TREE_TYPE (type
)))
21296 tree parm
= TYPE_ARG_TYPES (type
);
21297 if (TREE_CODE (type
) == METHOD_TYPE
)
21298 parm
= TREE_CHAIN (parm
);
21299 for (; parm
; parm
= TREE_CHAIN (parm
))
21300 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
21307 /* Subroutine of type_unification_real and unify_pack_expansion to
21308 handle unification of a single P/A pair. Parameters are as
21309 for those functions. */
21312 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
21313 int subr
, unification_kind_t strict
,
21316 tree arg_expr
= NULL_TREE
;
21319 if (arg
== error_mark_node
|| parm
== error_mark_node
)
21320 return unify_invalid (explain_p
);
21321 if (arg
== unknown_type_node
)
21322 /* We can't deduce anything from this, but we might get all the
21323 template args from other function args. */
21324 return unify_success (explain_p
);
21326 /* Implicit conversions (Clause 4) will be performed on a function
21327 argument to convert it to the type of the corresponding function
21328 parameter if the parameter type contains no template-parameters that
21329 participate in template argument deduction. */
21330 if (strict
!= DEDUCE_EXACT
21331 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
21332 /* For function parameters with no deducible template parameters,
21333 just return. We'll check non-dependent conversions later. */
21334 return unify_success (explain_p
);
21339 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
21340 | UNIFY_ALLOW_MORE_CV_QUAL
21341 | UNIFY_ALLOW_DERIVED
);
21345 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
21349 arg_strict
= UNIFY_ALLOW_NONE
;
21353 gcc_unreachable ();
21356 /* We only do these transformations if this is the top-level
21357 parameter_type_list in a call or declaration matching; in other
21358 situations (nested function declarators, template argument lists) we
21359 won't be comparing a type to an expression, and we don't do any type
21365 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
21366 if (type_unknown_p (arg
))
21368 /* [temp.deduct.type] A template-argument can be
21369 deduced from a pointer to function or pointer
21370 to member function argument if the set of
21371 overloaded functions does not contain function
21372 templates and at most one of a set of
21373 overloaded functions provides a unique
21375 resolve_overloaded_unification (tparms
, targs
, parm
,
21377 arg_strict
, explain_p
);
21378 /* If a unique match was not found, this is a
21379 non-deduced context, so we still succeed. */
21380 return unify_success (explain_p
);
21384 arg
= unlowered_expr_type (arg
);
21385 if (arg
== error_mark_node
)
21386 return unify_invalid (explain_p
);
21390 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
21393 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
21394 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
21395 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
21397 /* For deduction from an init-list we need the actual list. */
21398 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
21400 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
21403 /* for_each_template_parm callback that always returns 0. */
21406 zero_r (tree
, void *)
21411 /* for_each_template_parm any_fn callback to handle deduction of a template
21412 type argument from the type of an array bound. */
21415 array_deduction_r (tree t
, void *data
)
21417 tree_pair_p d
= (tree_pair_p
)data
;
21418 tree
&tparms
= d
->purpose
;
21419 tree
&targs
= d
->value
;
21421 if (TREE_CODE (t
) == ARRAY_TYPE
)
21422 if (tree dom
= TYPE_DOMAIN (t
))
21423 if (tree max
= TYPE_MAX_VALUE (dom
))
21425 if (TREE_CODE (max
) == MINUS_EXPR
)
21426 max
= TREE_OPERAND (max
, 0);
21427 if (TREE_CODE (max
) == TEMPLATE_PARM_INDEX
)
21428 unify (tparms
, targs
, TREE_TYPE (max
), size_type_node
,
21429 UNIFY_ALLOW_NONE
, /*explain*/false);
21432 /* Keep walking. */
21436 /* Try to deduce any not-yet-deduced template type arguments from the type of
21437 an array bound. This is handled separately from unify because 14.8.2.5 says
21438 "The type of a type parameter is only deduced from an array bound if it is
21439 not otherwise deduced." */
21442 try_array_deduction (tree tparms
, tree targs
, tree parm
)
21444 tree_pair_s data
= { tparms
, targs
};
21445 hash_set
<tree
> visited
;
21446 for_each_template_parm (parm
, zero_r
, &data
, &visited
,
21447 /*nondeduced*/false, array_deduction_r
);
21450 /* Most parms like fn_type_unification.
21452 If SUBR is 1, we're being called recursively (to unify the
21453 arguments of a function or method parameter of a function
21456 CHECKS is a pointer to a vector of access checks encountered while
21457 substituting default template arguments. */
21460 type_unification_real (tree tparms
,
21464 unsigned int xnargs
,
21466 unification_kind_t strict
,
21467 vec
<deferred_access_check
, va_gc
> **checks
,
21472 int ntparms
= TREE_VEC_LENGTH (tparms
);
21473 int saw_undeduced
= 0;
21476 unsigned int nargs
;
21479 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
21480 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
21481 gcc_assert (ntparms
> 0);
21483 tree targs
= INNERMOST_TEMPLATE_ARGS (full_targs
);
21485 /* Reset the number of non-defaulted template arguments contained
21487 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
21495 while (parms
&& parms
!= void_list_node
21498 parm
= TREE_VALUE (parms
);
21500 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
21501 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
21502 /* For a function parameter pack that occurs at the end of the
21503 parameter-declaration-list, the type A of each remaining
21504 argument of the call is compared with the type P of the
21505 declarator-id of the function parameter pack. */
21508 parms
= TREE_CHAIN (parms
);
21510 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
21511 /* For a function parameter pack that does not occur at the
21512 end of the parameter-declaration-list, the type of the
21513 parameter pack is a non-deduced context. */
21519 if (unify_one_argument (tparms
, full_targs
, parm
, arg
, subr
, strict
,
21525 && parms
!= void_list_node
21526 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
21528 /* Unify the remaining arguments with the pack expansion type. */
21530 tree parmvec
= make_tree_vec (1);
21532 /* Allocate a TREE_VEC and copy in all of the arguments */
21533 argvec
= make_tree_vec (nargs
- ia
);
21534 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
21535 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
21537 /* Copy the parameter into parmvec. */
21538 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
21539 if (unify_pack_expansion (tparms
, full_targs
, parmvec
, argvec
, strict
,
21540 /*subr=*/subr
, explain_p
))
21543 /* Advance to the end of the list of parameters. */
21544 parms
= TREE_CHAIN (parms
);
21547 /* Fail if we've reached the end of the parm list, and more args
21548 are present, and the parm list isn't variadic. */
21549 if (ia
< nargs
&& parms
== void_list_node
)
21550 return unify_too_many_arguments (explain_p
, nargs
, ia
);
21551 /* Fail if parms are left and they don't have default values and
21552 they aren't all deduced as empty packs (c++/57397). This is
21553 consistent with sufficient_parms_p. */
21554 if (parms
&& parms
!= void_list_node
21555 && TREE_PURPOSE (parms
) == NULL_TREE
)
21557 unsigned int count
= nargs
;
21562 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
21565 p
= TREE_CHAIN (p
);
21567 while (p
&& p
!= void_list_node
);
21568 if (count
!= nargs
)
21569 return unify_too_few_arguments (explain_p
, ia
, count
,
21575 tsubst_flags_t complain
= (explain_p
21576 ? tf_warning_or_error
21578 bool tried_array_deduction
= (cxx_dialect
< cxx17
);
21580 for (i
= 0; i
< ntparms
; i
++)
21582 tree targ
= TREE_VEC_ELT (targs
, i
);
21583 tree tparm
= TREE_VEC_ELT (tparms
, i
);
21585 /* Clear the "incomplete" flags on all argument packs now so that
21586 substituting them into later default arguments works. */
21587 if (targ
&& ARGUMENT_PACK_P (targ
))
21589 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
21590 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
21593 if (targ
|| tparm
== error_mark_node
)
21595 tparm
= TREE_VALUE (tparm
);
21597 if (TREE_CODE (tparm
) == TYPE_DECL
21598 && !tried_array_deduction
)
21600 try_array_deduction (tparms
, targs
, xparms
);
21601 tried_array_deduction
= true;
21602 if (TREE_VEC_ELT (targs
, i
))
21606 /* If this is an undeduced nontype parameter that depends on
21607 a type parameter, try another pass; its type may have been
21608 deduced from a later argument than the one from which
21609 this parameter can be deduced. */
21610 if (TREE_CODE (tparm
) == PARM_DECL
21611 && uses_template_parms (TREE_TYPE (tparm
))
21612 && saw_undeduced
< 2)
21618 /* Core issue #226 (C++0x) [temp.deduct]:
21620 If a template argument has not been deduced, its
21621 default template argument, if any, is used.
21623 When we are in C++98 mode, TREE_PURPOSE will either
21624 be NULL_TREE or ERROR_MARK_NODE, so we do not need
21625 to explicitly check cxx_dialect here. */
21626 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
21627 /* OK, there is a default argument. Wait until after the
21628 conversion check to do substitution. */
21631 /* If the type parameter is a parameter pack, then it will
21632 be deduced to an empty parameter pack. */
21633 if (template_parameter_pack_p (tparm
))
21637 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
21639 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
21640 TREE_CONSTANT (arg
) = 1;
21643 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
21645 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
21647 TREE_VEC_ELT (targs
, i
) = arg
;
21651 return unify_parameter_deduction_failure (explain_p
, tparm
);
21654 /* Now substitute into the default template arguments. */
21655 for (i
= 0; i
< ntparms
; i
++)
21657 tree targ
= TREE_VEC_ELT (targs
, i
);
21658 tree tparm
= TREE_VEC_ELT (tparms
, i
);
21660 if (targ
|| tparm
== error_mark_node
)
21662 tree parm
= TREE_VALUE (tparm
);
21663 tree arg
= TREE_PURPOSE (tparm
);
21664 reopen_deferring_access_checks (*checks
);
21665 location_t save_loc
= input_location
;
21667 input_location
= DECL_SOURCE_LOCATION (parm
);
21669 if (saw_undeduced
== 1
21670 && TREE_CODE (parm
) == PARM_DECL
21671 && uses_template_parms (TREE_TYPE (parm
)))
21673 /* The type of this non-type parameter depends on undeduced
21674 parameters. Don't try to use its default argument yet,
21675 since we might deduce an argument for it on the next pass,
21676 but do check whether the arguments we already have cause
21677 substitution failure, so that that happens before we try
21678 later default arguments (78489). */
21679 ++processing_template_decl
;
21680 tree type
= tsubst (TREE_TYPE (parm
), full_targs
, complain
,
21682 --processing_template_decl
;
21683 if (type
== error_mark_node
)
21684 arg
= error_mark_node
;
21690 /* Even if the call is happening in template context, getting
21691 here means it's non-dependent, and a default argument is
21692 considered a separate definition under [temp.decls], so we can
21693 do this substitution without processing_template_decl. This
21694 is important if the default argument contains something that
21695 might be instantiation-dependent like access (87480). */
21696 processing_template_decl_sentinel s
;
21697 tree substed
= NULL_TREE
;
21698 if (saw_undeduced
== 1)
21700 /* First instatiate in template context, in case we still
21701 depend on undeduced template parameters. */
21702 ++processing_template_decl
;
21703 substed
= tsubst_template_arg (arg
, full_targs
, complain
,
21705 --processing_template_decl
;
21706 if (substed
!= error_mark_node
21707 && !uses_template_parms (substed
))
21708 /* We replaced all the tparms, substitute again out of
21709 template context. */
21710 substed
= NULL_TREE
;
21713 substed
= tsubst_template_arg (arg
, full_targs
, complain
,
21716 if (!uses_template_parms (substed
))
21717 arg
= convert_template_argument (parm
, substed
, full_targs
,
21718 complain
, i
, NULL_TREE
);
21719 else if (saw_undeduced
== 1)
21722 arg
= error_mark_node
;
21725 input_location
= save_loc
;
21726 *checks
= get_deferred_access_checks ();
21727 pop_deferring_access_checks ();
21729 if (arg
== error_mark_node
)
21733 TREE_VEC_ELT (targs
, i
) = arg
;
21734 /* The position of the first default template argument,
21735 is also the number of non-defaulted arguments in TARGS.
21737 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
21738 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
21742 if (saw_undeduced
++ == 1)
21746 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
21747 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
21749 return unify_success (explain_p
);
21752 /* Subroutine of type_unification_real. Args are like the variables
21753 at the call site. ARG is an overloaded function (or template-id);
21754 we try deducing template args from each of the overloads, and if
21755 only one succeeds, we go with that. Modifies TARGS and returns
21756 true on success. */
21759 resolve_overloaded_unification (tree tparms
,
21763 unification_kind_t strict
,
21767 tree tempargs
= copy_node (targs
);
21769 tree goodfn
= NULL_TREE
;
21772 if (TREE_CODE (arg
) == ADDR_EXPR
)
21774 arg
= TREE_OPERAND (arg
, 0);
21780 if (TREE_CODE (arg
) == COMPONENT_REF
)
21781 /* Handle `&x' where `x' is some static or non-static member
21783 arg
= TREE_OPERAND (arg
, 1);
21785 if (TREE_CODE (arg
) == OFFSET_REF
)
21786 arg
= TREE_OPERAND (arg
, 1);
21788 /* Strip baselink information. */
21789 if (BASELINK_P (arg
))
21790 arg
= BASELINK_FUNCTIONS (arg
);
21792 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
21794 /* If we got some explicit template args, we need to plug them into
21795 the affected templates before we try to unify, in case the
21796 explicit args will completely resolve the templates in question. */
21799 tree expl_subargs
= TREE_OPERAND (arg
, 1);
21800 arg
= TREE_OPERAND (arg
, 0);
21802 for (lkp_iterator
iter (arg
); iter
; ++iter
)
21805 tree subargs
, elem
;
21807 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
21810 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
21811 expl_subargs
, NULL_TREE
, tf_none
,
21812 /*require_all_args=*/true,
21813 /*use_default_args=*/true);
21814 if (subargs
!= error_mark_node
21815 && !any_dependent_template_arguments_p (subargs
))
21817 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
21818 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
21819 elem
, strict
, sub_strict
, addr_p
, explain_p
)
21820 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
21829 /* If no templates (or more than one) are fully resolved by the
21830 explicit arguments, this template-id is a non-deduced context; it
21831 could still be OK if we deduce all template arguments for the
21832 enclosing call through other arguments. */
21836 else if (!OVL_P (arg
))
21837 /* If ARG is, for example, "(0, &f)" then its type will be unknown
21838 -- but the deduction does not succeed because the expression is
21839 not just the function on its own. */
21842 for (lkp_iterator
iter (arg
); iter
; ++iter
)
21845 if (try_one_overload (tparms
, targs
, tempargs
, parm
, TREE_TYPE (fn
),
21846 strict
, sub_strict
, addr_p
, explain_p
)
21847 && (!goodfn
|| !decls_match (goodfn
, fn
)))
21854 /* [temp.deduct.type] A template-argument can be deduced from a pointer
21855 to function or pointer to member function argument if the set of
21856 overloaded functions does not contain function templates and at most
21857 one of a set of overloaded functions provides a unique match.
21859 So if we found multiple possibilities, we return success but don't
21860 deduce anything. */
21864 int i
= TREE_VEC_LENGTH (targs
);
21866 if (TREE_VEC_ELT (tempargs
, i
))
21868 tree old
= TREE_VEC_ELT (targs
, i
);
21869 tree new_
= TREE_VEC_ELT (tempargs
, i
);
21870 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
21871 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
21872 /* Don't forget explicit template arguments in a pack. */
21873 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
21874 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
21875 TREE_VEC_ELT (targs
, i
) = new_
;
21884 /* Core DR 115: In contexts where deduction is done and fails, or in
21885 contexts where deduction is not done, if a template argument list is
21886 specified and it, along with any default template arguments, identifies
21887 a single function template specialization, then the template-id is an
21888 lvalue for the function template specialization. */
21891 resolve_nondeduced_context (tree orig_expr
, tsubst_flags_t complain
)
21893 tree expr
, offset
, baselink
;
21896 if (!type_unknown_p (orig_expr
))
21901 offset
= NULL_TREE
;
21902 baselink
= NULL_TREE
;
21904 if (TREE_CODE (expr
) == ADDR_EXPR
)
21906 expr
= TREE_OPERAND (expr
, 0);
21909 if (TREE_CODE (expr
) == OFFSET_REF
)
21912 expr
= TREE_OPERAND (expr
, 1);
21914 if (BASELINK_P (expr
))
21917 expr
= BASELINK_FUNCTIONS (expr
);
21920 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
21923 tree goodfn
= NULL_TREE
;
21925 /* If we got some explicit template args, we need to plug them into
21926 the affected templates before we try to unify, in case the
21927 explicit args will completely resolve the templates in question. */
21929 tree expl_subargs
= TREE_OPERAND (expr
, 1);
21930 tree arg
= TREE_OPERAND (expr
, 0);
21931 tree badfn
= NULL_TREE
;
21932 tree badargs
= NULL_TREE
;
21934 for (lkp_iterator
iter (arg
); iter
; ++iter
)
21937 tree subargs
, elem
;
21939 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
21942 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
21943 expl_subargs
, NULL_TREE
, tf_none
,
21944 /*require_all_args=*/true,
21945 /*use_default_args=*/true);
21946 if (subargs
!= error_mark_node
21947 && !any_dependent_template_arguments_p (subargs
))
21949 elem
= instantiate_template (fn
, subargs
, tf_none
);
21950 if (elem
== error_mark_node
)
21955 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
21964 mark_used (goodfn
);
21967 expr
= build_baselink (BASELINK_BINFO (baselink
),
21968 BASELINK_ACCESS_BINFO (baselink
),
21969 expr
, BASELINK_OPTYPE (baselink
));
21973 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
21974 expr
= build_offset_ref (base
, expr
, addr
, complain
);
21977 expr
= cp_build_addr_expr (expr
, complain
);
21980 else if (good
== 0 && badargs
&& (complain
& tf_error
))
21981 /* There were no good options and at least one bad one, so let the
21982 user know what the problem is. */
21983 instantiate_template (badfn
, badargs
, complain
);
21988 /* As above, but error out if the expression remains overloaded. */
21991 resolve_nondeduced_context_or_error (tree exp
, tsubst_flags_t complain
)
21993 exp
= resolve_nondeduced_context (exp
, complain
);
21994 if (type_unknown_p (exp
))
21996 if (complain
& tf_error
)
21997 cxx_incomplete_type_error (exp
, TREE_TYPE (exp
));
21998 return error_mark_node
;
22003 /* Subroutine of resolve_overloaded_unification; does deduction for a single
22004 overload. Fills TARGS with any deduced arguments, or error_mark_node if
22005 different overloads deduce different arguments for a given parm.
22006 ADDR_P is true if the expression for which deduction is being
22007 performed was of the form "& fn" rather than simply "fn".
22009 Returns 1 on success. */
22012 try_one_overload (tree tparms
,
22017 unification_kind_t strict
,
22026 if (arg
== error_mark_node
)
22029 /* [temp.deduct.type] A template-argument can be deduced from a pointer
22030 to function or pointer to member function argument if the set of
22031 overloaded functions does not contain function templates and at most
22032 one of a set of overloaded functions provides a unique match.
22034 So if this is a template, just return success. */
22036 if (uses_template_parms (arg
))
22039 if (TREE_CODE (arg
) == METHOD_TYPE
)
22040 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
22042 arg
= build_pointer_type (arg
);
22044 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
22046 /* We don't copy orig_targs for this because if we have already deduced
22047 some template args from previous args, unify would complain when we
22048 try to deduce a template parameter for the same argument, even though
22049 there isn't really a conflict. */
22050 nargs
= TREE_VEC_LENGTH (targs
);
22051 tempargs
= make_tree_vec (nargs
);
22053 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
22056 /* First make sure we didn't deduce anything that conflicts with
22057 explicitly specified args. */
22058 for (i
= nargs
; i
--; )
22060 tree elt
= TREE_VEC_ELT (tempargs
, i
);
22061 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
22065 else if (uses_template_parms (elt
))
22066 /* Since we're unifying against ourselves, we will fill in
22067 template args used in the function parm list with our own
22068 template parms. Discard them. */
22069 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
22070 else if (oldelt
&& ARGUMENT_PACK_P (oldelt
))
22072 /* Check that the argument at each index of the deduced argument pack
22073 is equivalent to the corresponding explicitly specified argument.
22074 We may have deduced more arguments than were explicitly specified,
22077 /* We used to assert ARGUMENT_PACK_INCOMPLETE_P (oldelt) here, but
22078 that's wrong if we deduce the same argument pack from multiple
22079 function arguments: it's only incomplete the first time. */
22081 tree explicit_pack
= ARGUMENT_PACK_ARGS (oldelt
);
22082 tree deduced_pack
= ARGUMENT_PACK_ARGS (elt
);
22084 if (TREE_VEC_LENGTH (deduced_pack
)
22085 < TREE_VEC_LENGTH (explicit_pack
))
22088 for (int j
= 0; j
< TREE_VEC_LENGTH (explicit_pack
); j
++)
22089 if (!template_args_equal (TREE_VEC_ELT (explicit_pack
, j
),
22090 TREE_VEC_ELT (deduced_pack
, j
)))
22093 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
22097 for (i
= nargs
; i
--; )
22099 tree elt
= TREE_VEC_ELT (tempargs
, i
);
22102 TREE_VEC_ELT (targs
, i
) = elt
;
22108 /* PARM is a template class (perhaps with unbound template
22109 parameters). ARG is a fully instantiated type. If ARG can be
22110 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
22111 TARGS are as for unify. */
22114 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
22117 tree copy_of_targs
;
22119 if (!CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
22121 else if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22122 /* Matches anything. */;
22123 else if (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
22124 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
)))
22127 /* We need to make a new template argument vector for the call to
22128 unify. If we used TARGS, we'd clutter it up with the result of
22129 the attempted unification, even if this class didn't work out.
22130 We also don't want to commit ourselves to all the unifications
22131 we've already done, since unification is supposed to be done on
22132 an argument-by-argument basis. In other words, consider the
22133 following pathological case:
22135 template <int I, int J, int K>
22138 template <int I, int J>
22139 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
22141 template <int I, int J, int K>
22142 void f(S<I, J, K>, S<I, I, I>);
22151 Now, by the time we consider the unification involving `s2', we
22152 already know that we must have `f<0, 0, 0>'. But, even though
22153 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
22154 because there are two ways to unify base classes of S<0, 1, 2>
22155 with S<I, I, I>. If we kept the already deduced knowledge, we
22156 would reject the possibility I=1. */
22157 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
22159 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22161 if (unify_bound_ttp_args (tparms
, copy_of_targs
, parm
, arg
, explain_p
))
22166 /* If unification failed, we're done. */
22167 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
22168 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
22174 /* Given a template type PARM and a class type ARG, find the unique
22175 base type in ARG that is an instance of PARM. We do not examine
22176 ARG itself; only its base-classes. If there is not exactly one
22177 appropriate base class, return NULL_TREE. PARM may be the type of
22178 a partial specialization, as well as a plain template type. Used
22181 static enum template_base_result
22182 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
22183 bool explain_p
, tree
*result
)
22185 tree rval
= NULL_TREE
;
22188 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
22190 binfo
= TYPE_BINFO (complete_type (arg
));
22193 /* The type could not be completed. */
22194 *result
= NULL_TREE
;
22195 return tbr_incomplete_type
;
22198 /* Walk in inheritance graph order. The search order is not
22199 important, and this avoids multiple walks of virtual bases. */
22200 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
22202 tree r
= try_class_unification (tparms
, targs
, parm
,
22203 BINFO_TYPE (binfo
), explain_p
);
22207 /* If there is more than one satisfactory baseclass, then:
22211 If they yield more than one possible deduced A, the type
22215 if (rval
&& !same_type_p (r
, rval
))
22217 *result
= NULL_TREE
;
22218 return tbr_ambiguous_baseclass
;
22226 return tbr_success
;
22229 /* Returns the level of DECL, which declares a template parameter. */
22232 template_decl_level (tree decl
)
22234 switch (TREE_CODE (decl
))
22237 case TEMPLATE_DECL
:
22238 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
22241 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
22244 gcc_unreachable ();
22249 /* Decide whether ARG can be unified with PARM, considering only the
22250 cv-qualifiers of each type, given STRICT as documented for unify.
22251 Returns nonzero iff the unification is OK on that basis. */
22254 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
22256 int arg_quals
= cp_type_quals (arg
);
22257 int parm_quals
= cp_type_quals (parm
);
22259 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
22260 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
22262 /* Although a CVR qualifier is ignored when being applied to a
22263 substituted template parameter ([8.3.2]/1 for example), that
22264 does not allow us to unify "const T" with "int&" because both
22265 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
22266 It is ok when we're allowing additional CV qualifiers
22267 at the outer level [14.8.2.1]/3,1st bullet. */
22268 if ((TYPE_REF_P (arg
)
22269 || FUNC_OR_METHOD_TYPE_P (arg
))
22270 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
22273 if ((!INDIRECT_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
22274 && (parm_quals
& TYPE_QUAL_RESTRICT
))
22278 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
22279 && (arg_quals
& parm_quals
) != parm_quals
)
22282 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
22283 && (parm_quals
& arg_quals
) != arg_quals
)
22289 /* Determines the LEVEL and INDEX for the template parameter PARM. */
22291 template_parm_level_and_index (tree parm
, int* level
, int* index
)
22293 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
22294 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
22295 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22297 *index
= TEMPLATE_TYPE_IDX (parm
);
22298 *level
= TEMPLATE_TYPE_LEVEL (parm
);
22302 *index
= TEMPLATE_PARM_IDX (parm
);
22303 *level
= TEMPLATE_PARM_LEVEL (parm
);
22307 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
22309 if (unify (TP, TA, P, A, S, EP)) \
22313 /* Unifies the remaining arguments in PACKED_ARGS with the pack
22314 expansion at the end of PACKED_PARMS. Returns 0 if the type
22315 deduction succeeds, 1 otherwise. STRICT is the same as in
22316 fn_type_unification. CALL_ARGS_P is true iff PACKED_ARGS is actually a
22317 function call argument list. We'll need to adjust the arguments to make them
22318 types. SUBR tells us if this is from a recursive call to
22319 type_unification_real, or for comparing two template argument
22323 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
22324 tree packed_args
, unification_kind_t strict
,
22325 bool subr
, bool explain_p
)
22328 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
22329 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
22330 tree pack
, packs
= NULL_TREE
;
22331 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
22333 /* Add in any args remembered from an earlier partial instantiation. */
22334 targs
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (parm
), targs
);
22335 int levels
= TMPL_ARGS_DEPTH (targs
);
22337 packed_args
= expand_template_argument_pack (packed_args
);
22339 int len
= TREE_VEC_LENGTH (packed_args
);
22341 /* Determine the parameter packs we will be deducing from the
22342 pattern, and record their current deductions. */
22343 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
22344 pack
; pack
= TREE_CHAIN (pack
))
22346 tree parm_pack
= TREE_VALUE (pack
);
22349 /* Only template parameter packs can be deduced, not e.g. function
22350 parameter packs or __bases or __integer_pack. */
22351 if (!TEMPLATE_PARM_P (parm_pack
))
22354 /* Determine the index and level of this parameter pack. */
22355 template_parm_level_and_index (parm_pack
, &level
, &idx
);
22356 if (level
< levels
)
22359 /* Keep track of the parameter packs and their corresponding
22361 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
22362 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
22365 /* Loop through all of the arguments that have not yet been
22366 unified and unify each with the pattern. */
22367 for (i
= start
; i
< len
; i
++)
22370 bool any_explicit
= false;
22371 tree arg
= TREE_VEC_ELT (packed_args
, i
);
22373 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
22374 or the element of its argument pack at the current index if
22375 this argument was explicitly specified. */
22376 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
22380 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
22383 if (TREE_VALUE (pack
)
22384 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
22385 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
22387 any_explicit
= true;
22388 arg
= TREE_VEC_ELT (pargs
, i
- start
);
22390 TMPL_ARG (targs
, level
, idx
) = arg
;
22393 /* If we had explicit template arguments, substitute them into the
22394 pattern before deduction. */
22397 /* Some arguments might still be unspecified or dependent. */
22399 ++processing_template_decl
;
22400 dependent
= any_dependent_template_arguments_p (targs
);
22402 --processing_template_decl
;
22403 parm
= tsubst (pattern
, targs
,
22404 explain_p
? tf_warning_or_error
: tf_none
,
22407 --processing_template_decl
;
22408 if (parm
== error_mark_node
)
22414 /* Unify the pattern with the current argument. */
22415 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
22419 /* For each parameter pack, collect the deduced value. */
22420 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
22423 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
22425 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
22426 TMPL_ARG (targs
, level
, idx
);
22430 /* Verify that the results of unification with the parameter packs
22431 produce results consistent with what we've seen before, and make
22432 the deduced argument packs available. */
22433 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
22435 tree old_pack
= TREE_VALUE (pack
);
22436 tree new_args
= TREE_TYPE (pack
);
22437 int i
, len
= TREE_VEC_LENGTH (new_args
);
22439 bool nondeduced_p
= false;
22441 /* By default keep the original deduced argument pack.
22442 If necessary, more specific code is going to update the
22443 resulting deduced argument later down in this function. */
22444 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
22445 TMPL_ARG (targs
, level
, idx
) = old_pack
;
22447 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
22448 actually deduce anything. */
22449 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
22450 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
22451 nondeduced_p
= true;
22455 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
22457 /* If we had fewer function args than explicit template args,
22458 just use the explicits. */
22459 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
22460 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
22461 if (len
< explicit_len
)
22462 new_args
= explicit_args
;
22468 /* Build the deduced *_ARGUMENT_PACK. */
22469 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
22471 result
= make_node (NONTYPE_ARGUMENT_PACK
);
22472 TREE_CONSTANT (result
) = 1;
22475 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
22477 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
22479 /* Note the deduced argument packs for this parameter
22481 TMPL_ARG (targs
, level
, idx
) = result
;
22483 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
22484 && (ARGUMENT_PACK_ARGS (old_pack
)
22485 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
22487 /* We only had the explicitly-provided arguments before, but
22488 now we have a complete set of arguments. */
22489 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
22491 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
22492 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
22493 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
22497 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
22498 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
22500 if (!comp_template_args (old_args
, new_args
,
22501 &bad_old_arg
, &bad_new_arg
))
22502 /* Inconsistent unification of this parameter pack. */
22503 return unify_parameter_pack_inconsistent (explain_p
,
22509 return unify_success (explain_p
);
22512 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
22513 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
22514 parameters and return value are as for unify. */
22517 unify_array_domain (tree tparms
, tree targs
,
22518 tree parm_dom
, tree arg_dom
,
22526 /* Our representation of array types uses "N - 1" as the
22527 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
22528 not an integer constant. We cannot unify arbitrarily
22529 complex expressions, so we eliminate the MINUS_EXPRs
22531 parm_max
= TYPE_MAX_VALUE (parm_dom
);
22532 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
22535 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
22536 parm_max
= TREE_OPERAND (parm_max
, 0);
22538 arg_max
= TYPE_MAX_VALUE (arg_dom
);
22539 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
22542 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
22543 trying to unify the type of a variable with the type
22544 of a template parameter. For example:
22546 template <unsigned int N>
22547 void f (char (&) [N]);
22554 Here, the type of the ARG will be "int [g(i)]", and
22555 may be a SAVE_EXPR, etc. */
22556 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
22557 return unify_vla_arg (explain_p
, arg_dom
);
22558 arg_max
= TREE_OPERAND (arg_max
, 0);
22561 /* If only one of the bounds used a MINUS_EXPR, compensate
22562 by adding one to the other bound. */
22563 if (parm_cst
&& !arg_cst
)
22564 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
22568 else if (arg_cst
&& !parm_cst
)
22569 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
22574 return unify (tparms
, targs
, parm_max
, arg_max
,
22575 UNIFY_ALLOW_INTEGER
, explain_p
);
22578 /* Returns whether T, a P or A in unify, is a type, template or expression. */
22580 enum pa_kind_t
{ pa_type
, pa_tmpl
, pa_expr
};
22585 if (PACK_EXPANSION_P (t
))
22586 t
= PACK_EXPANSION_PATTERN (t
);
22587 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
22588 || TREE_CODE (t
) == UNBOUND_CLASS_TEMPLATE
22589 || DECL_TYPE_TEMPLATE_P (t
))
22591 else if (TYPE_P (t
))
22597 /* Deduce the value of template parameters. TPARMS is the (innermost)
22598 set of template parameters to a template. TARGS is the bindings
22599 for those template parameters, as determined thus far; TARGS may
22600 include template arguments for outer levels of template parameters
22601 as well. PARM is a parameter to a template function, or a
22602 subcomponent of that parameter; ARG is the corresponding argument.
22603 This function attempts to match PARM with ARG in a manner
22604 consistent with the existing assignments in TARGS. If more values
22605 are deduced, then TARGS is updated.
22607 Returns 0 if the type deduction succeeds, 1 otherwise. The
22608 parameter STRICT is a bitwise or of the following flags:
22611 Require an exact match between PARM and ARG.
22612 UNIFY_ALLOW_MORE_CV_QUAL:
22613 Allow the deduced ARG to be more cv-qualified (by qualification
22614 conversion) than ARG.
22615 UNIFY_ALLOW_LESS_CV_QUAL:
22616 Allow the deduced ARG to be less cv-qualified than ARG.
22617 UNIFY_ALLOW_DERIVED:
22618 Allow the deduced ARG to be a template base class of ARG,
22619 or a pointer to a template base class of the type pointed to by
22621 UNIFY_ALLOW_INTEGER:
22622 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
22623 case for more information.
22624 UNIFY_ALLOW_OUTER_LEVEL:
22625 This is the outermost level of a deduction. Used to determine validity
22626 of qualification conversions. A valid qualification conversion must
22627 have const qualified pointers leading up to the inner type which
22628 requires additional CV quals, except at the outer level, where const
22629 is not required [conv.qual]. It would be normal to set this flag in
22630 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
22631 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
22632 This is the outermost level of a deduction, and PARM can be more CV
22633 qualified at this point.
22634 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
22635 This is the outermost level of a deduction, and PARM can be less CV
22636 qualified at this point. */
22639 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
22645 int strict_in
= strict
;
22646 tsubst_flags_t complain
= (explain_p
22647 ? tf_warning_or_error
22650 /* I don't think this will do the right thing with respect to types.
22651 But the only case I've seen it in so far has been array bounds, where
22652 signedness is the only information lost, and I think that will be
22653 okay. VIEW_CONVERT_EXPR can appear with class NTTP, thanks to
22654 finish_id_expression_1, and are also OK. */
22655 while (CONVERT_EXPR_P (parm
) || TREE_CODE (parm
) == VIEW_CONVERT_EXPR
)
22656 parm
= TREE_OPERAND (parm
, 0);
22658 if (arg
== error_mark_node
)
22659 return unify_invalid (explain_p
);
22660 if (arg
== unknown_type_node
22661 || arg
== init_list_type_node
)
22662 /* We can't deduce anything from this, but we might get all the
22663 template args from other function args. */
22664 return unify_success (explain_p
);
22666 if (parm
== any_targ_node
|| arg
== any_targ_node
)
22667 return unify_success (explain_p
);
22669 /* If PARM uses template parameters, then we can't bail out here,
22670 even if ARG == PARM, since we won't record unifications for the
22671 template parameters. We might need them if we're trying to
22672 figure out which of two things is more specialized. */
22673 if (arg
== parm
&& !uses_template_parms (parm
))
22674 return unify_success (explain_p
);
22676 /* Handle init lists early, so the rest of the function can assume
22677 we're dealing with a type. */
22678 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
22682 tree orig_parm
= parm
;
22684 if (!is_std_init_list (parm
)
22685 && TREE_CODE (parm
) != ARRAY_TYPE
)
22686 /* We can only deduce from an initializer list argument if the
22687 parameter is std::initializer_list or an array; otherwise this
22688 is a non-deduced context. */
22689 return unify_success (explain_p
);
22691 if (TREE_CODE (parm
) == ARRAY_TYPE
)
22692 elttype
= TREE_TYPE (parm
);
22695 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
22696 /* Deduction is defined in terms of a single type, so just punt
22697 on the (bizarre) std::initializer_list<T...>. */
22698 if (PACK_EXPANSION_P (elttype
))
22699 return unify_success (explain_p
);
22702 if (strict
!= DEDUCE_EXACT
22703 && TYPE_P (elttype
)
22704 && !uses_deducible_template_parms (elttype
))
22705 /* If ELTTYPE has no deducible template parms, skip deduction from
22706 the list elements. */;
22708 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
22710 int elt_strict
= strict
;
22712 if (elt
== error_mark_node
)
22713 return unify_invalid (explain_p
);
22715 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
22717 tree type
= TREE_TYPE (elt
);
22718 if (type
== error_mark_node
)
22719 return unify_invalid (explain_p
);
22720 /* It should only be possible to get here for a call. */
22721 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
22722 elt_strict
|= maybe_adjust_types_for_deduction
22723 (DEDUCE_CALL
, &elttype
, &type
, elt
);
22727 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
22731 if (TREE_CODE (parm
) == ARRAY_TYPE
22732 && deducible_array_bound (TYPE_DOMAIN (parm
)))
22734 /* Also deduce from the length of the initializer list. */
22735 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
22736 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
22737 if (idx
== error_mark_node
)
22738 return unify_invalid (explain_p
);
22739 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
22743 /* If the std::initializer_list<T> deduction worked, replace the
22744 deduced A with std::initializer_list<A>. */
22745 if (orig_parm
!= parm
)
22747 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
22748 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
22749 targ
= listify (targ
);
22750 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
22752 return unify_success (explain_p
);
22755 /* If parm and arg aren't the same kind of thing (template, type, or
22756 expression), fail early. */
22757 if (pa_kind (parm
) != pa_kind (arg
))
22758 return unify_invalid (explain_p
);
22760 /* Immediately reject some pairs that won't unify because of
22761 cv-qualification mismatches. */
22762 if (TREE_CODE (arg
) == TREE_CODE (parm
)
22764 /* It is the elements of the array which hold the cv quals of an array
22765 type, and the elements might be template type parms. We'll check
22766 when we recurse. */
22767 && TREE_CODE (arg
) != ARRAY_TYPE
22768 /* We check the cv-qualifiers when unifying with template type
22769 parameters below. We want to allow ARG `const T' to unify with
22770 PARM `T' for example, when computing which of two templates
22771 is more specialized, for example. */
22772 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
22773 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
22774 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22776 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
22777 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
22778 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
22779 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
22780 strict
&= ~UNIFY_ALLOW_DERIVED
;
22781 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
22782 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
22784 switch (TREE_CODE (parm
))
22786 case TYPENAME_TYPE
:
22788 case UNBOUND_CLASS_TEMPLATE
:
22789 /* In a type which contains a nested-name-specifier, template
22790 argument values cannot be deduced for template parameters used
22791 within the nested-name-specifier. */
22792 return unify_success (explain_p
);
22794 case TEMPLATE_TYPE_PARM
:
22795 case TEMPLATE_TEMPLATE_PARM
:
22796 case BOUND_TEMPLATE_TEMPLATE_PARM
:
22797 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
22798 if (error_operand_p (tparm
))
22799 return unify_invalid (explain_p
);
22801 if (TEMPLATE_TYPE_LEVEL (parm
)
22802 != template_decl_level (tparm
))
22803 /* The PARM is not one we're trying to unify. Just check
22804 to see if it matches ARG. */
22806 if (TREE_CODE (arg
) == TREE_CODE (parm
)
22807 && (is_auto (parm
) ? is_auto (arg
)
22808 : same_type_p (parm
, arg
)))
22809 return unify_success (explain_p
);
22811 return unify_type_mismatch (explain_p
, parm
, arg
);
22813 idx
= TEMPLATE_TYPE_IDX (parm
);
22814 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
22815 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
22816 if (error_operand_p (tparm
))
22817 return unify_invalid (explain_p
);
22819 /* Check for mixed types and values. */
22820 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
22821 && TREE_CODE (tparm
) != TYPE_DECL
)
22822 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
22823 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
22824 gcc_unreachable ();
22826 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22828 if ((strict_in
& UNIFY_ALLOW_DERIVED
)
22829 && CLASS_TYPE_P (arg
))
22831 /* First try to match ARG directly. */
22832 tree t
= try_class_unification (tparms
, targs
, parm
, arg
,
22836 /* Otherwise, look for a suitable base of ARG, as below. */
22837 enum template_base_result r
;
22838 r
= get_template_base (tparms
, targs
, parm
, arg
,
22841 return unify_no_common_base (explain_p
, r
, parm
, arg
);
22845 /* ARG must be constructed from a template class or a template
22846 template parameter. */
22847 else if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
22848 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
22849 return unify_template_deduction_failure (explain_p
, parm
, arg
);
22851 /* Deduce arguments T, i from TT<T> or TT<i>. */
22852 if (unify_bound_ttp_args (tparms
, targs
, parm
, arg
, explain_p
))
22855 arg
= TYPE_TI_TEMPLATE (arg
);
22857 /* Fall through to deduce template name. */
22860 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
22861 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22863 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
22865 /* Simple cases: Value already set, does match or doesn't. */
22866 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
22867 return unify_success (explain_p
);
22869 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
22873 /* If PARM is `const T' and ARG is only `int', we don't have
22874 a match unless we are allowing additional qualification.
22875 If ARG is `const int' and PARM is just `T' that's OK;
22876 that binds `const int' to `T'. */
22877 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
22879 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22881 /* Consider the case where ARG is `const volatile int' and
22882 PARM is `const T'. Then, T should be `volatile int'. */
22883 arg
= cp_build_qualified_type_real
22884 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
22885 if (arg
== error_mark_node
)
22886 return unify_invalid (explain_p
);
22888 /* Simple cases: Value already set, does match or doesn't. */
22889 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
22890 return unify_success (explain_p
);
22892 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
22894 /* Make sure that ARG is not a variable-sized array. (Note
22895 that were talking about variable-sized arrays (like
22896 `int[n]'), rather than arrays of unknown size (like
22897 `int[]').) We'll get very confused by such a type since
22898 the bound of the array is not constant, and therefore
22899 not mangleable. Besides, such types are not allowed in
22900 ISO C++, so we can do as we please here. We do allow
22901 them for 'auto' deduction, since that isn't ABI-exposed. */
22902 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
22903 return unify_vla_arg (explain_p
, arg
);
22905 /* Strip typedefs as in convert_template_argument. */
22906 arg
= canonicalize_type_argument (arg
, tf_none
);
22909 /* If ARG is a parameter pack or an expansion, we cannot unify
22910 against it unless PARM is also a parameter pack. */
22911 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
22912 && !template_parameter_pack_p (parm
))
22913 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
22915 /* If the argument deduction results is a METHOD_TYPE,
22916 then there is a problem.
22917 METHOD_TYPE doesn't map to any real C++ type the result of
22918 the deduction cannot be of that type. */
22919 if (TREE_CODE (arg
) == METHOD_TYPE
)
22920 return unify_method_type_error (explain_p
, arg
);
22922 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
22923 return unify_success (explain_p
);
22925 case TEMPLATE_PARM_INDEX
:
22926 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
22927 if (error_operand_p (tparm
))
22928 return unify_invalid (explain_p
);
22930 if (TEMPLATE_PARM_LEVEL (parm
)
22931 != template_decl_level (tparm
))
22933 /* The PARM is not one we're trying to unify. Just check
22934 to see if it matches ARG. */
22935 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
22936 && cp_tree_equal (parm
, arg
));
22938 unify_expression_unequal (explain_p
, parm
, arg
);
22942 idx
= TEMPLATE_PARM_IDX (parm
);
22943 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
22947 if ((strict
& UNIFY_ALLOW_INTEGER
)
22948 && TREE_TYPE (targ
) && TREE_TYPE (arg
)
22949 && CP_INTEGRAL_TYPE_P (TREE_TYPE (targ
)))
22950 /* We're deducing from an array bound, the type doesn't matter. */
22951 arg
= fold_convert (TREE_TYPE (targ
), arg
);
22952 int x
= !cp_tree_equal (targ
, arg
);
22954 unify_inconsistency (explain_p
, parm
, targ
, arg
);
22958 /* [temp.deduct.type] If, in the declaration of a function template
22959 with a non-type template-parameter, the non-type
22960 template-parameter is used in an expression in the function
22961 parameter-list and, if the corresponding template-argument is
22962 deduced, the template-argument type shall match the type of the
22963 template-parameter exactly, except that a template-argument
22964 deduced from an array bound may be of any integral type.
22965 The non-type parameter might use already deduced type parameters. */
22966 tparm
= TREE_TYPE (parm
);
22967 if (TEMPLATE_PARM_LEVEL (parm
) > TMPL_ARGS_DEPTH (targs
))
22968 /* We don't have enough levels of args to do any substitution. This
22969 can happen in the context of -fnew-ttp-matching. */;
22972 ++processing_template_decl
;
22973 tparm
= tsubst (tparm
, targs
, tf_none
, NULL_TREE
);
22974 --processing_template_decl
;
22976 if (tree a
= type_uses_auto (tparm
))
22978 tparm
= do_auto_deduction (tparm
, arg
, a
, complain
, adc_unify
);
22979 if (tparm
== error_mark_node
)
22984 if (!TREE_TYPE (arg
))
22985 /* Template-parameter dependent expression. Just accept it for now.
22986 It will later be processed in convert_template_argument. */
22988 else if (same_type_ignoring_top_level_qualifiers_p
22989 (non_reference (TREE_TYPE (arg
)),
22990 non_reference (tparm
)))
22991 /* OK. Ignore top-level quals here because a class-type template
22992 parameter object is const. */;
22993 else if ((strict
& UNIFY_ALLOW_INTEGER
)
22994 && CP_INTEGRAL_TYPE_P (tparm
))
22995 /* Convert the ARG to the type of PARM; the deduced non-type
22996 template argument must exactly match the types of the
22997 corresponding parameter. */
22998 arg
= fold (build_nop (tparm
, arg
));
22999 else if (uses_template_parms (tparm
))
23001 /* We haven't deduced the type of this parameter yet. */
23002 if (cxx_dialect
>= cxx17
23003 /* We deduce from array bounds in try_array_deduction. */
23004 && !(strict
& UNIFY_ALLOW_INTEGER
))
23006 /* Deduce it from the non-type argument. */
23007 tree atype
= TREE_TYPE (arg
);
23008 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
23010 UNIFY_ALLOW_NONE
, explain_p
);
23013 /* Try again later. */
23014 return unify_success (explain_p
);
23017 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
23019 /* If ARG is a parameter pack or an expansion, we cannot unify
23020 against it unless PARM is also a parameter pack. */
23021 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
23022 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
23023 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
23026 bool removed_attr
= false;
23027 arg
= strip_typedefs_expr (arg
, &removed_attr
);
23029 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
23030 return unify_success (explain_p
);
23034 /* A pointer-to-member constant can be unified only with
23035 another constant. */
23036 if (TREE_CODE (arg
) != PTRMEM_CST
)
23037 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
23039 /* Just unify the class member. It would be useless (and possibly
23040 wrong, depending on the strict flags) to unify also
23041 PTRMEM_CST_CLASS, because we want to be sure that both parm and
23042 arg refer to the same variable, even if through different
23043 classes. For instance:
23045 struct A { int x; };
23048 Unification of &A::x and &B::x must succeed. */
23049 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
23050 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
23055 if (!TYPE_PTR_P (arg
))
23056 return unify_type_mismatch (explain_p
, parm
, arg
);
23058 /* [temp.deduct.call]
23060 A can be another pointer or pointer to member type that can
23061 be converted to the deduced A via a qualification
23062 conversion (_conv.qual_).
23064 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
23065 This will allow for additional cv-qualification of the
23066 pointed-to types if appropriate. */
23068 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
23069 /* The derived-to-base conversion only persists through one
23070 level of pointers. */
23071 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
23073 return unify (tparms
, targs
, TREE_TYPE (parm
),
23074 TREE_TYPE (arg
), strict
, explain_p
);
23077 case REFERENCE_TYPE
:
23078 if (!TYPE_REF_P (arg
))
23079 return unify_type_mismatch (explain_p
, parm
, arg
);
23080 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
23081 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
23084 if (TREE_CODE (arg
) != ARRAY_TYPE
)
23085 return unify_type_mismatch (explain_p
, parm
, arg
);
23086 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
23087 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
23088 return unify_type_mismatch (explain_p
, parm
, arg
);
23089 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
23090 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
23091 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
23092 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
23093 TYPE_DOMAIN (arg
), explain_p
);
23094 return unify_success (explain_p
);
23101 case ENUMERAL_TYPE
:
23104 if (TREE_CODE (arg
) != TREE_CODE (parm
))
23105 return unify_type_mismatch (explain_p
, parm
, arg
);
23107 /* We have already checked cv-qualification at the top of the
23109 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
23110 return unify_type_mismatch (explain_p
, parm
, arg
);
23112 /* As far as unification is concerned, this wins. Later checks
23113 will invalidate it if necessary. */
23114 return unify_success (explain_p
);
23116 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
23117 /* Type INTEGER_CST can come from ordinary constant template args. */
23119 while (CONVERT_EXPR_P (arg
))
23120 arg
= TREE_OPERAND (arg
, 0);
23122 if (TREE_CODE (arg
) != INTEGER_CST
)
23123 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
23124 return (tree_int_cst_equal (parm
, arg
)
23125 ? unify_success (explain_p
)
23126 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
23130 int i
, len
, argslen
;
23131 int parm_variadic_p
= 0;
23133 if (TREE_CODE (arg
) != TREE_VEC
)
23134 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
23136 len
= TREE_VEC_LENGTH (parm
);
23137 argslen
= TREE_VEC_LENGTH (arg
);
23139 /* Check for pack expansions in the parameters. */
23140 for (i
= 0; i
< len
; ++i
)
23142 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
23145 /* We can unify against something with a trailing
23147 parm_variadic_p
= 1;
23149 /* [temp.deduct.type]/9: If the template argument list of
23150 P contains a pack expansion that is not the last
23151 template argument, the entire template argument list
23152 is a non-deduced context. */
23153 return unify_success (explain_p
);
23157 /* If we don't have enough arguments to satisfy the parameters
23158 (not counting the pack expression at the end), or we have
23159 too many arguments for a parameter list that doesn't end in
23160 a pack expression, we can't unify. */
23161 if (parm_variadic_p
23162 ? argslen
< len
- parm_variadic_p
23164 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
23166 /* Unify all of the parameters that precede the (optional)
23167 pack expression. */
23168 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
23170 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
23171 TREE_VEC_ELT (parm
, i
),
23172 TREE_VEC_ELT (arg
, i
),
23173 UNIFY_ALLOW_NONE
, explain_p
);
23175 if (parm_variadic_p
)
23176 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
23178 /*subr=*/true, explain_p
);
23179 return unify_success (explain_p
);
23184 if (TREE_CODE (arg
) != TREE_CODE (parm
))
23185 return unify_type_mismatch (explain_p
, parm
, arg
);
23187 if (TYPE_PTRMEMFUNC_P (parm
))
23189 if (!TYPE_PTRMEMFUNC_P (arg
))
23190 return unify_type_mismatch (explain_p
, parm
, arg
);
23192 return unify (tparms
, targs
,
23193 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
23194 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
23195 strict
, explain_p
);
23197 else if (TYPE_PTRMEMFUNC_P (arg
))
23198 return unify_type_mismatch (explain_p
, parm
, arg
);
23200 if (CLASSTYPE_TEMPLATE_INFO (parm
))
23202 tree t
= NULL_TREE
;
23204 if (strict_in
& UNIFY_ALLOW_DERIVED
)
23206 /* First, we try to unify the PARM and ARG directly. */
23207 t
= try_class_unification (tparms
, targs
,
23208 parm
, arg
, explain_p
);
23212 /* Fallback to the special case allowed in
23213 [temp.deduct.call]:
23215 If P is a class, and P has the form
23216 template-id, then A can be a derived class of
23217 the deduced A. Likewise, if P is a pointer to
23218 a class of the form template-id, A can be a
23219 pointer to a derived class pointed to by the
23221 enum template_base_result r
;
23222 r
= get_template_base (tparms
, targs
, parm
, arg
,
23227 /* Don't give the derived diagnostic if we're
23228 already dealing with the same template. */
23230 = (CLASSTYPE_TEMPLATE_INFO (arg
)
23231 && (CLASSTYPE_TI_TEMPLATE (parm
)
23232 == CLASSTYPE_TI_TEMPLATE (arg
)));
23233 return unify_no_common_base (explain_p
&& !same_template
,
23238 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
23239 && (CLASSTYPE_TI_TEMPLATE (parm
)
23240 == CLASSTYPE_TI_TEMPLATE (arg
)))
23241 /* Perhaps PARM is something like S<U> and ARG is S<int>.
23242 Then, we should unify `int' and `U'. */
23245 /* There's no chance of unification succeeding. */
23246 return unify_type_mismatch (explain_p
, parm
, arg
);
23248 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
23249 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
23251 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
23252 return unify_type_mismatch (explain_p
, parm
, arg
);
23253 return unify_success (explain_p
);
23256 case FUNCTION_TYPE
:
23258 unsigned int nargs
;
23263 if (TREE_CODE (arg
) != TREE_CODE (parm
))
23264 return unify_type_mismatch (explain_p
, parm
, arg
);
23266 /* CV qualifications for methods can never be deduced, they must
23267 match exactly. We need to check them explicitly here,
23268 because type_unification_real treats them as any other
23269 cv-qualified parameter. */
23270 if (TREE_CODE (parm
) == METHOD_TYPE
23271 && (!check_cv_quals_for_unify
23273 class_of_this_parm (arg
),
23274 class_of_this_parm (parm
))))
23275 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
23276 if (TREE_CODE (arg
) == FUNCTION_TYPE
23277 && type_memfn_quals (parm
) != type_memfn_quals (arg
))
23278 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
23279 if (type_memfn_rqual (parm
) != type_memfn_rqual (arg
))
23280 return unify_type_mismatch (explain_p
, parm
, arg
);
23282 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
23283 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
23285 nargs
= list_length (TYPE_ARG_TYPES (arg
));
23286 args
= XALLOCAVEC (tree
, nargs
);
23287 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
23288 a
!= NULL_TREE
&& a
!= void_list_node
;
23289 a
= TREE_CHAIN (a
), ++i
)
23290 args
[i
] = TREE_VALUE (a
);
23293 if (type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
23294 args
, nargs
, 1, DEDUCE_EXACT
,
23298 if (flag_noexcept_type
)
23300 tree pspec
= TYPE_RAISES_EXCEPTIONS (parm
);
23301 tree aspec
= canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (arg
));
23302 if (pspec
== NULL_TREE
) pspec
= noexcept_false_spec
;
23303 if (aspec
== NULL_TREE
) aspec
= noexcept_false_spec
;
23304 if (TREE_PURPOSE (pspec
) && TREE_PURPOSE (aspec
)
23305 && uses_template_parms (TREE_PURPOSE (pspec
)))
23306 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_PURPOSE (pspec
),
23307 TREE_PURPOSE (aspec
),
23308 UNIFY_ALLOW_NONE
, explain_p
);
23309 else if (nothrow_spec_p (pspec
) && !nothrow_spec_p (aspec
))
23310 return unify_type_mismatch (explain_p
, parm
, arg
);
23317 /* Unify a pointer to member with a pointer to member function, which
23318 deduces the type of the member as a function type. */
23319 if (TYPE_PTRMEMFUNC_P (arg
))
23321 /* Check top-level cv qualifiers */
23322 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
23323 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
23325 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
23326 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
23327 UNIFY_ALLOW_NONE
, explain_p
);
23329 /* Determine the type of the function we are unifying against. */
23330 tree fntype
= static_fn_type (arg
);
23332 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
23335 if (TREE_CODE (arg
) != OFFSET_TYPE
)
23336 return unify_type_mismatch (explain_p
, parm
, arg
);
23337 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
23338 TYPE_OFFSET_BASETYPE (arg
),
23339 UNIFY_ALLOW_NONE
, explain_p
);
23340 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
23341 strict
, explain_p
);
23344 if (DECL_TEMPLATE_PARM_P (parm
))
23345 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
23346 if (arg
!= scalar_constant_value (parm
))
23347 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
23348 return unify_success (explain_p
);
23351 case TEMPLATE_DECL
:
23352 /* Matched cases are handled by the ARG == PARM test above. */
23353 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
23356 /* We might get a variable as a non-type template argument in parm if the
23357 corresponding parameter is type-dependent. Make any necessary
23358 adjustments based on whether arg is a reference. */
23359 if (CONSTANT_CLASS_P (arg
))
23360 parm
= fold_non_dependent_expr (parm
, complain
);
23361 else if (REFERENCE_REF_P (arg
))
23363 tree sub
= TREE_OPERAND (arg
, 0);
23365 if (TREE_CODE (sub
) == ADDR_EXPR
)
23366 arg
= TREE_OPERAND (sub
, 0);
23368 /* Now use the normal expression code to check whether they match. */
23371 case TYPE_ARGUMENT_PACK
:
23372 case NONTYPE_ARGUMENT_PACK
:
23373 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
23374 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
23377 case DECLTYPE_TYPE
:
23378 case UNDERLYING_TYPE
:
23379 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
23380 or UNDERLYING_TYPE nodes. */
23381 return unify_success (explain_p
);
23384 /* Unification fails if we hit an error node. */
23385 return unify_invalid (explain_p
);
23388 if (REFERENCE_REF_P (parm
))
23390 bool pexp
= PACK_EXPANSION_P (arg
);
23392 arg
= PACK_EXPANSION_PATTERN (arg
);
23393 if (REFERENCE_REF_P (arg
))
23394 arg
= TREE_OPERAND (arg
, 0);
23396 arg
= make_pack_expansion (arg
, complain
);
23397 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
23398 strict
, explain_p
);
23403 /* An unresolved overload is a nondeduced context. */
23404 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
23405 return unify_success (explain_p
);
23406 gcc_assert (EXPR_P (parm
)
23407 || COMPOUND_LITERAL_P (parm
)
23408 || TREE_CODE (parm
) == TRAIT_EXPR
);
23410 /* We must be looking at an expression. This can happen with
23414 void foo(S<I>, S<I + 2>);
23418 template<typename T>
23419 void foo(A<T, T{}>);
23421 This is a "non-deduced context":
23425 The non-deduced contexts are:
23427 --A non-type template argument or an array bound in which
23428 a subexpression references a template parameter.
23430 In these cases, we assume deduction succeeded, but don't
23431 actually infer any unifications. */
23433 if (!uses_template_parms (parm
)
23434 && !template_args_equal (parm
, arg
))
23435 return unify_expression_unequal (explain_p
, parm
, arg
);
23437 return unify_success (explain_p
);
23440 #undef RECUR_AND_CHECK_FAILURE
23442 /* Note that DECL can be defined in this translation unit, if
23446 mark_definable (tree decl
)
23449 DECL_NOT_REALLY_EXTERN (decl
) = 1;
23450 FOR_EACH_CLONE (clone
, decl
)
23451 DECL_NOT_REALLY_EXTERN (clone
) = 1;
23454 /* Called if RESULT is explicitly instantiated, or is a member of an
23455 explicitly instantiated class. */
23458 mark_decl_instantiated (tree result
, int extern_p
)
23460 SET_DECL_EXPLICIT_INSTANTIATION (result
);
23462 /* If this entity has already been written out, it's too late to
23463 make any modifications. */
23464 if (TREE_ASM_WRITTEN (result
))
23467 /* For anonymous namespace we don't need to do anything. */
23468 if (decl_anon_ns_mem_p (result
))
23470 gcc_assert (!TREE_PUBLIC (result
));
23474 if (TREE_CODE (result
) != FUNCTION_DECL
)
23475 /* The TREE_PUBLIC flag for function declarations will have been
23476 set correctly by tsubst. */
23477 TREE_PUBLIC (result
) = 1;
23479 /* This might have been set by an earlier implicit instantiation. */
23480 DECL_COMDAT (result
) = 0;
23483 DECL_NOT_REALLY_EXTERN (result
) = 0;
23486 mark_definable (result
);
23487 mark_needed (result
);
23488 /* Always make artificials weak. */
23489 if (DECL_ARTIFICIAL (result
) && flag_weak
)
23490 comdat_linkage (result
);
23491 /* For WIN32 we also want to put explicit instantiations in
23492 linkonce sections. */
23493 else if (TREE_PUBLIC (result
))
23494 maybe_make_one_only (result
);
23495 if (TREE_CODE (result
) == FUNCTION_DECL
23496 && DECL_TEMPLATE_INSTANTIATED (result
))
23497 /* If the function has already been instantiated, clear DECL_EXTERNAL,
23498 since start_preparsed_function wouldn't have if we had an earlier
23499 extern explicit instantiation. */
23500 DECL_EXTERNAL (result
) = 0;
23503 /* If EXTERN_P, then this function will not be emitted -- unless
23504 followed by an explicit instantiation, at which point its linkage
23505 will be adjusted. If !EXTERN_P, then this function will be
23506 emitted here. In neither circumstance do we want
23507 import_export_decl to adjust the linkage. */
23508 DECL_INTERFACE_KNOWN (result
) = 1;
23511 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
23512 important template arguments. If any are missing, we check whether
23513 they're important by using error_mark_node for substituting into any
23514 args that were used for partial ordering (the ones between ARGS and END)
23515 and seeing if it bubbles up. */
23518 check_undeduced_parms (tree targs
, tree args
, tree end
)
23520 bool found
= false;
23522 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
23523 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
23526 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
23530 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
23531 if (substed
== error_mark_node
)
23537 /* Given two function templates PAT1 and PAT2, return:
23539 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
23540 -1 if PAT2 is more specialized than PAT1.
23541 0 if neither is more specialized.
23543 LEN indicates the number of parameters we should consider
23544 (defaulted parameters should not be considered).
23546 The 1998 std underspecified function template partial ordering, and
23547 DR214 addresses the issue. We take pairs of arguments, one from
23548 each of the templates, and deduce them against each other. One of
23549 the templates will be more specialized if all the *other*
23550 template's arguments deduce against its arguments and at least one
23551 of its arguments *does* *not* deduce against the other template's
23552 corresponding argument. Deduction is done as for class templates.
23553 The arguments used in deduction have reference and top level cv
23554 qualifiers removed. Iff both arguments were originally reference
23555 types *and* deduction succeeds in both directions, an lvalue reference
23556 wins against an rvalue reference and otherwise the template
23557 with the more cv-qualified argument wins for that pairing (if
23558 neither is more cv-qualified, they both are equal). Unlike regular
23559 deduction, after all the arguments have been deduced in this way,
23560 we do *not* verify the deduced template argument values can be
23561 substituted into non-deduced contexts.
23563 The logic can be a bit confusing here, because we look at deduce1 and
23564 targs1 to see if pat2 is at least as specialized, and vice versa; if we
23565 can find template arguments for pat1 to make arg1 look like arg2, that
23566 means that arg2 is at least as specialized as arg1. */
23569 more_specialized_fn (tree pat1
, tree pat2
, int len
)
23571 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
23572 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
23573 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
23574 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
23575 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
23576 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
23577 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
23578 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
23579 tree origs1
, origs2
;
23580 bool lose1
= false;
23581 bool lose2
= false;
23583 /* Remove the this parameter from non-static member functions. If
23584 one is a non-static member function and the other is not a static
23585 member function, remove the first parameter from that function
23586 also. This situation occurs for operator functions where we
23587 locate both a member function (with this pointer) and non-member
23588 operator (with explicit first operand). */
23589 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
23591 len
--; /* LEN is the number of significant arguments for DECL1 */
23592 args1
= TREE_CHAIN (args1
);
23593 if (!DECL_STATIC_FUNCTION_P (decl2
))
23594 args2
= TREE_CHAIN (args2
);
23596 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
23598 args2
= TREE_CHAIN (args2
);
23599 if (!DECL_STATIC_FUNCTION_P (decl1
))
23602 args1
= TREE_CHAIN (args1
);
23606 /* If only one is a conversion operator, they are unordered. */
23607 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
23610 /* Consider the return type for a conversion function */
23611 if (DECL_CONV_FN_P (decl1
))
23613 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
23614 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
23618 processing_template_decl
++;
23624 /* Stop when an ellipsis is seen. */
23625 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
23627 tree arg1
= TREE_VALUE (args1
);
23628 tree arg2
= TREE_VALUE (args2
);
23629 int deduce1
, deduce2
;
23635 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
23636 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
23638 /* When both arguments are pack expansions, we need only
23639 unify the patterns themselves. */
23640 arg1
= PACK_EXPANSION_PATTERN (arg1
);
23641 arg2
= PACK_EXPANSION_PATTERN (arg2
);
23643 /* This is the last comparison we need to do. */
23647 /* DR 1847: If a particular P contains no template-parameters that
23648 participate in template argument deduction, that P is not used to
23649 determine the ordering. */
23650 if (!uses_deducible_template_parms (arg1
)
23651 && !uses_deducible_template_parms (arg2
))
23654 if (TYPE_REF_P (arg1
))
23656 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
23657 arg1
= TREE_TYPE (arg1
);
23658 quals1
= cp_type_quals (arg1
);
23661 if (TYPE_REF_P (arg2
))
23663 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
23664 arg2
= TREE_TYPE (arg2
);
23665 quals2
= cp_type_quals (arg2
);
23668 arg1
= TYPE_MAIN_VARIANT (arg1
);
23669 arg2
= TYPE_MAIN_VARIANT (arg2
);
23671 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
23673 int i
, len2
= remaining_arguments (args2
);
23674 tree parmvec
= make_tree_vec (1);
23675 tree argvec
= make_tree_vec (len2
);
23678 /* Setup the parameter vector, which contains only ARG1. */
23679 TREE_VEC_ELT (parmvec
, 0) = arg1
;
23681 /* Setup the argument vector, which contains the remaining
23683 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
23684 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
23686 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
23687 argvec
, DEDUCE_EXACT
,
23688 /*subr=*/true, /*explain_p=*/false)
23691 /* We cannot deduce in the other direction, because ARG1 is
23692 a pack expansion but ARG2 is not. */
23695 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
23697 int i
, len1
= remaining_arguments (args1
);
23698 tree parmvec
= make_tree_vec (1);
23699 tree argvec
= make_tree_vec (len1
);
23702 /* Setup the parameter vector, which contains only ARG1. */
23703 TREE_VEC_ELT (parmvec
, 0) = arg2
;
23705 /* Setup the argument vector, which contains the remaining
23707 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
23708 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
23710 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
23711 argvec
, DEDUCE_EXACT
,
23712 /*subr=*/true, /*explain_p=*/false)
23715 /* We cannot deduce in the other direction, because ARG2 is
23716 a pack expansion but ARG1 is not.*/
23722 /* The normal case, where neither argument is a pack
23724 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
23725 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
23727 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
23728 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
23732 /* If we couldn't deduce arguments for tparms1 to make arg1 match
23733 arg2, then arg2 is not as specialized as arg1. */
23739 /* "If, for a given type, deduction succeeds in both directions
23740 (i.e., the types are identical after the transformations above)
23741 and both P and A were reference types (before being replaced with
23742 the type referred to above):
23743 - if the type from the argument template was an lvalue reference and
23744 the type from the parameter template was not, the argument type is
23745 considered to be more specialized than the other; otherwise,
23746 - if the type from the argument template is more cv-qualified
23747 than the type from the parameter template (as described above),
23748 the argument type is considered to be more specialized than the other;
23750 - neither type is more specialized than the other." */
23752 if (deduce1
&& deduce2
)
23754 if (ref1
&& ref2
&& ref1
!= ref2
)
23761 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
23763 if ((quals1
& quals2
) == quals2
)
23765 if ((quals1
& quals2
) == quals1
)
23770 if (lose1
&& lose2
)
23771 /* We've failed to deduce something in either direction.
23772 These must be unordered. */
23777 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
23778 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
23779 /* We have already processed all of the arguments in our
23780 handing of the pack expansion type. */
23783 args1
= TREE_CHAIN (args1
);
23784 args2
= TREE_CHAIN (args2
);
23787 /* "In most cases, all template parameters must have values in order for
23788 deduction to succeed, but for partial ordering purposes a template
23789 parameter may remain without a value provided it is not used in the
23790 types being used for partial ordering."
23792 Thus, if we are missing any of the targs1 we need to substitute into
23793 origs1, then pat2 is not as specialized as pat1. This can happen when
23794 there is a nondeduced context. */
23795 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
23797 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
23800 processing_template_decl
--;
23802 /* If both deductions succeed, the partial ordering selects the more
23803 constrained template. */
23804 if (!lose1
&& !lose2
)
23806 int winner
= more_constrained (decl1
, decl2
);
23809 else if (winner
< 0)
23813 /* All things being equal, if the next argument is a pack expansion
23814 for one function but not for the other, prefer the
23815 non-variadic function. FIXME this is bogus; see c++/41958. */
23817 && args1
&& TREE_VALUE (args1
)
23818 && args2
&& TREE_VALUE (args2
))
23820 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
23821 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
23824 if (lose1
== lose2
)
23832 /* Determine which of two partial specializations of TMPL is more
23835 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
23836 to the first partial specialization. The TREE_PURPOSE is the
23837 innermost set of template parameters for the partial
23838 specialization. PAT2 is similar, but for the second template.
23840 Return 1 if the first partial specialization is more specialized;
23841 -1 if the second is more specialized; 0 if neither is more
23844 See [temp.class.order] for information about determining which of
23845 two templates is more specialized. */
23848 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
23852 bool any_deductions
= false;
23854 tree tmpl1
= TREE_VALUE (pat1
);
23855 tree tmpl2
= TREE_VALUE (pat2
);
23856 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
23857 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
23859 /* Just like what happens for functions, if we are ordering between
23860 different template specializations, we may encounter dependent
23861 types in the arguments, and we need our dependency check functions
23862 to behave correctly. */
23863 ++processing_template_decl
;
23864 targs
= get_partial_spec_bindings (tmpl
, tmpl1
, specargs2
);
23868 any_deductions
= true;
23871 targs
= get_partial_spec_bindings (tmpl
, tmpl2
, specargs1
);
23875 any_deductions
= true;
23877 --processing_template_decl
;
23879 /* If both deductions succeed, the partial ordering selects the more
23880 constrained template. */
23881 if (!winner
&& any_deductions
)
23882 winner
= more_constrained (tmpl1
, tmpl2
);
23884 /* In the case of a tie where at least one of the templates
23885 has a parameter pack at the end, the template with the most
23886 non-packed parameters wins. */
23889 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
23890 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
23892 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
23893 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
23894 int len1
= TREE_VEC_LENGTH (args1
);
23895 int len2
= TREE_VEC_LENGTH (args2
);
23897 /* We don't count the pack expansion at the end. */
23898 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
23900 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
23905 else if (len1
< len2
)
23912 /* Return the template arguments that will produce the function signature
23913 DECL from the function template FN, with the explicit template
23914 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
23915 also match. Return NULL_TREE if no satisfactory arguments could be
23919 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
23921 int ntparms
= DECL_NTPARMS (fn
);
23922 tree targs
= make_tree_vec (ntparms
);
23923 tree decl_type
= TREE_TYPE (decl
);
23924 tree decl_arg_types
;
23926 unsigned int nargs
, ix
;
23929 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
23931 /* Never do unification on the 'this' parameter. */
23932 decl_arg_types
= skip_artificial_parms_for (decl
,
23933 TYPE_ARG_TYPES (decl_type
));
23935 nargs
= list_length (decl_arg_types
);
23936 args
= XALLOCAVEC (tree
, nargs
);
23937 for (arg
= decl_arg_types
, ix
= 0;
23938 arg
!= NULL_TREE
&& arg
!= void_list_node
;
23939 arg
= TREE_CHAIN (arg
), ++ix
)
23940 args
[ix
] = TREE_VALUE (arg
);
23942 if (fn_type_unification (fn
, explicit_args
, targs
,
23944 (check_rettype
|| DECL_CONV_FN_P (fn
)
23945 ? TREE_TYPE (decl_type
) : NULL_TREE
),
23946 DEDUCE_EXACT
, LOOKUP_NORMAL
, NULL
,
23947 /*explain_p=*/false,
23949 == error_mark_node
)
23955 /* Return the innermost template arguments that, when applied to a partial
23956 specialization SPEC_TMPL of TMPL, yield the ARGS.
23958 For example, suppose we have:
23960 template <class T, class U> struct S {};
23961 template <class T> struct S<T*, int> {};
23963 Then, suppose we want to get `S<double*, int>'. SPEC_TMPL will be the
23964 partial specialization and the ARGS will be {double*, int}. The resulting
23965 vector will be {double}, indicating that `T' is bound to `double'. */
23968 get_partial_spec_bindings (tree tmpl
, tree spec_tmpl
, tree args
)
23970 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
23972 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (spec_tmpl
)));
23973 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
23975 tree innermost_deduced_args
;
23977 innermost_deduced_args
= make_tree_vec (ntparms
);
23978 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
23980 deduced_args
= copy_node (args
);
23981 SET_TMPL_ARGS_LEVEL (deduced_args
,
23982 TMPL_ARGS_DEPTH (deduced_args
),
23983 innermost_deduced_args
);
23986 deduced_args
= innermost_deduced_args
;
23988 bool tried_array_deduction
= (cxx_dialect
< cxx17
);
23990 if (unify (tparms
, deduced_args
,
23991 INNERMOST_TEMPLATE_ARGS (spec_args
),
23992 INNERMOST_TEMPLATE_ARGS (args
),
23993 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
23996 for (i
= 0; i
< ntparms
; ++i
)
23997 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
23999 if (!tried_array_deduction
)
24001 try_array_deduction (tparms
, innermost_deduced_args
,
24002 INNERMOST_TEMPLATE_ARGS (spec_args
));
24003 tried_array_deduction
= true;
24004 if (TREE_VEC_ELT (innermost_deduced_args
, i
))
24010 if (!push_tinst_level (spec_tmpl
, deduced_args
))
24012 excessive_deduction_depth
= true;
24016 /* Verify that nondeduced template arguments agree with the type
24017 obtained from argument deduction.
24021 struct A { typedef int X; };
24022 template <class T, class U> struct C {};
24023 template <class T> struct C<T, typename T::X> {};
24025 Then with the instantiation `C<A, int>', we can deduce that
24026 `T' is `A' but unify () does not check whether `typename T::X'
24028 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
24030 if (spec_args
!= error_mark_node
)
24031 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
24032 INNERMOST_TEMPLATE_ARGS (spec_args
),
24033 tmpl
, tf_none
, false, false);
24035 pop_tinst_level ();
24037 if (spec_args
== error_mark_node
24038 /* We only need to check the innermost arguments; the other
24039 arguments will always agree. */
24040 || !comp_template_args_porder (INNERMOST_TEMPLATE_ARGS (spec_args
),
24041 INNERMOST_TEMPLATE_ARGS (args
)))
24044 /* Now that we have bindings for all of the template arguments,
24045 ensure that the arguments deduced for the template template
24046 parameters have compatible template parameter lists. See the use
24047 of template_template_parm_bindings_ok_p in fn_type_unification
24048 for more information. */
24049 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
24052 return deduced_args
;
24055 // Compare two function templates T1 and T2 by deducing bindings
24056 // from one against the other. If both deductions succeed, compare
24057 // constraints to see which is more constrained.
24059 more_specialized_inst (tree t1
, tree t2
)
24064 if (get_bindings (t1
, DECL_TEMPLATE_RESULT (t2
), NULL_TREE
, true))
24070 if (get_bindings (t2
, DECL_TEMPLATE_RESULT (t1
), NULL_TREE
, true))
24076 // If both deductions succeed, then one may be more constrained.
24077 if (count
== 2 && fate
== 0)
24078 fate
= more_constrained (t1
, t2
);
24083 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
24084 Return the TREE_LIST node with the most specialized template, if
24085 any. If there is no most specialized template, the error_mark_node
24088 Note that this function does not look at, or modify, the
24089 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
24090 returned is one of the elements of INSTANTIATIONS, callers may
24091 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
24092 and retrieve it from the value returned. */
24095 most_specialized_instantiation (tree templates
)
24099 ++processing_template_decl
;
24102 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
24104 gcc_assert (TREE_VALUE (champ
) != TREE_VALUE (fn
));
24105 int fate
= more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
));
24110 /* Equally specialized, move to next function. If there
24111 is no next function, nothing's most specialized. */
24112 fn
= TREE_CHAIN (fn
);
24120 /* Now verify that champ is better than everything earlier in the
24121 instantiation list. */
24122 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
)) {
24123 if (more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
)) != 1)
24130 processing_template_decl
--;
24133 return error_mark_node
;
24138 /* If DECL is a specialization of some template, return the most
24139 general such template. Otherwise, returns NULL_TREE.
24141 For example, given:
24143 template <class T> struct S { template <class U> void f(U); };
24145 if TMPL is `template <class U> void S<int>::f(U)' this will return
24146 the full template. This function will not trace past partial
24147 specializations, however. For example, given in addition:
24149 template <class T> struct S<T*> { template <class U> void f(U); };
24151 if TMPL is `template <class U> void S<int*>::f(U)' this will return
24152 `template <class T> template <class U> S<T*>::f(U)'. */
24155 most_general_template (tree decl
)
24157 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
24159 if (tree tinfo
= get_template_info (decl
))
24160 decl
= TI_TEMPLATE (tinfo
);
24161 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
24162 template friend, or a FIELD_DECL for a capture pack. */
24163 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
24167 /* Look for more and more general templates. */
24168 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
24170 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
24171 (See cp-tree.h for details.) */
24172 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
24175 if (CLASS_TYPE_P (TREE_TYPE (decl
))
24176 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
24177 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
24180 /* Stop if we run into an explicitly specialized class template. */
24181 if (!DECL_NAMESPACE_SCOPE_P (decl
)
24182 && DECL_CONTEXT (decl
)
24183 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
24186 decl
= DECL_TI_TEMPLATE (decl
);
24192 /* Return the most specialized of the template partial specializations
24193 which can produce TARGET, a specialization of some class or variable
24194 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
24195 a TEMPLATE_DECL node corresponding to the partial specialization, while
24196 the TREE_PURPOSE is the set of template arguments that must be
24197 substituted into the template pattern in order to generate TARGET.
24199 If the choice of partial specialization is ambiguous, a diagnostic
24200 is issued, and the error_mark_node is returned. If there are no
24201 partial specializations matching TARGET, then NULL_TREE is
24202 returned, indicating that the primary template should be used. */
24205 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
24207 tree list
= NULL_TREE
;
24212 tree outer_args
= NULL_TREE
;
24215 if (TYPE_P (target
))
24217 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
24218 tmpl
= TI_TEMPLATE (tinfo
);
24219 args
= TI_ARGS (tinfo
);
24221 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
24223 tmpl
= TREE_OPERAND (target
, 0);
24224 args
= TREE_OPERAND (target
, 1);
24226 else if (VAR_P (target
))
24228 tree tinfo
= DECL_TEMPLATE_INFO (target
);
24229 tmpl
= TI_TEMPLATE (tinfo
);
24230 args
= TI_ARGS (tinfo
);
24233 gcc_unreachable ();
24235 tree main_tmpl
= most_general_template (tmpl
);
24237 /* For determining which partial specialization to use, only the
24238 innermost args are interesting. */
24239 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
24241 outer_args
= strip_innermost_template_args (args
, 1);
24242 args
= INNERMOST_TEMPLATE_ARGS (args
);
24245 /* The caller hasn't called push_to_top_level yet, but we need
24246 get_partial_spec_bindings to be done in non-template context so that we'll
24247 fully resolve everything. */
24248 processing_template_decl_sentinel ptds
;
24250 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
24253 tree spec_tmpl
= TREE_VALUE (t
);
24257 /* Substitute in the template args from the enclosing class. */
24258 ++processing_template_decl
;
24259 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
24260 --processing_template_decl
;
24263 if (spec_tmpl
== error_mark_node
)
24264 return error_mark_node
;
24266 spec_args
= get_partial_spec_bindings (tmpl
, spec_tmpl
, args
);
24270 spec_args
= add_to_template_args (outer_args
, spec_args
);
24272 /* Keep the candidate only if the constraints are satisfied,
24273 or if we're not compiling with concepts. */
24275 || constraints_satisfied_p (spec_tmpl
, spec_args
))
24277 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
24278 TREE_TYPE (list
) = TREE_TYPE (t
);
24286 ambiguous_p
= false;
24289 t
= TREE_CHAIN (t
);
24290 for (; t
; t
= TREE_CHAIN (t
))
24292 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
24299 t
= TREE_CHAIN (t
);
24302 ambiguous_p
= true;
24311 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
24313 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
24316 ambiguous_p
= true;
24324 char *spaces
= NULL
;
24325 if (!(complain
& tf_error
))
24326 return error_mark_node
;
24327 if (TYPE_P (target
))
24328 error ("ambiguous template instantiation for %q#T", target
);
24330 error ("ambiguous template instantiation for %q#D", target
);
24331 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
24332 for (t
= list
; t
; t
= TREE_CHAIN (t
))
24334 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
24335 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
24336 "%s %#qS", spaces
? spaces
: str
, subst
);
24337 spaces
= spaces
? spaces
: get_spaces (str
);
24340 return error_mark_node
;
24346 /* Explicitly instantiate DECL. */
24349 do_decl_instantiation (tree decl
, tree storage
)
24351 tree result
= NULL_TREE
;
24354 if (!decl
|| decl
== error_mark_node
)
24355 /* An error occurred, for which grokdeclarator has already issued
24356 an appropriate message. */
24358 else if (! DECL_LANG_SPECIFIC (decl
))
24360 error ("explicit instantiation of non-template %q#D", decl
);
24363 else if (DECL_DECLARED_CONCEPT_P (decl
))
24366 error ("explicit instantiation of variable concept %q#D", decl
);
24368 error ("explicit instantiation of function concept %q#D", decl
);
24372 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
24373 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
24375 if (VAR_P (decl
) && !var_templ
)
24377 /* There is an asymmetry here in the way VAR_DECLs and
24378 FUNCTION_DECLs are handled by grokdeclarator. In the case of
24379 the latter, the DECL we get back will be marked as a
24380 template instantiation, and the appropriate
24381 DECL_TEMPLATE_INFO will be set up. This does not happen for
24382 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
24383 should handle VAR_DECLs as it currently handles
24385 if (!DECL_CLASS_SCOPE_P (decl
))
24387 error ("%qD is not a static data member of a class template", decl
);
24390 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
24391 if (!result
|| !VAR_P (result
))
24393 error ("no matching template for %qD found", decl
);
24396 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
24398 error ("type %qT for explicit instantiation %qD does not match "
24399 "declared type %qT", TREE_TYPE (result
), decl
,
24404 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
24406 error ("explicit instantiation of %q#D", decl
);
24412 /* Check for various error cases. Note that if the explicit
24413 instantiation is valid the RESULT will currently be marked as an
24414 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
24415 until we get here. */
24417 if (DECL_TEMPLATE_SPECIALIZATION (result
))
24419 /* DR 259 [temp.spec].
24421 Both an explicit instantiation and a declaration of an explicit
24422 specialization shall not appear in a program unless the explicit
24423 instantiation follows a declaration of the explicit specialization.
24425 For a given set of template parameters, if an explicit
24426 instantiation of a template appears after a declaration of an
24427 explicit specialization for that template, the explicit
24428 instantiation has no effect. */
24431 else if (DECL_EXPLICIT_INSTANTIATION (result
))
24435 No program shall explicitly instantiate any template more
24438 We check DECL_NOT_REALLY_EXTERN so as not to complain when
24439 the first instantiation was `extern' and the second is not,
24440 and EXTERN_P for the opposite case. */
24441 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
24442 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
24443 /* If an "extern" explicit instantiation follows an ordinary
24444 explicit instantiation, the template is instantiated. */
24448 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
24450 error ("no matching template for %qD found", result
);
24453 else if (!DECL_TEMPLATE_INFO (result
))
24455 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
24459 if (storage
== NULL_TREE
)
24461 else if (storage
== ridpointers
[(int) RID_EXTERN
])
24463 if (cxx_dialect
== cxx98
)
24464 pedwarn (input_location
, OPT_Wpedantic
,
24465 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
24470 error ("storage class %qD applied to template instantiation", storage
);
24472 check_explicit_instantiation_namespace (result
);
24473 mark_decl_instantiated (result
, extern_p
);
24475 instantiate_decl (result
, /*defer_ok=*/true,
24476 /*expl_inst_class_mem_p=*/false);
24480 mark_class_instantiated (tree t
, int extern_p
)
24482 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
24483 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
24484 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
24485 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
24488 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
24489 rest_of_type_compilation (t
, 1);
24493 /* Called from do_type_instantiation through binding_table_foreach to
24494 do recursive instantiation for the type bound in ENTRY. */
24496 bt_instantiate_type_proc (binding_entry entry
, void *data
)
24498 tree storage
= *(tree
*) data
;
24500 if (MAYBE_CLASS_TYPE_P (entry
->type
)
24501 && CLASSTYPE_TEMPLATE_INFO (entry
->type
)
24502 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
24503 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
24506 /* Perform an explicit instantiation of template class T. STORAGE, if
24507 non-null, is the RID for extern, inline or static. COMPLAIN is
24508 nonzero if this is called from the parser, zero if called recursively,
24509 since the standard is unclear (as detailed below). */
24512 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
24517 int previous_instantiation_extern_p
= 0;
24519 if (TREE_CODE (t
) == TYPE_DECL
)
24522 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
24525 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
24527 error ("explicit instantiation of non-class template %qD", tmpl
);
24529 error ("explicit instantiation of non-template type %qT", t
);
24535 if (!COMPLETE_TYPE_P (t
))
24537 if (complain
& tf_error
)
24538 error ("explicit instantiation of %q#T before definition of template",
24543 if (storage
!= NULL_TREE
)
24545 if (storage
== ridpointers
[(int) RID_EXTERN
])
24547 if (cxx_dialect
== cxx98
)
24548 pedwarn (input_location
, OPT_Wpedantic
,
24549 "ISO C++ 1998 forbids the use of %<extern%> on "
24550 "explicit instantiations");
24553 pedwarn (input_location
, OPT_Wpedantic
,
24554 "ISO C++ forbids the use of %qE"
24555 " on explicit instantiations", storage
);
24557 if (storage
== ridpointers
[(int) RID_INLINE
])
24559 else if (storage
== ridpointers
[(int) RID_EXTERN
])
24561 else if (storage
== ridpointers
[(int) RID_STATIC
])
24565 error ("storage class %qD applied to template instantiation",
24571 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
24573 /* DR 259 [temp.spec].
24575 Both an explicit instantiation and a declaration of an explicit
24576 specialization shall not appear in a program unless the explicit
24577 instantiation follows a declaration of the explicit specialization.
24579 For a given set of template parameters, if an explicit
24580 instantiation of a template appears after a declaration of an
24581 explicit specialization for that template, the explicit
24582 instantiation has no effect. */
24585 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
24589 No program shall explicitly instantiate any template more
24592 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
24593 instantiation was `extern'. If EXTERN_P then the second is.
24594 These cases are OK. */
24595 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
24597 if (!previous_instantiation_extern_p
&& !extern_p
24598 && (complain
& tf_error
))
24599 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
24601 /* If we've already instantiated the template, just return now. */
24602 if (!CLASSTYPE_INTERFACE_ONLY (t
))
24606 check_explicit_instantiation_namespace (TYPE_NAME (t
));
24607 mark_class_instantiated (t
, extern_p
);
24612 /* In contrast to implicit instantiation, where only the
24613 declarations, and not the definitions, of members are
24614 instantiated, we have here:
24618 The explicit instantiation of a class template specialization
24619 implies the instantiation of all of its members not
24620 previously explicitly specialized in the translation unit
24621 containing the explicit instantiation.
24623 Of course, we can't instantiate member template classes, since we
24624 don't have any arguments for them. Note that the standard is
24625 unclear on whether the instantiation of the members are
24626 *explicit* instantiations or not. However, the most natural
24627 interpretation is that it should be an explicit
24629 for (tree fld
= TYPE_FIELDS (t
); fld
; fld
= DECL_CHAIN (fld
))
24631 || (TREE_CODE (fld
) == FUNCTION_DECL
24633 && user_provided_p (fld
)))
24634 && DECL_TEMPLATE_INSTANTIATION (fld
))
24636 mark_decl_instantiated (fld
, extern_p
);
24638 instantiate_decl (fld
, /*defer_ok=*/true,
24639 /*expl_inst_class_mem_p=*/true);
24642 if (CLASSTYPE_NESTED_UTDS (t
))
24643 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
24644 bt_instantiate_type_proc
, &storage
);
24647 /* Given a function DECL, which is a specialization of TMPL, modify
24648 DECL to be a re-instantiation of TMPL with the same template
24649 arguments. TMPL should be the template into which tsubst'ing
24650 should occur for DECL, not the most general template.
24652 One reason for doing this is a scenario like this:
24655 void f(const T&, int i);
24657 void g() { f(3, 7); }
24660 void f(const T& t, const int i) { }
24662 Note that when the template is first instantiated, with
24663 instantiate_template, the resulting DECL will have no name for the
24664 first parameter, and the wrong type for the second. So, when we go
24665 to instantiate the DECL, we regenerate it. */
24668 regenerate_decl_from_template (tree decl
, tree tmpl
, tree args
)
24670 /* The arguments used to instantiate DECL, from the most general
24674 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
24676 /* Make sure that we can see identifiers, and compute access
24678 push_access_scope (decl
);
24680 if (TREE_CODE (decl
) == FUNCTION_DECL
)
24688 args_depth
= TMPL_ARGS_DEPTH (args
);
24689 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
24690 if (args_depth
> parms_depth
)
24691 args
= get_innermost_template_args (args
, parms_depth
);
24693 /* Instantiate a dynamic exception-specification. noexcept will be
24695 if (tree raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (code_pattern
)))
24696 if (TREE_VALUE (raises
))
24698 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
24699 args
, tf_error
, NULL_TREE
,
24700 /*defer_ok*/false);
24701 if (specs
&& specs
!= error_mark_node
)
24702 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
24706 /* Merge parameter declarations. */
24707 decl_parm
= skip_artificial_parms_for (decl
,
24708 DECL_ARGUMENTS (decl
));
24710 = skip_artificial_parms_for (code_pattern
,
24711 DECL_ARGUMENTS (code_pattern
));
24712 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
24717 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
24718 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
24719 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
24721 parm_type
= type_decays_to (parm_type
);
24722 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
24723 TREE_TYPE (decl_parm
) = parm_type
;
24724 attributes
= DECL_ATTRIBUTES (pattern_parm
);
24725 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
24727 DECL_ATTRIBUTES (decl_parm
) = attributes
;
24728 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
24730 decl_parm
= DECL_CHAIN (decl_parm
);
24731 pattern_parm
= DECL_CHAIN (pattern_parm
);
24733 /* Merge any parameters that match with the function parameter
24735 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
24738 tree expanded_types
;
24739 /* Expand the TYPE_PACK_EXPANSION that provides the types for
24740 the parameters in this function parameter pack. */
24741 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
24742 args
, tf_error
, NULL_TREE
);
24743 len
= TREE_VEC_LENGTH (expanded_types
);
24744 for (i
= 0; i
< len
; i
++)
24749 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
24750 /* Rename the parameter to include the index. */
24751 DECL_NAME (decl_parm
) =
24752 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
24753 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
24754 parm_type
= type_decays_to (parm_type
);
24755 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
24756 TREE_TYPE (decl_parm
) = parm_type
;
24757 attributes
= DECL_ATTRIBUTES (pattern_parm
);
24758 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
24760 DECL_ATTRIBUTES (decl_parm
) = attributes
;
24761 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
24763 decl_parm
= DECL_CHAIN (decl_parm
);
24766 /* Merge additional specifiers from the CODE_PATTERN. */
24767 if (DECL_DECLARED_INLINE_P (code_pattern
)
24768 && !DECL_DECLARED_INLINE_P (decl
))
24769 DECL_DECLARED_INLINE_P (decl
) = 1;
24771 maybe_instantiate_noexcept (decl
, tf_error
);
24773 else if (VAR_P (decl
))
24775 start_lambda_scope (decl
);
24776 DECL_INITIAL (decl
) =
24777 tsubst_init (DECL_INITIAL (code_pattern
), decl
, args
,
24778 tf_error
, DECL_TI_TEMPLATE (decl
));
24779 finish_lambda_scope ();
24780 if (VAR_HAD_UNKNOWN_BOUND (decl
))
24781 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
24782 tf_error
, DECL_TI_TEMPLATE (decl
));
24785 gcc_unreachable ();
24787 pop_access_scope (decl
);
24790 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
24791 substituted to get DECL. */
24794 template_for_substitution (tree decl
)
24796 tree tmpl
= DECL_TI_TEMPLATE (decl
);
24798 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
24799 for the instantiation. This is not always the most general
24800 template. Consider, for example:
24803 struct S { template <class U> void f();
24804 template <> void f<int>(); };
24806 and an instantiation of S<double>::f<int>. We want TD to be the
24807 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
24808 while (/* An instantiation cannot have a definition, so we need a
24809 more general template. */
24810 DECL_TEMPLATE_INSTANTIATION (tmpl
)
24811 /* We must also deal with friend templates. Given:
24813 template <class T> struct S {
24814 template <class U> friend void f() {};
24817 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
24818 so far as the language is concerned, but that's still
24819 where we get the pattern for the instantiation from. On
24820 other hand, if the definition comes outside the class, say:
24822 template <class T> struct S {
24823 template <class U> friend void f();
24825 template <class U> friend void f() {}
24827 we don't need to look any further. That's what the check for
24828 DECL_INITIAL is for. */
24829 || (TREE_CODE (decl
) == FUNCTION_DECL
24830 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
24831 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
24833 /* The present template, TD, should not be a definition. If it
24834 were a definition, we should be using it! Note that we
24835 cannot restructure the loop to just keep going until we find
24836 a template with a definition, since that might go too far if
24837 a specialization was declared, but not defined. */
24839 /* Fetch the more general template. */
24840 tmpl
= DECL_TI_TEMPLATE (tmpl
);
24846 /* Returns true if we need to instantiate this template instance even if we
24847 know we aren't going to emit it. */
24850 always_instantiate_p (tree decl
)
24852 /* We always instantiate inline functions so that we can inline them. An
24853 explicit instantiation declaration prohibits implicit instantiation of
24854 non-inline functions. With high levels of optimization, we would
24855 normally inline non-inline functions -- but we're not allowed to do
24856 that for "extern template" functions. Therefore, we check
24857 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
24858 return ((TREE_CODE (decl
) == FUNCTION_DECL
24859 && (DECL_DECLARED_INLINE_P (decl
)
24860 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
24861 /* And we need to instantiate static data members so that
24862 their initializers are available in integral constant
24865 && decl_maybe_constant_var_p (decl
)));
24868 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
24869 instantiate it now, modifying TREE_TYPE (fn). Returns false on
24870 error, true otherwise. */
24873 maybe_instantiate_noexcept (tree fn
, tsubst_flags_t complain
)
24875 tree fntype
, spec
, noex
, clone
;
24877 /* Don't instantiate a noexcept-specification from template context. */
24878 if (processing_template_decl
24879 && (!flag_noexcept_type
|| type_dependent_expression_p (fn
)))
24882 if (DECL_CLONED_FUNCTION_P (fn
))
24883 fn
= DECL_CLONED_FUNCTION (fn
);
24885 tree orig_fn
= NULL_TREE
;
24886 /* For a member friend template we can get a TEMPLATE_DECL. Let's use
24887 its FUNCTION_DECL for the rest of this function -- push_access_scope
24888 doesn't accept TEMPLATE_DECLs. */
24889 if (DECL_FUNCTION_TEMPLATE_P (fn
))
24892 fn
= DECL_TEMPLATE_RESULT (fn
);
24895 fntype
= TREE_TYPE (fn
);
24896 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
24898 if (!spec
|| !TREE_PURPOSE (spec
))
24901 noex
= TREE_PURPOSE (spec
);
24903 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
24905 static hash_set
<tree
>* fns
= new hash_set
<tree
>;
24906 bool added
= false;
24907 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
24909 spec
= get_defaulted_eh_spec (fn
, complain
);
24910 if (spec
== error_mark_node
)
24911 /* This might have failed because of an unparsed DMI, so
24912 let's try again later. */
24915 else if (!(added
= !fns
->add (fn
)))
24917 /* If hash_set::add returns true, the element was already there. */
24918 location_t loc
= cp_expr_loc_or_loc (DEFERRED_NOEXCEPT_PATTERN (noex
),
24919 DECL_SOURCE_LOCATION (fn
));
24921 "exception specification of %qD depends on itself",
24923 spec
= noexcept_false_spec
;
24925 else if (push_tinst_level (fn
))
24927 push_to_top_level ();
24928 push_access_scope (fn
);
24929 push_deferring_access_checks (dk_no_deferred
);
24930 input_location
= DECL_SOURCE_LOCATION (fn
);
24932 /* If needed, set current_class_ptr for the benefit of
24933 tsubst_copy/PARM_DECL. */
24934 tree tdecl
= DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (fn
));
24935 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tdecl
))
24937 tree this_parm
= DECL_ARGUMENTS (tdecl
);
24938 current_class_ptr
= NULL_TREE
;
24939 current_class_ref
= cp_build_fold_indirect_ref (this_parm
);
24940 current_class_ptr
= this_parm
;
24943 /* If this function is represented by a TEMPLATE_DECL, then
24944 the deferred noexcept-specification might still contain
24945 dependent types, even after substitution. And we need the
24946 dependency check functions to work in build_noexcept_spec. */
24948 ++processing_template_decl
;
24950 /* Do deferred instantiation of the noexcept-specifier. */
24951 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
24952 DEFERRED_NOEXCEPT_ARGS (noex
),
24953 tf_warning_or_error
, fn
,
24954 /*function_p=*/false,
24957 /* Build up the noexcept-specification. */
24958 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
24961 --processing_template_decl
;
24963 pop_deferring_access_checks ();
24964 pop_access_scope (fn
);
24965 pop_tinst_level ();
24966 pop_from_top_level ();
24969 spec
= noexcept_false_spec
;
24974 if (spec
== error_mark_node
)
24976 /* This failed with a hard error, so let's go with false. */
24977 gcc_assert (seen_error ());
24978 spec
= noexcept_false_spec
;
24981 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
24983 TREE_TYPE (orig_fn
) = TREE_TYPE (fn
);
24985 FOR_EACH_CLONE (clone
, fn
)
24987 if (TREE_TYPE (clone
) == fntype
)
24988 TREE_TYPE (clone
) = TREE_TYPE (fn
);
24990 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
24997 /* We're starting to process the function INST, an instantiation of PATTERN;
24998 add their parameters to local_specializations. */
25001 register_parameter_specializations (tree pattern
, tree inst
)
25003 tree tmpl_parm
= DECL_ARGUMENTS (pattern
);
25004 tree spec_parm
= DECL_ARGUMENTS (inst
);
25005 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (inst
))
25007 register_local_specialization (spec_parm
, tmpl_parm
);
25008 spec_parm
= skip_artificial_parms_for (inst
, spec_parm
);
25009 tmpl_parm
= skip_artificial_parms_for (pattern
, tmpl_parm
);
25011 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
25013 if (!DECL_PACK_P (tmpl_parm
))
25015 register_local_specialization (spec_parm
, tmpl_parm
);
25016 spec_parm
= DECL_CHAIN (spec_parm
);
25020 /* Register the (value) argument pack as a specialization of
25021 TMPL_PARM, then move on. */
25022 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
25023 register_local_specialization (argpack
, tmpl_parm
);
25026 gcc_assert (!spec_parm
);
25029 /* Produce the definition of D, a _DECL generated from a template. If
25030 DEFER_OK is true, then we don't have to actually do the
25031 instantiation now; we just have to do it sometime. Normally it is
25032 an error if this is an explicit instantiation but D is undefined.
25033 EXPL_INST_CLASS_MEM_P is true iff D is a member of an explicitly
25034 instantiated class template. */
25037 instantiate_decl (tree d
, bool defer_ok
, bool expl_inst_class_mem_p
)
25039 tree tmpl
= DECL_TI_TEMPLATE (d
);
25046 bool pattern_defined
;
25047 location_t saved_loc
= input_location
;
25048 int saved_unevaluated_operand
= cp_unevaluated_operand
;
25049 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
25053 /* This function should only be used to instantiate templates for
25054 functions and static member variables. */
25055 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
25057 /* A concept is never instantiated. */
25058 gcc_assert (!DECL_DECLARED_CONCEPT_P (d
));
25060 /* Variables are never deferred; if instantiation is required, they
25061 are instantiated right away. That allows for better code in the
25062 case that an expression refers to the value of the variable --
25063 if the variable has a constant value the referring expression can
25064 take advantage of that fact. */
25068 /* Don't instantiate cloned functions. Instead, instantiate the
25069 functions they cloned. */
25070 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
25071 d
= DECL_CLONED_FUNCTION (d
);
25073 if (DECL_TEMPLATE_INSTANTIATED (d
)
25074 || (TREE_CODE (d
) == FUNCTION_DECL
25075 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
25076 || DECL_TEMPLATE_SPECIALIZATION (d
))
25077 /* D has already been instantiated or explicitly specialized, so
25078 there's nothing for us to do here.
25080 It might seem reasonable to check whether or not D is an explicit
25081 instantiation, and, if so, stop here. But when an explicit
25082 instantiation is deferred until the end of the compilation,
25083 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
25084 the instantiation. */
25087 /* Check to see whether we know that this template will be
25088 instantiated in some other file, as with "extern template"
25090 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
25092 /* In general, we do not instantiate such templates. */
25093 if (external_p
&& !always_instantiate_p (d
))
25096 gen_tmpl
= most_general_template (tmpl
);
25097 gen_args
= DECL_TI_ARGS (d
);
25099 if (tmpl
!= gen_tmpl
)
25100 /* We should already have the extra args. */
25101 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
25102 == TMPL_ARGS_DEPTH (gen_args
));
25103 /* And what's in the hash table should match D. */
25104 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
25105 || spec
== NULL_TREE
);
25107 /* This needs to happen before any tsubsting. */
25108 if (! push_tinst_level (d
))
25111 timevar_push (TV_TEMPLATE_INST
);
25113 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
25114 for the instantiation. */
25115 td
= template_for_substitution (d
);
25120 /* Look up an explicit specialization, if any. */
25121 tree tid
= lookup_template_variable (gen_tmpl
, gen_args
);
25122 tree elt
= most_specialized_partial_spec (tid
, tf_warning_or_error
);
25123 if (elt
&& elt
!= error_mark_node
)
25125 td
= TREE_VALUE (elt
);
25126 args
= TREE_PURPOSE (elt
);
25130 code_pattern
= DECL_TEMPLATE_RESULT (td
);
25132 /* We should never be trying to instantiate a member of a class
25133 template or partial specialization. */
25134 gcc_assert (d
!= code_pattern
);
25136 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
25137 || DECL_TEMPLATE_SPECIALIZATION (td
))
25138 /* In the case of a friend template whose definition is provided
25139 outside the class, we may have too many arguments. Drop the
25140 ones we don't need. The same is true for specializations. */
25141 args
= get_innermost_template_args
25142 (args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
25144 if (TREE_CODE (d
) == FUNCTION_DECL
)
25146 deleted_p
= DECL_DELETED_FN (code_pattern
);
25147 pattern_defined
= ((DECL_SAVED_TREE (code_pattern
) != NULL_TREE
25148 && DECL_INITIAL (code_pattern
) != error_mark_node
)
25149 || DECL_DEFAULTED_FN (code_pattern
)
25155 if (DECL_CLASS_SCOPE_P (code_pattern
))
25156 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
25158 pattern_defined
= ! DECL_EXTERNAL (code_pattern
);
25161 /* We may be in the middle of deferred access check. Disable it now. */
25162 push_deferring_access_checks (dk_no_deferred
);
25164 /* Unless an explicit instantiation directive has already determined
25165 the linkage of D, remember that a definition is available for
25167 if (pattern_defined
25168 && !DECL_INTERFACE_KNOWN (d
)
25169 && !DECL_NOT_REALLY_EXTERN (d
))
25170 mark_definable (d
);
25172 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
25173 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
25174 input_location
= DECL_SOURCE_LOCATION (d
);
25176 /* If D is a member of an explicitly instantiated class template,
25177 and no definition is available, treat it like an implicit
25179 if (!pattern_defined
&& expl_inst_class_mem_p
25180 && DECL_EXPLICIT_INSTANTIATION (d
))
25182 /* Leave linkage flags alone on instantiations with anonymous
25184 if (TREE_PUBLIC (d
))
25186 DECL_NOT_REALLY_EXTERN (d
) = 0;
25187 DECL_INTERFACE_KNOWN (d
) = 0;
25189 SET_DECL_IMPLICIT_INSTANTIATION (d
);
25192 /* Defer all other templates, unless we have been explicitly
25193 forbidden from doing so. */
25194 if (/* If there is no definition, we cannot instantiate the
25197 /* If it's OK to postpone instantiation, do so. */
25199 /* If this is a static data member that will be defined
25200 elsewhere, we don't want to instantiate the entire data
25201 member, but we do want to instantiate the initializer so that
25202 we can substitute that elsewhere. */
25203 || (external_p
&& VAR_P (d
))
25204 /* Handle here a deleted function too, avoid generating
25205 its body (c++/61080). */
25208 /* The definition of the static data member is now required so
25209 we must substitute the initializer. */
25211 && !DECL_INITIAL (d
)
25212 && DECL_INITIAL (code_pattern
))
25216 bool const_init
= false;
25217 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
25219 ns
= decl_namespace_context (d
);
25220 push_nested_namespace (ns
);
25222 push_nested_class (DECL_CONTEXT (d
));
25223 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
25225 tf_warning_or_error
, NULL_TREE
,
25226 /*integral_constant_expression_p=*/false);
25227 /* If instantiating the initializer involved instantiating this
25228 again, don't call cp_finish_decl twice. */
25229 if (!DECL_INITIAL (d
))
25231 /* Make sure the initializer is still constant, in case of
25232 circular dependency (template/instantiate6.C). */
25234 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
25235 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
25236 /*asmspec_tree=*/NULL_TREE
,
25237 LOOKUP_ONLYCONVERTING
);
25240 pop_nested_class ();
25241 pop_nested_namespace (ns
);
25244 /* We restore the source position here because it's used by
25245 add_pending_template. */
25246 input_location
= saved_loc
;
25248 if (at_eof
&& !pattern_defined
25249 && DECL_EXPLICIT_INSTANTIATION (d
)
25250 && DECL_NOT_REALLY_EXTERN (d
))
25253 The definition of a non-exported function template, a
25254 non-exported member function template, or a non-exported
25255 member function or static data member of a class template
25256 shall be present in every translation unit in which it is
25257 explicitly instantiated. */
25258 permerror (input_location
, "explicit instantiation of %qD "
25259 "but no definition available", d
);
25261 /* If we're in unevaluated context, we just wanted to get the
25262 constant value; this isn't an odr use, so don't queue
25263 a full instantiation. */
25264 if (cp_unevaluated_operand
!= 0)
25266 /* ??? Historically, we have instantiated inline functions, even
25267 when marked as "extern template". */
25268 if (!(external_p
&& VAR_P (d
)))
25269 add_pending_template (d
);
25273 bool push_to_top
, nested
;
25275 fn_context
= decl_function_context (d
);
25276 if (LAMBDA_FUNCTION_P (d
))
25277 /* tsubst_lambda_expr resolved any references to enclosing functions. */
25278 fn_context
= NULL_TREE
;
25279 nested
= current_function_decl
!= NULL_TREE
;
25280 push_to_top
= !(nested
&& fn_context
== current_function_decl
);
25282 vec
<tree
> omp_privatization_save
;
25284 save_omp_privatization_clauses (omp_privatization_save
);
25287 push_to_top_level ();
25290 gcc_assert (!processing_template_decl
);
25291 push_function_context ();
25292 cp_unevaluated_operand
= 0;
25293 c_inhibit_evaluation_warnings
= 0;
25296 /* Mark D as instantiated so that recursive calls to
25297 instantiate_decl do not try to instantiate it again. */
25298 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
25300 /* Regenerate the declaration in case the template has been modified
25301 by a subsequent redeclaration. */
25302 regenerate_decl_from_template (d
, td
, args
);
25304 /* We already set the file and line above. Reset them now in case
25305 they changed as a result of calling regenerate_decl_from_template. */
25306 input_location
= DECL_SOURCE_LOCATION (d
);
25311 bool const_init
= false;
25313 /* Clear out DECL_RTL; whatever was there before may not be right
25314 since we've reset the type of the declaration. */
25315 SET_DECL_RTL (d
, NULL
);
25316 DECL_IN_AGGR_P (d
) = 0;
25318 /* The initializer is placed in DECL_INITIAL by
25319 regenerate_decl_from_template so we don't need to
25320 push/pop_access_scope again here. Pull it out so that
25321 cp_finish_decl can process it. */
25322 init
= DECL_INITIAL (d
);
25323 DECL_INITIAL (d
) = NULL_TREE
;
25324 DECL_INITIALIZED_P (d
) = 0;
25326 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
25327 initializer. That function will defer actual emission until
25328 we have a chance to determine linkage. */
25329 DECL_EXTERNAL (d
) = 0;
25331 /* Enter the scope of D so that access-checking works correctly. */
25332 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
25334 push_nested_class (DECL_CONTEXT (d
));
25336 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
25337 int flags
= (TINFO_VAR_DECLARED_CONSTINIT (DECL_TEMPLATE_INFO (d
))
25338 ? LOOKUP_CONSTINIT
: 0);
25339 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, flags
);
25342 pop_nested_class ();
25344 if (variable_template_p (gen_tmpl
))
25345 note_variable_template_instantiation (d
);
25347 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
25348 synthesize_method (d
);
25349 else if (TREE_CODE (d
) == FUNCTION_DECL
)
25351 /* Set up the list of local specializations. */
25352 local_specialization_stack
lss (push_to_top
? lss_blank
: lss_copy
);
25353 tree block
= NULL_TREE
;
25355 /* Set up context. */
25356 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
25357 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
25358 block
= push_stmt_list ();
25360 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
25362 /* Some typedefs referenced from within the template code need to be
25363 access checked at template instantiation time, i.e now. These
25364 types were added to the template at parsing time. Let's get those
25365 and perform the access checks then. */
25366 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (td
),
25369 /* Create substitution entries for the parameters. */
25370 register_parameter_specializations (code_pattern
, d
);
25372 /* Substitute into the body of the function. */
25373 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
25374 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
25375 tf_warning_or_error
, tmpl
);
25378 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
25379 tf_warning_or_error
, tmpl
,
25380 /*integral_constant_expression_p=*/false);
25382 /* Set the current input_location to the end of the function
25383 so that finish_function knows where we are. */
25385 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
25387 /* Remember if we saw an infinite loop in the template. */
25388 current_function_infinite_loop
25389 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
25392 /* Finish the function. */
25393 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
25394 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
25395 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
25398 d
= finish_function (/*inline_p=*/false);
25399 expand_or_defer_fn (d
);
25402 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
25403 cp_check_omp_declare_reduction (d
);
25406 /* We're not deferring instantiation any more. */
25407 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
25410 pop_from_top_level ();
25412 pop_function_context ();
25415 restore_omp_privatization_clauses (omp_privatization_save
);
25418 pop_deferring_access_checks ();
25419 timevar_pop (TV_TEMPLATE_INST
);
25420 pop_tinst_level ();
25421 input_location
= saved_loc
;
25422 cp_unevaluated_operand
= saved_unevaluated_operand
;
25423 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
25428 /* Run through the list of templates that we wish we could
25429 instantiate, and instantiate any we can. RETRIES is the
25430 number of times we retry pending template instantiation. */
25433 instantiate_pending_templates (int retries
)
25436 location_t saved_loc
= input_location
;
25438 /* Instantiating templates may trigger vtable generation. This in turn
25439 may require further template instantiations. We place a limit here
25440 to avoid infinite loop. */
25441 if (pending_templates
&& retries
>= max_tinst_depth
)
25443 tree decl
= pending_templates
->tinst
->maybe_get_node ();
25445 fatal_error (input_location
,
25446 "template instantiation depth exceeds maximum of %d"
25447 " instantiating %q+D, possibly from virtual table generation"
25448 " (use %<-ftemplate-depth=%> to increase the maximum)",
25449 max_tinst_depth
, decl
);
25450 if (TREE_CODE (decl
) == FUNCTION_DECL
)
25451 /* Pretend that we defined it. */
25452 DECL_INITIAL (decl
) = error_mark_node
;
25458 struct pending_template
**t
= &pending_templates
;
25459 struct pending_template
*last
= NULL
;
25463 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
25464 bool complete
= false;
25466 if (TYPE_P (instantiation
))
25468 if (!COMPLETE_TYPE_P (instantiation
))
25470 instantiate_class_template (instantiation
);
25471 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
25472 for (tree fld
= TYPE_FIELDS (instantiation
);
25473 fld
; fld
= TREE_CHAIN (fld
))
25475 || (TREE_CODE (fld
) == FUNCTION_DECL
25476 && !DECL_ARTIFICIAL (fld
)))
25477 && DECL_TEMPLATE_INSTANTIATION (fld
))
25478 instantiate_decl (fld
,
25479 /*defer_ok=*/false,
25480 /*expl_inst_class_mem_p=*/false);
25482 if (COMPLETE_TYPE_P (instantiation
))
25486 complete
= COMPLETE_TYPE_P (instantiation
);
25490 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
25491 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
25494 = instantiate_decl (instantiation
,
25495 /*defer_ok=*/false,
25496 /*expl_inst_class_mem_p=*/false);
25497 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
25501 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
25502 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
25507 /* If INSTANTIATION has been instantiated, then we don't
25508 need to consider it again in the future. */
25509 struct pending_template
*drop
= *t
;
25511 set_refcount_ptr (drop
->tinst
);
25512 pending_template_freelist ().free (drop
);
25520 set_refcount_ptr (current_tinst_level
);
25522 last_pending_template
= last
;
25524 while (reconsider
);
25526 input_location
= saved_loc
;
25529 /* Substitute ARGVEC into T, which is a list of initializers for
25530 either base class or a non-static data member. The TREE_PURPOSEs
25531 are DECLs, and the TREE_VALUEs are the initializer values. Used by
25532 instantiate_decl. */
25535 tsubst_initializer_list (tree t
, tree argvec
)
25537 tree inits
= NULL_TREE
;
25538 tree target_ctor
= error_mark_node
;
25540 for (; t
; t
= TREE_CHAIN (t
))
25544 tree expanded_bases
= NULL_TREE
;
25545 tree expanded_arguments
= NULL_TREE
;
25548 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
25553 /* Expand the base class expansion type into separate base
25555 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
25556 tf_warning_or_error
,
25558 if (expanded_bases
== error_mark_node
)
25561 /* We'll be building separate TREE_LISTs of arguments for
25563 len
= TREE_VEC_LENGTH (expanded_bases
);
25564 expanded_arguments
= make_tree_vec (len
);
25565 for (i
= 0; i
< len
; i
++)
25566 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
25568 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
25569 expand each argument in the TREE_VALUE of t. */
25570 expr
= make_node (EXPR_PACK_EXPANSION
);
25571 PACK_EXPANSION_LOCAL_P (expr
) = true;
25572 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
25573 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
25575 if (TREE_VALUE (t
) == void_type_node
)
25576 /* VOID_TYPE_NODE is used to indicate
25577 value-initialization. */
25579 for (i
= 0; i
< len
; i
++)
25580 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
25584 /* Substitute parameter packs into each argument in the
25586 in_base_initializer
= 1;
25587 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
25589 tree expanded_exprs
;
25591 /* Expand the argument. */
25592 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
25594 = tsubst_pack_expansion (expr
, argvec
,
25595 tf_warning_or_error
,
25597 if (expanded_exprs
== error_mark_node
)
25600 /* Prepend each of the expanded expressions to the
25601 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
25602 for (i
= 0; i
< len
; i
++)
25604 TREE_VEC_ELT (expanded_arguments
, i
) =
25605 tree_cons (NULL_TREE
,
25606 TREE_VEC_ELT (expanded_exprs
, i
),
25607 TREE_VEC_ELT (expanded_arguments
, i
));
25610 in_base_initializer
= 0;
25612 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
25613 since we built them backwards. */
25614 for (i
= 0; i
< len
; i
++)
25616 TREE_VEC_ELT (expanded_arguments
, i
) =
25617 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
25622 for (i
= 0; i
< len
; ++i
)
25624 if (expanded_bases
)
25626 decl
= TREE_VEC_ELT (expanded_bases
, i
);
25627 decl
= expand_member_init (decl
);
25628 init
= TREE_VEC_ELT (expanded_arguments
, i
);
25633 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
25634 tf_warning_or_error
, NULL_TREE
);
25636 decl
= expand_member_init (decl
);
25637 if (decl
&& !DECL_P (decl
))
25638 in_base_initializer
= 1;
25640 init
= TREE_VALUE (t
);
25642 if (init
!= void_type_node
)
25643 init
= tsubst_expr (init
, argvec
,
25644 tf_warning_or_error
, NULL_TREE
,
25645 /*integral_constant_expression_p=*/false);
25646 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
25647 /* If we had an initializer but it instantiated to nothing,
25648 value-initialize the object. This will only occur when
25649 the initializer was a pack expansion where the parameter
25650 packs used in that expansion were of length zero. */
25651 init
= void_type_node
;
25652 in_base_initializer
= 0;
25655 if (target_ctor
!= error_mark_node
25656 && init
!= error_mark_node
)
25658 error ("mem-initializer for %qD follows constructor delegation",
25662 /* Look for a target constructor. */
25663 if (init
!= error_mark_node
25664 && decl
&& CLASS_TYPE_P (decl
)
25665 && same_type_p (decl
, current_class_type
))
25667 maybe_warn_cpp0x (CPP0X_DELEGATING_CTORS
);
25670 error ("constructor delegation follows mem-initializer for %qD",
25671 TREE_PURPOSE (inits
));
25674 target_ctor
= init
;
25679 init
= build_tree_list (decl
, init
);
25680 TREE_CHAIN (init
) = inits
;
25688 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
25691 set_current_access_from_decl (tree decl
)
25693 if (TREE_PRIVATE (decl
))
25694 current_access_specifier
= access_private_node
;
25695 else if (TREE_PROTECTED (decl
))
25696 current_access_specifier
= access_protected_node
;
25698 current_access_specifier
= access_public_node
;
25701 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
25702 is the instantiation (which should have been created with
25703 start_enum) and ARGS are the template arguments to use. */
25706 tsubst_enum (tree tag
, tree newtag
, tree args
)
25710 if (SCOPED_ENUM_P (newtag
))
25711 begin_scope (sk_scoped_enum
, newtag
);
25713 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
25718 decl
= TREE_VALUE (e
);
25719 /* Note that in a template enum, the TREE_VALUE is the
25720 CONST_DECL, not the corresponding INTEGER_CST. */
25721 value
= tsubst_expr (DECL_INITIAL (decl
),
25722 args
, tf_warning_or_error
, NULL_TREE
,
25723 /*integral_constant_expression_p=*/true);
25725 /* Give this enumeration constant the correct access. */
25726 set_current_access_from_decl (decl
);
25728 /* Actually build the enumerator itself. Here we're assuming that
25729 enumerators can't have dependent attributes. */
25730 build_enumerator (DECL_NAME (decl
), value
, newtag
,
25731 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
25734 if (SCOPED_ENUM_P (newtag
))
25737 finish_enum_value_list (newtag
);
25738 finish_enum (newtag
);
25740 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
25741 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
25744 /* DECL is a FUNCTION_DECL that is a template specialization. Return
25745 its type -- but without substituting the innermost set of template
25746 arguments. So, innermost set of template parameters will appear in
25750 get_mostly_instantiated_function_type (tree decl
)
25752 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
25753 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
25756 /* Return truthvalue if we're processing a template different from
25757 the last one involved in diagnostics. */
25759 problematic_instantiation_changed (void)
25761 return current_tinst_level
!= last_error_tinst_level
;
25764 /* Remember current template involved in diagnostics. */
25766 record_last_problematic_instantiation (void)
25768 set_refcount_ptr (last_error_tinst_level
, current_tinst_level
);
25771 struct tinst_level
*
25772 current_instantiation (void)
25774 return current_tinst_level
;
25777 /* Return TRUE if current_function_decl is being instantiated, false
25781 instantiating_current_function_p (void)
25783 return (current_instantiation ()
25784 && (current_instantiation ()->maybe_get_node ()
25785 == current_function_decl
));
25788 /* [temp.param] Check that template non-type parm TYPE is of an allowable
25789 type. Return false for ok, true for disallowed. Issue error and
25790 inform messages under control of COMPLAIN. */
25793 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
25795 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
25797 else if (TYPE_PTR_P (type
))
25799 else if (TYPE_REF_P (type
)
25800 && !TYPE_REF_IS_RVALUE (type
))
25802 else if (TYPE_PTRMEM_P (type
))
25804 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
25806 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
25808 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
25810 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
25812 /* A bound template template parm could later be instantiated to have a valid
25813 nontype parm type via an alias template. */
25814 else if (cxx_dialect
>= cxx11
25815 && TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
25817 else if (CLASS_TYPE_P (type
))
25819 if (cxx_dialect
< cxx2a
)
25821 if (complain
& tf_error
)
25822 error ("non-type template parameters of class type only available "
25823 "with %<-std=c++2a%> or %<-std=gnu++2a%>");
25826 if (dependent_type_p (type
))
25828 if (!complete_type_or_else (type
, NULL_TREE
))
25830 if (!structural_type_p (type
))
25832 auto_diagnostic_group d
;
25833 if (complain
& tf_error
)
25834 error ("%qT is not a valid type for a template non-type parameter "
25835 "because it is not structural", type
);
25836 structural_type_p (type
, true);
25842 if (complain
& tf_error
)
25844 if (type
== error_mark_node
)
25845 inform (input_location
, "invalid template non-type parameter");
25847 error ("%q#T is not a valid type for a template non-type parameter",
25853 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
25854 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
25857 dependent_type_p_r (tree type
)
25863 A type is dependent if it is:
25865 -- a template parameter. Template template parameters are types
25866 for us (since TYPE_P holds true for them) so we handle
25868 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
25869 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
25871 /* -- a qualified-id with a nested-name-specifier which contains a
25872 class-name that names a dependent type or whose unqualified-id
25873 names a dependent type. */
25874 if (TREE_CODE (type
) == TYPENAME_TYPE
)
25877 /* An alias template specialization can be dependent even if the
25878 resulting type is not. */
25879 if (dependent_alias_template_spec_p (type
, nt_transparent
))
25882 /* -- a cv-qualified type where the cv-unqualified type is
25884 No code is necessary for this bullet; the code below handles
25885 cv-qualified types, and we don't want to strip aliases with
25886 TYPE_MAIN_VARIANT because of DR 1558. */
25887 /* -- a compound type constructed from any dependent type. */
25888 if (TYPE_PTRMEM_P (type
))
25889 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
25890 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
25892 else if (INDIRECT_TYPE_P (type
))
25893 return dependent_type_p (TREE_TYPE (type
));
25894 else if (FUNC_OR_METHOD_TYPE_P (type
))
25898 if (dependent_type_p (TREE_TYPE (type
)))
25900 for (arg_type
= TYPE_ARG_TYPES (type
);
25902 arg_type
= TREE_CHAIN (arg_type
))
25903 if (dependent_type_p (TREE_VALUE (arg_type
)))
25905 if (cxx_dialect
>= cxx17
)
25906 /* A value-dependent noexcept-specifier makes the type dependent. */
25907 if (tree spec
= TYPE_RAISES_EXCEPTIONS (type
))
25908 if (tree noex
= TREE_PURPOSE (spec
))
25909 /* Treat DEFERRED_NOEXCEPT as non-dependent, since it doesn't
25910 affect overload resolution and treating it as dependent breaks
25911 things. Same for an unparsed noexcept expression. */
25912 if (TREE_CODE (noex
) != DEFERRED_NOEXCEPT
25913 && TREE_CODE (noex
) != DEFERRED_PARSE
25914 && value_dependent_expression_p (noex
))
25918 /* -- an array type constructed from any dependent type or whose
25919 size is specified by a constant expression that is
25922 We checked for type- and value-dependence of the bounds in
25923 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
25924 if (TREE_CODE (type
) == ARRAY_TYPE
)
25926 if (TYPE_DOMAIN (type
)
25927 && dependent_type_p (TYPE_DOMAIN (type
)))
25929 return dependent_type_p (TREE_TYPE (type
));
25932 /* -- a template-id in which either the template name is a template
25934 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
25936 /* ... or any of the template arguments is a dependent type or
25937 an expression that is type-dependent or value-dependent. */
25938 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
25939 && (any_dependent_template_arguments_p
25940 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
25943 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
25944 dependent; if the argument of the `typeof' expression is not
25945 type-dependent, then it should already been have resolved. */
25946 if (TREE_CODE (type
) == TYPEOF_TYPE
25947 || TREE_CODE (type
) == DECLTYPE_TYPE
25948 || TREE_CODE (type
) == UNDERLYING_TYPE
)
25951 /* A template argument pack is dependent if any of its packed
25953 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
25955 tree args
= ARGUMENT_PACK_ARGS (type
);
25956 int i
, len
= TREE_VEC_LENGTH (args
);
25957 for (i
= 0; i
< len
; ++i
)
25958 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
25962 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
25963 be template parameters. */
25964 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
25967 if (any_dependent_type_attributes_p (TYPE_ATTRIBUTES (type
)))
25970 /* The standard does not specifically mention types that are local
25971 to template functions or local classes, but they should be
25972 considered dependent too. For example:
25974 template <int I> void f() {
25979 The size of `E' cannot be known until the value of `I' has been
25980 determined. Therefore, `E' must be considered dependent. */
25981 scope
= TYPE_CONTEXT (type
);
25982 if (scope
&& TYPE_P (scope
))
25983 return dependent_type_p (scope
);
25984 /* Don't use type_dependent_expression_p here, as it can lead
25985 to infinite recursion trying to determine whether a lambda
25986 nested in a lambda is dependent (c++/47687). */
25987 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
25988 && DECL_LANG_SPECIFIC (scope
)
25989 && DECL_TEMPLATE_INFO (scope
)
25990 && (any_dependent_template_arguments_p
25991 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
25994 /* Other types are non-dependent. */
25998 /* Returns TRUE if TYPE is dependent, in the sense of
25999 [temp.dep.type]. Note that a NULL type is considered dependent. */
26002 dependent_type_p (tree type
)
26004 /* If there are no template parameters in scope, then there can't be
26005 any dependent types. */
26006 if (!processing_template_decl
)
26008 /* If we are not processing a template, then nobody should be
26009 providing us with a dependent type. */
26011 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
26015 /* If the type is NULL, we have not computed a type for the entity
26016 in question; in that case, the type is dependent. */
26020 /* Erroneous types can be considered non-dependent. */
26021 if (type
== error_mark_node
)
26024 /* Getting here with global_type_node means we improperly called this
26025 function on the TREE_TYPE of an IDENTIFIER_NODE. */
26026 gcc_checking_assert (type
!= global_type_node
);
26028 /* If we have not already computed the appropriate value for TYPE,
26030 if (!TYPE_DEPENDENT_P_VALID (type
))
26032 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
26033 TYPE_DEPENDENT_P_VALID (type
) = 1;
26036 return TYPE_DEPENDENT_P (type
);
26039 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
26040 lookup. In other words, a dependent type that is not the current
26044 dependent_scope_p (tree scope
)
26046 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
26047 && !currently_open_class (scope
));
26050 /* T is a SCOPE_REF. Return whether it represents a non-static member of
26051 an unknown base of 'this' (and is therefore instantiation-dependent). */
26054 unknown_base_ref_p (tree t
)
26056 if (!current_class_ptr
)
26059 tree mem
= TREE_OPERAND (t
, 1);
26060 if (shared_member_p (mem
))
26063 tree cur
= current_nonlambda_class_type ();
26064 if (!any_dependent_bases_p (cur
))
26067 tree ctx
= TREE_OPERAND (t
, 0);
26068 if (DERIVED_FROM_P (ctx
, cur
))
26074 /* T is a SCOPE_REF; return whether we need to consider it
26075 instantiation-dependent so that we can check access at instantiation
26076 time even though we know which member it resolves to. */
26079 instantiation_dependent_scope_ref_p (tree t
)
26081 if (DECL_P (TREE_OPERAND (t
, 1))
26082 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
26083 && !unknown_base_ref_p (t
)
26084 && accessible_in_template_p (TREE_OPERAND (t
, 0),
26085 TREE_OPERAND (t
, 1)))
26091 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
26092 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
26095 /* Note that this predicate is not appropriate for general expressions;
26096 only constant expressions (that satisfy potential_constant_expression)
26097 can be tested for value dependence. */
26100 value_dependent_expression_p (tree expression
)
26102 if (!processing_template_decl
|| expression
== NULL_TREE
)
26105 /* A type-dependent expression is also value-dependent. */
26106 if (type_dependent_expression_p (expression
))
26109 switch (TREE_CODE (expression
))
26112 /* A dependent member function of the current instantiation. */
26113 return dependent_type_p (BINFO_TYPE (BASELINK_BINFO (expression
)));
26115 case FUNCTION_DECL
:
26116 /* A dependent member function of the current instantiation. */
26117 if (DECL_CLASS_SCOPE_P (expression
)
26118 && dependent_type_p (DECL_CONTEXT (expression
)))
26122 case IDENTIFIER_NODE
:
26123 /* A name that has not been looked up -- must be dependent. */
26126 case TEMPLATE_PARM_INDEX
:
26127 /* A non-type template parm. */
26131 /* A non-type template parm. */
26132 if (DECL_TEMPLATE_PARM_P (expression
))
26134 return value_dependent_expression_p (DECL_INITIAL (expression
));
26137 /* A constant with literal type and is initialized
26138 with an expression that is value-dependent. */
26139 if (DECL_DEPENDENT_INIT_P (expression
)
26140 /* FIXME cp_finish_decl doesn't fold reference initializers. */
26141 || TYPE_REF_P (TREE_TYPE (expression
)))
26143 if (DECL_HAS_VALUE_EXPR_P (expression
))
26145 tree value_expr
= DECL_VALUE_EXPR (expression
);
26146 if (value_dependent_expression_p (value_expr
)
26147 /* __PRETTY_FUNCTION__ inside a template function is dependent
26148 on the name of the function. */
26149 || (DECL_PRETTY_FUNCTION_P (expression
)
26150 /* It might be used in a template, but not a template
26151 function, in which case its DECL_VALUE_EXPR will be
26153 && value_expr
== error_mark_node
))
26158 case DYNAMIC_CAST_EXPR
:
26159 case STATIC_CAST_EXPR
:
26160 case CONST_CAST_EXPR
:
26161 case REINTERPRET_CAST_EXPR
:
26163 case IMPLICIT_CONV_EXPR
:
26164 /* These expressions are value-dependent if the type to which
26165 the cast occurs is dependent or the expression being casted
26166 is value-dependent. */
26168 tree type
= TREE_TYPE (expression
);
26170 if (dependent_type_p (type
))
26173 /* A functional cast has a list of operands. */
26174 expression
= TREE_OPERAND (expression
, 0);
26177 /* If there are no operands, it must be an expression such
26178 as "int()". This should not happen for aggregate types
26179 because it would form non-constant expressions. */
26180 gcc_assert (cxx_dialect
>= cxx11
26181 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
26186 if (TREE_CODE (expression
) == TREE_LIST
)
26187 return any_value_dependent_elements_p (expression
);
26189 return value_dependent_expression_p (expression
);
26193 if (SIZEOF_EXPR_TYPE_P (expression
))
26194 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
26198 /* A `sizeof' expression is value-dependent if the operand is
26199 type-dependent or is a pack expansion. */
26200 expression
= TREE_OPERAND (expression
, 0);
26201 if (PACK_EXPANSION_P (expression
))
26203 else if (TYPE_P (expression
))
26204 return dependent_type_p (expression
);
26205 return instantiation_dependent_uneval_expression_p (expression
);
26207 case AT_ENCODE_EXPR
:
26208 /* An 'encode' expression is value-dependent if the operand is
26210 expression
= TREE_OPERAND (expression
, 0);
26211 return dependent_type_p (expression
);
26213 case NOEXCEPT_EXPR
:
26214 expression
= TREE_OPERAND (expression
, 0);
26215 return instantiation_dependent_uneval_expression_p (expression
);
26218 /* All instantiation-dependent expressions should also be considered
26219 value-dependent. */
26220 return instantiation_dependent_scope_ref_p (expression
);
26222 case COMPONENT_REF
:
26223 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
26224 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
26226 case NONTYPE_ARGUMENT_PACK
:
26227 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
26228 is value-dependent. */
26230 tree values
= ARGUMENT_PACK_ARGS (expression
);
26231 int i
, len
= TREE_VEC_LENGTH (values
);
26233 for (i
= 0; i
< len
; ++i
)
26234 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
26242 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
26244 if (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
)))
26250 if (TREE_CODE (type2
) != TREE_LIST
)
26251 return dependent_type_p (type2
);
26253 for (; type2
; type2
= TREE_CHAIN (type2
))
26254 if (dependent_type_p (TREE_VALUE (type2
)))
26261 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
26262 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
26265 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
26266 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
26270 tree op
= TREE_OPERAND (expression
, 0);
26271 return (value_dependent_expression_p (op
)
26272 || has_value_dependent_address (op
));
26275 case REQUIRES_EXPR
:
26276 /* Treat all requires-expressions as value-dependent so
26277 we don't try to fold them. */
26281 return dependent_type_p (TREE_OPERAND (expression
, 0));
26285 if (value_dependent_expression_p (CALL_EXPR_FN (expression
)))
26287 tree fn
= get_callee_fndecl (expression
);
26289 nargs
= call_expr_nargs (expression
);
26290 for (i
= 0; i
< nargs
; ++i
)
26292 tree op
= CALL_EXPR_ARG (expression
, i
);
26293 /* In a call to a constexpr member function, look through the
26294 implicit ADDR_EXPR on the object argument so that it doesn't
26295 cause the call to be considered value-dependent. We also
26296 look through it in potential_constant_expression. */
26297 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
26298 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
26299 && TREE_CODE (op
) == ADDR_EXPR
)
26300 op
= TREE_OPERAND (op
, 0);
26301 if (value_dependent_expression_p (op
))
26307 case TEMPLATE_ID_EXPR
:
26308 return concept_definition_p (TREE_OPERAND (expression
, 0));
26314 if (dependent_type_p (TREE_TYPE (expression
)))
26316 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
26317 if (value_dependent_expression_p (val
))
26323 /* Treat a GNU statement expression as dependent to avoid crashing
26324 under instantiate_non_dependent_expr; it can't be constant. */
26328 /* A constant expression is value-dependent if any subexpression is
26329 value-dependent. */
26330 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
26332 case tcc_reference
:
26334 case tcc_comparison
:
26336 case tcc_expression
:
26339 int i
, len
= cp_tree_operand_length (expression
);
26341 for (i
= 0; i
< len
; i
++)
26343 tree t
= TREE_OPERAND (expression
, i
);
26345 /* In some cases, some of the operands may be missing.
26346 (For example, in the case of PREDECREMENT_EXPR, the
26347 amount to increment by may be missing.) That doesn't
26348 make the expression dependent. */
26349 if (t
&& value_dependent_expression_p (t
))
26360 /* The expression is not value-dependent. */
26364 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
26365 [temp.dep.expr]. Note that an expression with no type is
26366 considered dependent. Other parts of the compiler arrange for an
26367 expression with type-dependent subexpressions to have no type, so
26368 this function doesn't have to be fully recursive. */
26371 type_dependent_expression_p (tree expression
)
26373 if (!processing_template_decl
)
26376 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
26379 STRIP_ANY_LOCATION_WRAPPER (expression
);
26381 /* An unresolved name is always dependent. */
26382 if (identifier_p (expression
)
26383 || TREE_CODE (expression
) == USING_DECL
26384 || TREE_CODE (expression
) == WILDCARD_DECL
)
26387 /* A lambda-expression in template context is dependent. dependent_type_p is
26388 true for a lambda in the scope of a class or function template, but that
26389 doesn't cover all template contexts, like a default template argument. */
26390 if (TREE_CODE (expression
) == LAMBDA_EXPR
)
26393 /* A fold expression is type-dependent. */
26394 if (TREE_CODE (expression
) == UNARY_LEFT_FOLD_EXPR
26395 || TREE_CODE (expression
) == UNARY_RIGHT_FOLD_EXPR
26396 || TREE_CODE (expression
) == BINARY_LEFT_FOLD_EXPR
26397 || TREE_CODE (expression
) == BINARY_RIGHT_FOLD_EXPR
)
26400 /* Some expression forms are never type-dependent. */
26401 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
26402 || TREE_CODE (expression
) == SIZEOF_EXPR
26403 || TREE_CODE (expression
) == ALIGNOF_EXPR
26404 || TREE_CODE (expression
) == AT_ENCODE_EXPR
26405 || TREE_CODE (expression
) == NOEXCEPT_EXPR
26406 || TREE_CODE (expression
) == TRAIT_EXPR
26407 || TREE_CODE (expression
) == TYPEID_EXPR
26408 || TREE_CODE (expression
) == DELETE_EXPR
26409 || TREE_CODE (expression
) == VEC_DELETE_EXPR
26410 || TREE_CODE (expression
) == THROW_EXPR
26411 || TREE_CODE (expression
) == REQUIRES_EXPR
)
26414 /* The types of these expressions depends only on the type to which
26415 the cast occurs. */
26416 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
26417 || TREE_CODE (expression
) == STATIC_CAST_EXPR
26418 || TREE_CODE (expression
) == CONST_CAST_EXPR
26419 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
26420 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
26421 || TREE_CODE (expression
) == CAST_EXPR
)
26422 return dependent_type_p (TREE_TYPE (expression
));
26424 /* The types of these expressions depends only on the type created
26425 by the expression. */
26426 if (TREE_CODE (expression
) == NEW_EXPR
26427 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
26429 /* For NEW_EXPR tree nodes created inside a template, either
26430 the object type itself or a TREE_LIST may appear as the
26432 tree type
= TREE_OPERAND (expression
, 1);
26433 if (TREE_CODE (type
) == TREE_LIST
)
26434 /* This is an array type. We need to check array dimensions
26436 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
26437 || value_dependent_expression_p
26438 (TREE_OPERAND (TREE_VALUE (type
), 1));
26440 return dependent_type_p (type
);
26443 if (TREE_CODE (expression
) == SCOPE_REF
)
26445 tree scope
= TREE_OPERAND (expression
, 0);
26446 tree name
= TREE_OPERAND (expression
, 1);
26448 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
26449 contains an identifier associated by name lookup with one or more
26450 declarations declared with a dependent type, or...a
26451 nested-name-specifier or qualified-id that names a member of an
26452 unknown specialization. */
26453 return (type_dependent_expression_p (name
)
26454 || dependent_scope_p (scope
));
26457 if (TREE_CODE (expression
) == TEMPLATE_DECL
26458 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
26459 return uses_outer_template_parms (expression
);
26461 if (TREE_CODE (expression
) == STMT_EXPR
)
26462 expression
= stmt_expr_value_expr (expression
);
26464 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
26469 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
26471 if (type_dependent_expression_p (elt
))
26477 /* A static data member of the current instantiation with incomplete
26478 array type is type-dependent, as the definition and specializations
26479 can have different bounds. */
26480 if (VAR_P (expression
)
26481 && DECL_CLASS_SCOPE_P (expression
)
26482 && dependent_type_p (DECL_CONTEXT (expression
))
26483 && VAR_HAD_UNKNOWN_BOUND (expression
))
26486 /* An array of unknown bound depending on a variadic parameter, eg:
26488 template<typename... Args>
26489 void foo (Args... args)
26491 int arr[] = { args... };
26494 template<int... vals>
26497 int arr[] = { vals... };
26500 If the array has no length and has an initializer, it must be that
26501 we couldn't determine its length in cp_complete_array_type because
26502 it is dependent. */
26503 if (VAR_P (expression
)
26504 && TREE_TYPE (expression
) != NULL_TREE
26505 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
26506 && !TYPE_DOMAIN (TREE_TYPE (expression
))
26507 && DECL_INITIAL (expression
))
26510 /* A function or variable template-id is type-dependent if it has any
26511 dependent template arguments. */
26512 if (VAR_OR_FUNCTION_DECL_P (expression
)
26513 && DECL_LANG_SPECIFIC (expression
)
26514 && DECL_TEMPLATE_INFO (expression
))
26516 /* Consider the innermost template arguments, since those are the ones
26517 that come from the template-id; the template arguments for the
26518 enclosing class do not make it type-dependent unless they are used in
26519 the type of the decl. */
26520 if (instantiates_primary_template_p (expression
)
26521 && (any_dependent_template_arguments_p
26522 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
26526 /* Otherwise, if the function decl isn't from a dependent scope, it can't be
26527 type-dependent. Checking this is important for functions with auto return
26528 type, which looks like a dependent type. */
26529 if (TREE_CODE (expression
) == FUNCTION_DECL
26530 && !(DECL_CLASS_SCOPE_P (expression
)
26531 && dependent_type_p (DECL_CONTEXT (expression
)))
26532 && !(DECL_LANG_SPECIFIC (expression
)
26533 && DECL_FRIEND_P (expression
)
26534 && (!DECL_FRIEND_CONTEXT (expression
)
26535 || dependent_type_p (DECL_FRIEND_CONTEXT (expression
))))
26536 && !DECL_LOCAL_FUNCTION_P (expression
))
26538 gcc_assert (!dependent_type_p (TREE_TYPE (expression
))
26539 || undeduced_auto_decl (expression
));
26543 /* Always dependent, on the number of arguments if nothing else. */
26544 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
26547 if (TREE_TYPE (expression
) == unknown_type_node
)
26549 if (TREE_CODE (expression
) == ADDR_EXPR
)
26550 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
26551 if (TREE_CODE (expression
) == COMPONENT_REF
26552 || TREE_CODE (expression
) == OFFSET_REF
)
26554 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
26556 expression
= TREE_OPERAND (expression
, 1);
26557 if (identifier_p (expression
))
26560 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
26561 if (TREE_CODE (expression
) == SCOPE_REF
)
26564 if (BASELINK_P (expression
))
26566 if (BASELINK_OPTYPE (expression
)
26567 && dependent_type_p (BASELINK_OPTYPE (expression
)))
26569 expression
= BASELINK_FUNCTIONS (expression
);
26572 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
26574 if (any_dependent_template_arguments_p
26575 (TREE_OPERAND (expression
, 1)))
26577 expression
= TREE_OPERAND (expression
, 0);
26578 if (identifier_p (expression
))
26582 gcc_assert (OVL_P (expression
));
26584 for (lkp_iterator
iter (expression
); iter
; ++iter
)
26585 if (type_dependent_expression_p (*iter
))
26591 /* The type of a non-type template parm declared with a placeholder type
26592 depends on the corresponding template argument, even though
26593 placeholders are not normally considered dependent. */
26594 if (TREE_CODE (expression
) == TEMPLATE_PARM_INDEX
26595 && is_auto (TREE_TYPE (expression
)))
26598 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
26600 /* Dependent type attributes might not have made it from the decl to
26602 if (DECL_P (expression
)
26603 && any_dependent_type_attributes_p (DECL_ATTRIBUTES (expression
)))
26606 return (dependent_type_p (TREE_TYPE (expression
)));
26609 /* [temp.dep.expr]/5: A class member access expression (5.2.5) is
26610 type-dependent if the expression refers to a member of the current
26611 instantiation and the type of the referenced member is dependent, or the
26612 class member access expression refers to a member of an unknown
26615 This function returns true if the OBJECT in such a class member access
26616 expression is of an unknown specialization. */
26619 type_dependent_object_expression_p (tree object
)
26621 /* An IDENTIFIER_NODE can sometimes have a TREE_TYPE, but it's still
26623 if (TREE_CODE (object
) == IDENTIFIER_NODE
)
26625 tree scope
= TREE_TYPE (object
);
26626 return (!scope
|| dependent_scope_p (scope
));
26629 /* walk_tree callback function for instantiation_dependent_expression_p,
26630 below. Returns non-zero if a dependent subexpression is found. */
26633 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
26638 /* We don't have to worry about decltype currently because decltype
26639 of an instantiation-dependent expr is a dependent type. This
26640 might change depending on the resolution of DR 1172. */
26641 *walk_subtrees
= false;
26644 enum tree_code code
= TREE_CODE (*tp
);
26647 /* Don't treat an argument list as dependent just because it has no
26651 case NONTYPE_ARGUMENT_PACK
:
26654 case TEMPLATE_PARM_INDEX
:
26655 if (dependent_type_p (TREE_TYPE (*tp
)))
26657 if (TEMPLATE_PARM_PARAMETER_PACK (*tp
))
26659 /* We'll check value-dependence separately. */
26662 /* Handle expressions with type operands. */
26666 case AT_ENCODE_EXPR
:
26668 tree op
= TREE_OPERAND (*tp
, 0);
26669 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
26670 op
= TREE_TYPE (op
);
26673 if (dependent_type_p (op
))
26677 *walk_subtrees
= false;
26684 case COMPONENT_REF
:
26685 if (identifier_p (TREE_OPERAND (*tp
, 1)))
26686 /* In a template, finish_class_member_access_expr creates a
26687 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
26688 type-dependent, so that we can check access control at
26689 instantiation time (PR 42277). See also Core issue 1273. */
26694 if (instantiation_dependent_scope_ref_p (*tp
))
26699 /* Treat statement-expressions as dependent. */
26703 /* Treat requires-expressions as dependent. */
26704 case REQUIRES_EXPR
:
26708 /* Treat concept checks as dependent. */
26709 if (concept_check_p (*tp
))
26713 case TEMPLATE_ID_EXPR
:
26714 /* Treat concept checks as dependent. */
26715 if (concept_check_p (*tp
))
26720 if (CONSTRUCTOR_IS_DEPENDENT (*tp
))
26728 if (type_dependent_expression_p (*tp
))
26734 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
26735 sense defined by the ABI:
26737 "An expression is instantiation-dependent if it is type-dependent
26738 or value-dependent, or it has a subexpression that is type-dependent
26739 or value-dependent."
26741 Except don't actually check value-dependence for unevaluated expressions,
26742 because in sizeof(i) we don't care about the value of i. Checking
26743 type-dependence will in turn check value-dependence of array bounds/template
26744 arguments as needed. */
26747 instantiation_dependent_uneval_expression_p (tree expression
)
26751 if (!processing_template_decl
)
26754 if (expression
== error_mark_node
)
26757 result
= cp_walk_tree_without_duplicates (&expression
,
26758 instantiation_dependent_r
, NULL
);
26759 return result
!= NULL_TREE
;
26762 /* As above, but also check value-dependence of the expression as a whole. */
26765 instantiation_dependent_expression_p (tree expression
)
26767 return (instantiation_dependent_uneval_expression_p (expression
)
26768 || value_dependent_expression_p (expression
));
26771 /* Like type_dependent_expression_p, but it also works while not processing
26772 a template definition, i.e. during substitution or mangling. */
26775 type_dependent_expression_p_push (tree expr
)
26778 ++processing_template_decl
;
26779 b
= type_dependent_expression_p (expr
);
26780 --processing_template_decl
;
26784 /* Returns TRUE if ARGS contains a type-dependent expression. */
26787 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
26792 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
26794 if (type_dependent_expression_p (arg
))
26800 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
26801 expressions) contains any type-dependent expressions. */
26804 any_type_dependent_elements_p (const_tree list
)
26806 for (; list
; list
= TREE_CHAIN (list
))
26807 if (type_dependent_expression_p (TREE_VALUE (list
)))
26813 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
26814 expressions) contains any value-dependent expressions. */
26817 any_value_dependent_elements_p (const_tree list
)
26819 for (; list
; list
= TREE_CHAIN (list
))
26820 if (value_dependent_expression_p (TREE_VALUE (list
)))
26826 /* Returns TRUE if the ARG (a template argument) is dependent. */
26829 dependent_template_arg_p (tree arg
)
26831 if (!processing_template_decl
)
26834 /* Assume a template argument that was wrongly written by the user
26835 is dependent. This is consistent with what
26836 any_dependent_template_arguments_p [that calls this function]
26838 if (!arg
|| arg
== error_mark_node
)
26841 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
26842 arg
= argument_pack_select_arg (arg
);
26844 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
26846 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
26848 if (DECL_TEMPLATE_PARM_P (arg
))
26850 /* A member template of a dependent class is not necessarily
26851 type-dependent, but it is a dependent template argument because it
26852 will be a member of an unknown specialization to that template. */
26853 tree scope
= CP_DECL_CONTEXT (arg
);
26854 return TYPE_P (scope
) && dependent_type_p (scope
);
26856 else if (ARGUMENT_PACK_P (arg
))
26858 tree args
= ARGUMENT_PACK_ARGS (arg
);
26859 int i
, len
= TREE_VEC_LENGTH (args
);
26860 for (i
= 0; i
< len
; ++i
)
26862 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
26868 else if (TYPE_P (arg
))
26869 return dependent_type_p (arg
);
26871 return (type_dependent_expression_p (arg
)
26872 || value_dependent_expression_p (arg
));
26875 /* Returns true if ARGS (a collection of template arguments) contains
26876 any types that require structural equality testing. */
26879 any_template_arguments_need_structural_equality_p (tree args
)
26886 if (args
== error_mark_node
)
26889 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
26891 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
26892 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
26894 tree arg
= TREE_VEC_ELT (level
, j
);
26895 tree packed_args
= NULL_TREE
;
26898 if (ARGUMENT_PACK_P (arg
))
26900 /* Look inside the argument pack. */
26901 packed_args
= ARGUMENT_PACK_ARGS (arg
);
26902 len
= TREE_VEC_LENGTH (packed_args
);
26905 for (k
= 0; k
< len
; ++k
)
26908 arg
= TREE_VEC_ELT (packed_args
, k
);
26910 if (error_operand_p (arg
))
26912 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
26914 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
26916 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
26917 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
26926 /* Returns true if ARGS (a collection of template arguments) contains
26927 any dependent arguments. */
26930 any_dependent_template_arguments_p (const_tree args
)
26937 if (args
== error_mark_node
)
26940 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
26942 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
26943 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
26944 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
26951 /* Returns true if ARGS contains any errors. */
26954 any_erroneous_template_args_p (const_tree args
)
26959 if (args
== error_mark_node
)
26962 if (args
&& TREE_CODE (args
) != TREE_VEC
)
26964 if (tree ti
= get_template_info (args
))
26965 args
= TI_ARGS (ti
);
26973 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
26975 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
26976 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
26977 if (error_operand_p (TREE_VEC_ELT (level
, j
)))
26984 /* Returns TRUE if the template TMPL is type-dependent. */
26987 dependent_template_p (tree tmpl
)
26989 if (TREE_CODE (tmpl
) == OVERLOAD
)
26991 for (lkp_iterator
iter (tmpl
); iter
; ++iter
)
26992 if (dependent_template_p (*iter
))
26997 /* Template template parameters are dependent. */
26998 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
26999 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
27001 /* So are names that have not been looked up. */
27002 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
27007 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
27010 dependent_template_id_p (tree tmpl
, tree args
)
27012 return (dependent_template_p (tmpl
)
27013 || any_dependent_template_arguments_p (args
));
27016 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
27020 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
27024 if (!processing_template_decl
)
27027 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
27029 tree decl
= TREE_VEC_ELT (declv
, i
);
27030 tree init
= TREE_VEC_ELT (initv
, i
);
27031 tree cond
= TREE_VEC_ELT (condv
, i
);
27032 tree incr
= TREE_VEC_ELT (incrv
, i
);
27034 if (type_dependent_expression_p (decl
)
27035 || TREE_CODE (decl
) == SCOPE_REF
)
27038 if (init
&& type_dependent_expression_p (init
))
27041 if (cond
== global_namespace
)
27044 if (type_dependent_expression_p (cond
))
27047 if (COMPARISON_CLASS_P (cond
)
27048 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
27049 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
27052 if (TREE_CODE (incr
) == MODOP_EXPR
)
27054 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
27055 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
27058 else if (type_dependent_expression_p (incr
))
27060 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
27062 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
27064 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
27066 tree t
= TREE_OPERAND (incr
, 1);
27067 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
27068 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
27071 /* If this loop has a class iterator with != comparison
27072 with increment other than i++/++i/i--/--i, make sure the
27073 increment is constant. */
27074 if (CLASS_TYPE_P (TREE_TYPE (decl
))
27075 && TREE_CODE (cond
) == NE_EXPR
)
27077 if (TREE_OPERAND (t
, 0) == decl
)
27078 t
= TREE_OPERAND (t
, 1);
27080 t
= TREE_OPERAND (t
, 0);
27081 if (TREE_CODE (t
) != INTEGER_CST
)
27091 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
27092 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
27093 no such TYPE can be found. Note that this function peers inside
27094 uninstantiated templates and therefore should be used only in
27095 extremely limited situations. ONLY_CURRENT_P restricts this
27096 peering to the currently open classes hierarchy (which is required
27097 when comparing types). */
27100 resolve_typename_type (tree type
, bool only_current_p
)
27109 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
27111 scope
= TYPE_CONTEXT (type
);
27112 /* We shouldn't have built a TYPENAME_TYPE with a non-dependent scope. */
27113 gcc_checking_assert (uses_template_parms (scope
));
27115 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
27116 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
27117 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
27118 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
27119 identifier of the TYPENAME_TYPE anymore.
27120 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
27121 TYPENAME_TYPE instead, we avoid messing up with a possible
27122 typedef variant case. */
27123 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
27125 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
27126 it first before we can figure out what NAME refers to. */
27127 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
27129 if (TYPENAME_IS_RESOLVING_P (scope
))
27130 /* Given a class template A with a dependent base with nested type C,
27131 typedef typename A::C::C C will land us here, as trying to resolve
27132 the initial A::C leads to the local C typedef, which leads back to
27133 A::C::C. So we break the recursion now. */
27136 scope
= resolve_typename_type (scope
, only_current_p
);
27138 /* If we don't know what SCOPE refers to, then we cannot resolve the
27140 if (!CLASS_TYPE_P (scope
))
27142 /* If this is a typedef, we don't want to look inside (c++/11987). */
27143 if (typedef_variant_p (type
))
27145 /* If SCOPE isn't the template itself, it will not have a valid
27146 TYPE_FIELDS list. */
27147 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
27148 /* scope is either the template itself or a compatible instantiation
27149 like X<T>, so look up the name in the original template. */
27150 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
27151 /* If scope has no fields, it can't be a current instantiation. Check this
27152 before currently_open_class to avoid infinite recursion (71515). */
27153 if (!TYPE_FIELDS (scope
))
27155 /* If the SCOPE is not the current instantiation, there's no reason
27156 to look inside it. */
27157 if (only_current_p
&& !currently_open_class (scope
))
27159 /* Enter the SCOPE so that name lookup will be resolved as if we
27160 were in the class definition. In particular, SCOPE will no
27161 longer be considered a dependent type. */
27162 pushed_scope
= push_scope (scope
);
27163 /* Look up the declaration. */
27164 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
27165 tf_warning_or_error
);
27167 result
= NULL_TREE
;
27169 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
27170 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
27171 tree fullname
= TYPENAME_TYPE_FULLNAME (type
);
27174 else if (identifier_p (fullname
)
27175 && TREE_CODE (decl
) == TYPE_DECL
)
27177 result
= TREE_TYPE (decl
);
27178 if (result
== error_mark_node
)
27179 result
= NULL_TREE
;
27181 else if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
27182 && DECL_CLASS_TEMPLATE_P (decl
))
27184 /* Obtain the template and the arguments. */
27185 tree tmpl
= TREE_OPERAND (fullname
, 0);
27186 if (TREE_CODE (tmpl
) == IDENTIFIER_NODE
)
27188 /* We get here with a plain identifier because a previous tentative
27189 parse of the nested-name-specifier as part of a ptr-operator saw
27190 ::template X<A>. The use of ::template is necessary in a
27191 ptr-operator, but wrong in a declarator-id.
27193 [temp.names]: In a qualified-id of a declarator-id, the keyword
27194 template shall not appear at the top level. */
27195 pedwarn (cp_expr_loc_or_input_loc (fullname
), OPT_Wpedantic
,
27196 "keyword %<template%> not allowed in declarator-id");
27199 tree args
= TREE_OPERAND (fullname
, 1);
27200 /* Instantiate the template. */
27201 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
27202 /*entering_scope=*/true,
27203 tf_error
| tf_user
);
27204 if (result
== error_mark_node
)
27205 result
= NULL_TREE
;
27208 /* Leave the SCOPE. */
27210 pop_scope (pushed_scope
);
27212 /* If we failed to resolve it, return the original typename. */
27216 /* If lookup found a typename type, resolve that too. */
27217 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
27219 /* Ill-formed programs can cause infinite recursion here, so we
27220 must catch that. */
27221 TYPENAME_IS_RESOLVING_P (result
) = 1;
27222 result
= resolve_typename_type (result
, only_current_p
);
27223 TYPENAME_IS_RESOLVING_P (result
) = 0;
27226 /* Qualify the resulting type. */
27227 quals
= cp_type_quals (type
);
27229 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
27234 /* EXPR is an expression which is not type-dependent. Return a proxy
27235 for EXPR that can be used to compute the types of larger
27236 expressions containing EXPR. */
27239 build_non_dependent_expr (tree expr
)
27241 tree orig_expr
= expr
;
27244 /* When checking, try to get a constant value for all non-dependent
27245 expressions in order to expose bugs in *_dependent_expression_p
27246 and constexpr. This can affect code generation, see PR70704, so
27247 only do this for -fchecking=2. */
27248 if (flag_checking
> 1
27249 && cxx_dialect
>= cxx11
27250 /* Don't do this during nsdmi parsing as it can lead to
27251 unexpected recursive instantiations. */
27252 && !parsing_nsdmi ()
27253 /* Don't do this during concept processing either and for
27254 the same reason. */
27255 && !processing_constraint_expression_p ())
27256 fold_non_dependent_expr (expr
, tf_none
);
27258 STRIP_ANY_LOCATION_WRAPPER (expr
);
27260 /* Preserve OVERLOADs; the functions must be available to resolve
27263 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
27264 inner_expr
= stmt_expr_value_expr (inner_expr
);
27265 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
27266 inner_expr
= TREE_OPERAND (inner_expr
, 0);
27267 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
27268 inner_expr
= TREE_OPERAND (inner_expr
, 1);
27269 if (is_overloaded_fn (inner_expr
)
27270 || TREE_CODE (inner_expr
) == OFFSET_REF
)
27272 /* There is no need to return a proxy for a variable or enumerator. */
27273 if (VAR_P (expr
) || TREE_CODE (expr
) == CONST_DECL
)
27275 /* Preserve string constants; conversions from string constants to
27276 "char *" are allowed, even though normally a "const char *"
27277 cannot be used to initialize a "char *". */
27278 if (TREE_CODE (expr
) == STRING_CST
)
27280 /* Preserve void and arithmetic constants, as an optimization -- there is no
27281 reason to create a new node. */
27282 if (TREE_CODE (expr
) == VOID_CST
27283 || TREE_CODE (expr
) == INTEGER_CST
27284 || TREE_CODE (expr
) == REAL_CST
)
27286 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
27287 There is at least one place where we want to know that a
27288 particular expression is a throw-expression: when checking a ?:
27289 expression, there are special rules if the second or third
27290 argument is a throw-expression. */
27291 if (TREE_CODE (expr
) == THROW_EXPR
)
27294 /* Don't wrap an initializer list, we need to be able to look inside. */
27295 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
27298 /* Don't wrap a dummy object, we need to be able to test for it. */
27299 if (is_dummy_object (expr
))
27302 if (TREE_CODE (expr
) == COND_EXPR
)
27303 return build3 (COND_EXPR
,
27305 build_non_dependent_expr (TREE_OPERAND (expr
, 0)),
27306 (TREE_OPERAND (expr
, 1)
27307 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
27308 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
27309 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
27310 if (TREE_CODE (expr
) == COMPOUND_EXPR
27311 && !COMPOUND_EXPR_OVERLOADED (expr
))
27312 return build2 (COMPOUND_EXPR
,
27314 TREE_OPERAND (expr
, 0),
27315 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
27317 /* If the type is unknown, it can't really be non-dependent */
27318 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
27320 /* Otherwise, build a NON_DEPENDENT_EXPR. */
27321 return build1_loc (EXPR_LOCATION (orig_expr
), NON_DEPENDENT_EXPR
,
27322 TREE_TYPE (expr
), expr
);
27325 /* ARGS is a vector of expressions as arguments to a function call.
27326 Replace the arguments with equivalent non-dependent expressions.
27327 This modifies ARGS in place. */
27330 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
27335 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
27337 tree newarg
= build_non_dependent_expr (arg
);
27339 (*args
)[ix
] = newarg
;
27343 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
27344 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
27345 parms. If set_canonical is true, we set TYPE_CANONICAL on it. */
27348 make_auto_1 (tree name
, bool set_canonical
)
27350 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
27351 TYPE_NAME (au
) = build_decl (input_location
, TYPE_DECL
, name
, au
);
27352 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
27353 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
27354 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
27355 TYPE_NAME (au
), NULL_TREE
);
27357 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
27358 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
27359 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
27365 make_decltype_auto (void)
27367 return make_auto_1 (decltype_auto_identifier
, true);
27373 return make_auto_1 (auto_identifier
, true);
27376 /* Return a C++17 deduction placeholder for class template TMPL. */
27379 make_template_placeholder (tree tmpl
)
27381 tree t
= make_auto_1 (auto_identifier
, false);
27382 CLASS_PLACEHOLDER_TEMPLATE (t
) = tmpl
;
27383 /* Our canonical type depends on the placeholder. */
27384 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
27388 /* True iff T is a C++17 class template deduction placeholder. */
27391 template_placeholder_p (tree t
)
27393 return is_auto (t
) && CLASS_PLACEHOLDER_TEMPLATE (t
);
27396 /* Make a "constrained auto" type-specifier. This is an auto or
27397 decltype(auto) type with constraints that must be associated after
27398 deduction. The constraint is formed from the given concept CON
27399 and its optional sequence of template arguments ARGS.
27401 TYPE must be the result of make_auto_type or make_decltype_auto_type. */
27404 make_constrained_placeholder_type (tree type
, tree con
, tree args
)
27406 /* Build the constraint. */
27407 tree tmpl
= DECL_TI_TEMPLATE (con
);
27409 if (TREE_CODE (con
) == FUNCTION_DECL
)
27410 expr
= ovl_make (tmpl
);
27411 expr
= build_concept_check (expr
, type
, args
, tf_warning_or_error
);
27413 PLACEHOLDER_TYPE_CONSTRAINTS (type
) = expr
;
27415 /* Our canonical type depends on the constraint. */
27416 TYPE_CANONICAL (type
) = canonical_type_parameter (type
);
27418 /* Attach the constraint to the type declaration. */
27419 return TYPE_NAME (type
);
27422 /* Make a "constrained auto" type-specifier. */
27425 make_constrained_auto (tree con
, tree args
)
27427 tree type
= make_auto_1 (auto_identifier
, false);
27428 return make_constrained_placeholder_type (type
, con
, args
);
27431 /* Make a "constrained decltype(auto)" type-specifier. */
27434 make_constrained_decltype_auto (tree con
, tree args
)
27436 tree type
= make_auto_1 (decltype_auto_identifier
, false);
27437 /* FIXME: I don't know why this isn't done in make_auto_1. */
27438 AUTO_IS_DECLTYPE (type
) = true;
27439 return make_constrained_placeholder_type (type
, con
, args
);
27442 /* Build and return a concept definition. Like other templates, the
27443 CONCEPT_DECL node is wrapped by a TEMPLATE_DECL. This returns the
27444 the TEMPLATE_DECL. */
27447 finish_concept_definition (cp_expr id
, tree init
)
27449 gcc_assert (identifier_p (id
));
27450 gcc_assert (processing_template_decl
);
27452 location_t loc
= id
.get_location();
27454 /* A concept-definition shall not have associated constraints. */
27455 if (TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
))
27457 error_at (loc
, "a concept cannot be constrained");
27458 TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
) = NULL_TREE
;
27461 /* A concept-definition shall appear in namespace scope. Templates
27462 aren't allowed in block scope, so we only need to check for class
27464 if (TYPE_P (current_scope()) || !DECL_NAMESPACE_SCOPE_P (current_scope ()))
27466 error_at (loc
, "concept %qE not in namespace scope", *id
);
27467 return error_mark_node
;
27470 /* Initially build the concept declaration; it's type is bool. */
27471 tree decl
= build_lang_decl_loc (loc
, CONCEPT_DECL
, *id
, boolean_type_node
);
27472 DECL_CONTEXT (decl
) = current_scope ();
27473 DECL_INITIAL (decl
) = init
;
27475 /* Push the enclosing template. */
27476 return push_template_decl (decl
);
27479 /* Given type ARG, return std::initializer_list<ARG>. */
27484 tree std_init_list
= get_namespace_binding (std_node
, init_list_identifier
);
27486 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
27488 gcc_rich_location
richloc (input_location
);
27489 maybe_add_include_fixit (&richloc
, "<initializer_list>", false);
27490 error_at (&richloc
,
27491 "deducing from brace-enclosed initializer list"
27492 " requires %<#include <initializer_list>%>");
27494 return error_mark_node
;
27496 tree argvec
= make_tree_vec (1);
27497 TREE_VEC_ELT (argvec
, 0) = arg
;
27499 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
27500 NULL_TREE
, 0, tf_warning_or_error
);
27503 /* Replace auto in TYPE with std::initializer_list<auto>. */
27506 listify_autos (tree type
, tree auto_node
)
27508 tree init_auto
= listify (strip_top_quals (auto_node
));
27509 tree argvec
= make_tree_vec (1);
27510 TREE_VEC_ELT (argvec
, 0) = init_auto
;
27511 if (processing_template_decl
)
27512 argvec
= add_to_template_args (current_template_args (), argvec
);
27513 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
27516 /* Hash traits for hashing possibly constrained 'auto'
27517 TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
27519 struct auto_hash
: default_hash_traits
<tree
>
27521 static inline hashval_t
hash (tree
);
27522 static inline bool equal (tree
, tree
);
27525 /* Hash the 'auto' T. */
27528 auto_hash::hash (tree t
)
27530 if (tree c
= NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS (t
)))
27531 /* Matching constrained-type-specifiers denote the same template
27532 parameter, so hash the constraint. */
27533 return hash_placeholder_constraint (c
);
27535 /* But unconstrained autos are all separate, so just hash the pointer. */
27536 return iterative_hash_object (t
, 0);
27539 /* Compare two 'auto's. */
27542 auto_hash::equal (tree t1
, tree t2
)
27547 tree c1
= PLACEHOLDER_TYPE_CONSTRAINTS (t1
);
27548 tree c2
= PLACEHOLDER_TYPE_CONSTRAINTS (t2
);
27550 /* Two unconstrained autos are distinct. */
27554 return equivalent_placeholder_constraints (c1
, c2
);
27557 /* for_each_template_parm callback for extract_autos: if t is a (possibly
27558 constrained) auto, add it to the vector. */
27561 extract_autos_r (tree t
, void *data
)
27563 hash_table
<auto_hash
> &hash
= *(hash_table
<auto_hash
>*)data
;
27566 /* All the autos were built with index 0; fix that up now. */
27567 tree
*p
= hash
.find_slot (t
, INSERT
);
27570 /* If this is a repeated constrained-type-specifier, use the index we
27572 idx
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (*p
));
27575 /* Otherwise this is new, so use the current count. */
27577 idx
= hash
.elements () - 1;
27579 TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (t
)) = idx
;
27582 /* Always keep walking. */
27586 /* Return a TREE_VEC of the 'auto's used in type under the Concepts TS, which
27587 says they can appear anywhere in the type. */
27590 extract_autos (tree type
)
27592 hash_set
<tree
> visited
;
27593 hash_table
<auto_hash
> hash (2);
27595 for_each_template_parm (type
, extract_autos_r
, &hash
, &visited
, true);
27597 tree tree_vec
= make_tree_vec (hash
.elements());
27598 for (hash_table
<auto_hash
>::iterator iter
= hash
.begin();
27599 iter
!= hash
.end(); ++iter
)
27602 unsigned i
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (elt
));
27603 TREE_VEC_ELT (tree_vec
, i
)
27604 = build_tree_list (NULL_TREE
, TYPE_NAME (elt
));
27610 /* The stem for deduction guide names. */
27611 const char *const dguide_base
= "__dguide_";
27613 /* Return the name for a deduction guide for class template TMPL. */
27616 dguide_name (tree tmpl
)
27618 tree type
= (TYPE_P (tmpl
) ? tmpl
: TREE_TYPE (tmpl
));
27619 tree tname
= TYPE_IDENTIFIER (type
);
27620 char *buf
= (char *) alloca (1 + strlen (dguide_base
)
27621 + IDENTIFIER_LENGTH (tname
));
27622 memcpy (buf
, dguide_base
, strlen (dguide_base
));
27623 memcpy (buf
+ strlen (dguide_base
), IDENTIFIER_POINTER (tname
),
27624 IDENTIFIER_LENGTH (tname
) + 1);
27625 tree dname
= get_identifier (buf
);
27626 TREE_TYPE (dname
) = type
;
27630 /* True if NAME is the name of a deduction guide. */
27633 dguide_name_p (tree name
)
27635 return (TREE_CODE (name
) == IDENTIFIER_NODE
27636 && TREE_TYPE (name
)
27637 && !strncmp (IDENTIFIER_POINTER (name
), dguide_base
,
27638 strlen (dguide_base
)));
27641 /* True if FN is a deduction guide. */
27644 deduction_guide_p (const_tree fn
)
27647 if (tree name
= DECL_NAME (fn
))
27648 return dguide_name_p (name
);
27652 /* True if FN is the copy deduction guide, i.e. A(A)->A. */
27655 copy_guide_p (const_tree fn
)
27657 gcc_assert (deduction_guide_p (fn
));
27658 if (!DECL_ARTIFICIAL (fn
))
27660 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (DECL_TI_TEMPLATE (fn
));
27661 return (TREE_CHAIN (parms
) == void_list_node
27662 && same_type_p (TREE_VALUE (parms
), TREE_TYPE (DECL_NAME (fn
))));
27665 /* True if FN is a guide generated from a constructor template. */
27668 template_guide_p (const_tree fn
)
27670 gcc_assert (deduction_guide_p (fn
));
27671 if (!DECL_ARTIFICIAL (fn
))
27673 tree tmpl
= DECL_TI_TEMPLATE (fn
);
27674 if (tree org
= DECL_ABSTRACT_ORIGIN (tmpl
))
27675 return PRIMARY_TEMPLATE_P (org
);
27679 /* OLDDECL is a _DECL for a template parameter. Return a similar parameter at
27680 LEVEL:INDEX, using tsubst_args and complain for substitution into non-type
27681 template parameter types. Note that the handling of template template
27682 parameters relies on current_template_parms being set appropriately for the
27686 rewrite_template_parm (tree olddecl
, unsigned index
, unsigned level
,
27687 tree tsubst_args
, tsubst_flags_t complain
)
27689 if (olddecl
== error_mark_node
)
27690 return error_mark_node
;
27692 tree oldidx
= get_template_parm_index (olddecl
);
27695 if (TREE_CODE (olddecl
) == TYPE_DECL
27696 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
27698 tree oldtype
= TREE_TYPE (olddecl
);
27699 newtype
= cxx_make_type (TREE_CODE (oldtype
));
27700 TYPE_MAIN_VARIANT (newtype
) = newtype
;
27701 if (TREE_CODE (oldtype
) == TEMPLATE_TYPE_PARM
)
27702 TEMPLATE_TYPE_PARM_FOR_CLASS (newtype
)
27703 = TEMPLATE_TYPE_PARM_FOR_CLASS (oldtype
);
27707 newtype
= TREE_TYPE (olddecl
);
27708 if (type_uses_auto (newtype
))
27710 // Substitute once to fix references to other template parameters.
27711 newtype
= tsubst (newtype
, tsubst_args
,
27712 complain
|tf_partial
, NULL_TREE
);
27713 // Now substitute again to reduce the level of the auto.
27714 newtype
= tsubst (newtype
, current_template_args (),
27715 complain
, NULL_TREE
);
27718 newtype
= tsubst (newtype
, tsubst_args
,
27719 complain
, NULL_TREE
);
27723 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TREE_CODE (olddecl
),
27724 DECL_NAME (olddecl
), newtype
);
27725 SET_DECL_TEMPLATE_PARM_P (newdecl
);
27728 if (TREE_CODE (olddecl
) == TYPE_DECL
27729 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
27731 newidx
= TEMPLATE_TYPE_PARM_INDEX (newtype
)
27732 = build_template_parm_index (index
, level
, level
,
27734 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
27735 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
27736 TYPE_STUB_DECL (newtype
) = TYPE_NAME (newtype
) = newdecl
;
27737 TYPE_CANONICAL (newtype
) = canonical_type_parameter (newtype
);
27739 if (TREE_CODE (olddecl
) == TEMPLATE_DECL
)
27741 DECL_TEMPLATE_RESULT (newdecl
)
27742 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TYPE_DECL
,
27743 DECL_NAME (olddecl
), newtype
);
27744 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (newdecl
)) = true;
27745 // First create a copy (ttargs) of tsubst_args with an
27746 // additional level for the template template parameter's own
27747 // template parameters (ttparms).
27748 tree ttparms
= (INNERMOST_TEMPLATE_PARMS
27749 (DECL_TEMPLATE_PARMS (olddecl
)));
27750 const int depth
= TMPL_ARGS_DEPTH (tsubst_args
);
27751 tree ttargs
= make_tree_vec (depth
+ 1);
27752 for (int i
= 0; i
< depth
; ++i
)
27753 TREE_VEC_ELT (ttargs
, i
) = TREE_VEC_ELT (tsubst_args
, i
);
27754 TREE_VEC_ELT (ttargs
, depth
)
27755 = template_parms_level_to_args (ttparms
);
27756 // Substitute ttargs into ttparms to fix references to
27757 // other template parameters.
27758 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
27759 complain
|tf_partial
);
27760 // Now substitute again with args based on tparms, to reduce
27761 // the level of the ttparms.
27762 ttargs
= current_template_args ();
27763 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
27765 // Finally, tack the adjusted parms onto tparms.
27766 ttparms
= tree_cons (size_int (depth
), ttparms
,
27767 current_template_parms
);
27768 DECL_TEMPLATE_PARMS (newdecl
) = ttparms
;
27773 tree oldconst
= TEMPLATE_PARM_DECL (oldidx
);
27775 = build_decl (DECL_SOURCE_LOCATION (oldconst
),
27776 TREE_CODE (oldconst
),
27777 DECL_NAME (oldconst
), newtype
);
27778 TREE_CONSTANT (newconst
) = TREE_CONSTANT (newdecl
)
27779 = TREE_READONLY (newconst
) = TREE_READONLY (newdecl
) = true;
27780 SET_DECL_TEMPLATE_PARM_P (newconst
);
27781 newidx
= build_template_parm_index (index
, level
, level
,
27782 newconst
, newtype
);
27783 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
27784 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
27785 DECL_INITIAL (newdecl
) = DECL_INITIAL (newconst
) = newidx
;
27791 /* As rewrite_template_parm, but for the whole TREE_LIST representing a
27792 template parameter. */
27795 rewrite_tparm_list (tree oldelt
, unsigned index
, unsigned level
,
27796 tree targs
, unsigned targs_index
, tsubst_flags_t complain
)
27798 tree olddecl
= TREE_VALUE (oldelt
);
27799 tree newdecl
= rewrite_template_parm (olddecl
, index
, level
,
27801 if (newdecl
== error_mark_node
)
27802 return error_mark_node
;
27803 tree newdef
= tsubst_template_arg (TREE_PURPOSE (oldelt
),
27804 targs
, complain
, NULL_TREE
);
27805 tree list
= build_tree_list (newdef
, newdecl
);
27806 TEMPLATE_PARM_CONSTRAINTS (list
)
27807 = tsubst_constraint_info (TEMPLATE_PARM_CONSTRAINTS (oldelt
),
27808 targs
, complain
, NULL_TREE
);
27809 int depth
= TMPL_ARGS_DEPTH (targs
);
27810 TMPL_ARG (targs
, depth
, targs_index
) = template_parm_to_arg (list
);
27814 /* Returns a C++17 class deduction guide template based on the constructor
27815 CTOR. As a special case, CTOR can be a RECORD_TYPE for an implicit default
27816 guide, REFERENCE_TYPE for an implicit copy/move guide, or TREE_LIST for an
27817 aggregate initialization guide. */
27820 build_deduction_guide (tree type
, tree ctor
, tree outer_args
, tsubst_flags_t complain
)
27822 tree tparms
, targs
, fparms
, fargs
, ci
;
27823 bool memtmpl
= false;
27826 tree fn_tmpl
= NULL_TREE
;
27830 ++processing_template_decl
;
27831 type
= tsubst (type
, outer_args
, complain
, CLASSTYPE_TI_TEMPLATE (type
));
27832 --processing_template_decl
;
27835 if (!DECL_DECLARES_FUNCTION_P (ctor
))
27839 bool copy_p
= TYPE_REF_P (ctor
);
27841 fparms
= tree_cons (NULL_TREE
, type
, void_list_node
);
27843 fparms
= void_list_node
;
27845 else if (TREE_CODE (ctor
) == TREE_LIST
)
27848 gcc_unreachable ();
27850 tree ctmpl
= CLASSTYPE_TI_TEMPLATE (type
);
27851 tparms
= DECL_TEMPLATE_PARMS (ctmpl
);
27852 targs
= CLASSTYPE_TI_ARGS (type
);
27855 loc
= DECL_SOURCE_LOCATION (ctmpl
);
27856 explicit_p
= false;
27860 ++processing_template_decl
;
27864 = (TREE_CODE (ctor
) == TEMPLATE_DECL
? ctor
27865 : DECL_TI_TEMPLATE (ctor
));
27867 fn_tmpl
= tsubst (fn_tmpl
, outer_args
, complain
, ctor
);
27868 ctor
= DECL_TEMPLATE_RESULT (fn_tmpl
);
27870 tparms
= DECL_TEMPLATE_PARMS (fn_tmpl
);
27871 /* If type is a member class template, DECL_TI_ARGS (ctor) will have
27872 fully specialized args for the enclosing class. Strip those off, as
27873 the deduction guide won't have those template parameters. */
27874 targs
= get_innermost_template_args (DECL_TI_ARGS (ctor
),
27875 TMPL_PARMS_DEPTH (tparms
));
27876 /* Discard the 'this' parameter. */
27877 fparms
= FUNCTION_ARG_CHAIN (ctor
);
27878 fargs
= TREE_CHAIN (DECL_ARGUMENTS (ctor
));
27879 ci
= get_constraints (ctor
);
27880 loc
= DECL_SOURCE_LOCATION (ctor
);
27881 explicit_p
= DECL_NONCONVERTING_P (ctor
);
27883 if (PRIMARY_TEMPLATE_P (fn_tmpl
))
27887 /* For a member template constructor, we need to flatten the two
27888 template parameter lists into one, and then adjust the function
27889 signature accordingly. This gets...complicated. */
27890 tree save_parms
= current_template_parms
;
27892 /* For a member template we should have two levels of parms/args, one
27893 for the class and one for the constructor. We stripped
27894 specialized args for further enclosing classes above. */
27895 const int depth
= 2;
27896 gcc_assert (TMPL_ARGS_DEPTH (targs
) == depth
);
27898 /* Template args for translating references to the two-level template
27899 parameters into references to the one-level template parameters we
27901 tree tsubst_args
= copy_node (targs
);
27902 TMPL_ARGS_LEVEL (tsubst_args
, depth
)
27903 = copy_node (TMPL_ARGS_LEVEL (tsubst_args
, depth
));
27905 /* Template parms for the constructor template. */
27906 tree ftparms
= TREE_VALUE (tparms
);
27907 unsigned flen
= TREE_VEC_LENGTH (ftparms
);
27908 /* Template parms for the class template. */
27909 tparms
= TREE_CHAIN (tparms
);
27910 tree ctparms
= TREE_VALUE (tparms
);
27911 unsigned clen
= TREE_VEC_LENGTH (ctparms
);
27912 /* Template parms for the deduction guide start as a copy of the
27913 template parms for the class. We set current_template_parms for
27914 lookup_template_class_1. */
27915 current_template_parms
= tparms
= copy_node (tparms
);
27916 tree new_vec
= TREE_VALUE (tparms
) = make_tree_vec (flen
+ clen
);
27917 for (unsigned i
= 0; i
< clen
; ++i
)
27918 TREE_VEC_ELT (new_vec
, i
) = TREE_VEC_ELT (ctparms
, i
);
27920 /* Now we need to rewrite the constructor parms to append them to the
27922 for (unsigned i
= 0; i
< flen
; ++i
)
27924 unsigned index
= i
+ clen
;
27925 unsigned level
= 1;
27926 tree oldelt
= TREE_VEC_ELT (ftparms
, i
);
27928 = rewrite_tparm_list (oldelt
, index
, level
,
27929 tsubst_args
, i
, complain
);
27930 if (newelt
== error_mark_node
)
27932 TREE_VEC_ELT (new_vec
, index
) = newelt
;
27935 /* Now we have a final set of template parms to substitute into the
27936 function signature. */
27937 targs
= template_parms_to_args (tparms
);
27938 fparms
= tsubst_arg_types (fparms
, tsubst_args
, NULL_TREE
,
27940 if (fparms
== error_mark_node
)
27942 fargs
= tsubst (fargs
, tsubst_args
, complain
, ctor
);
27944 ci
= tsubst_constraint_info (ci
, tsubst_args
, complain
, ctor
);
27946 current_template_parms
= save_parms
;
27949 --processing_template_decl
;
27951 return error_mark_node
;
27956 /* Copy the parms so we can set DECL_PRIMARY_TEMPLATE. */
27957 tparms
= copy_node (tparms
);
27958 INNERMOST_TEMPLATE_PARMS (tparms
)
27959 = copy_node (INNERMOST_TEMPLATE_PARMS (tparms
));
27962 tree fntype
= build_function_type (type
, fparms
);
27963 tree ded_fn
= build_lang_decl_loc (loc
,
27965 dguide_name (type
), fntype
);
27966 DECL_ARGUMENTS (ded_fn
) = fargs
;
27967 DECL_ARTIFICIAL (ded_fn
) = true;
27968 DECL_NONCONVERTING_P (ded_fn
) = explicit_p
;
27969 tree ded_tmpl
= build_template_decl (ded_fn
, tparms
, /*member*/false);
27970 DECL_ARTIFICIAL (ded_tmpl
) = true;
27971 DECL_TEMPLATE_RESULT (ded_tmpl
) = ded_fn
;
27972 TREE_TYPE (ded_tmpl
) = TREE_TYPE (ded_fn
);
27973 DECL_TEMPLATE_INFO (ded_fn
) = build_template_info (ded_tmpl
, targs
);
27974 DECL_PRIMARY_TEMPLATE (ded_tmpl
) = ded_tmpl
;
27976 DECL_ABSTRACT_ORIGIN (ded_tmpl
) = fn_tmpl
;
27978 set_constraints (ded_tmpl
, ci
);
27983 /* Add to LIST the member types for the reshaped initializer CTOR. */
27986 collect_ctor_idx_types (tree ctor
, tree list
)
27988 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (ctor
);
27989 tree idx
, val
; unsigned i
;
27990 FOR_EACH_CONSTRUCTOR_ELT (v
, i
, idx
, val
)
27992 if (BRACE_ENCLOSED_INITIALIZER_P (val
)
27993 && CONSTRUCTOR_NELTS (val
))
27994 if (tree subidx
= CONSTRUCTOR_ELT (val
, 0)->index
)
27995 if (TREE_CODE (subidx
) == FIELD_DECL
)
27997 list
= collect_ctor_idx_types (val
, list
);
28000 tree ftype
= finish_decltype_type (idx
, true, tf_none
);
28001 list
= tree_cons (NULL_TREE
, ftype
, list
);
28007 /* Return whether ETYPE is, or is derived from, a specialization of TMPL. */
28010 is_spec_or_derived (tree etype
, tree tmpl
)
28012 if (!etype
|| !CLASS_TYPE_P (etype
))
28015 tree type
= TREE_TYPE (tmpl
);
28016 tree tparms
= (INNERMOST_TEMPLATE_PARMS
28017 (DECL_TEMPLATE_PARMS (tmpl
)));
28018 tree targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
28019 int err
= unify (tparms
, targs
, type
, etype
,
28020 UNIFY_ALLOW_DERIVED
, /*explain*/false);
28025 /* Return a C++20 aggregate deduction candidate for TYPE initialized from
28029 maybe_aggr_guide (tree tmpl
, tree init
, vec
<tree
,va_gc
> *args
)
28031 if (cxx_dialect
< cxx2a
)
28034 if (init
== NULL_TREE
)
28037 tree type
= TREE_TYPE (tmpl
);
28038 if (!CP_AGGREGATE_TYPE_P (type
))
28041 /* No aggregate candidate for copy-initialization. */
28042 if (args
->length() == 1)
28044 tree val
= (*args
)[0];
28045 if (is_spec_or_derived (tmpl
, TREE_TYPE (val
)))
28049 /* If we encounter a problem, we just won't add the candidate. */
28050 tsubst_flags_t complain
= tf_none
;
28052 tree parms
= NULL_TREE
;
28053 if (TREE_CODE (init
) == CONSTRUCTOR
)
28055 init
= reshape_init (type
, init
, complain
);
28056 if (init
== error_mark_node
)
28058 parms
= collect_ctor_idx_types (init
, parms
);
28060 else if (TREE_CODE (init
) == TREE_LIST
)
28062 int len
= list_length (init
);
28063 for (tree field
= TYPE_FIELDS (type
);
28065 --len
, field
= DECL_CHAIN (field
))
28067 field
= next_initializable_field (field
);
28070 tree ftype
= finish_decltype_type (field
, true, complain
);
28071 parms
= tree_cons (NULL_TREE
, ftype
, parms
);
28075 /* Aggregate initialization doesn't apply to an initializer expression. */
28081 parms
= nreverse (parms
);
28082 TREE_CHAIN (last
) = void_list_node
;
28083 tree guide
= build_deduction_guide (type
, parms
, NULL_TREE
, complain
);
28090 /* UGUIDES are the deduction guides for the underlying template of alias
28091 template TMPL; adjust them to be deduction guides for TMPL. */
28094 alias_ctad_tweaks (tree tmpl
, tree uguides
)
28096 /* [over.match.class.deduct]: When resolving a placeholder for a deduced
28097 class type (9.2.8.2) where the template-name names an alias template A,
28098 the defining-type-id of A must be of the form
28100 typename(opt) nested-name-specifier(opt) template(opt) simple-template-id
28102 as specified in 9.2.8.2. The guides of A are the set of functions or
28103 function templates formed as follows. For each function or function
28104 template f in the guides of the template named by the simple-template-id
28105 of the defining-type-id, the template arguments of the return type of f
28106 are deduced from the defining-type-id of A according to the process in
28107 13.10.2.5 with the exception that deduction does not fail if not all
28108 template arguments are deduced. Let g denote the result of substituting
28109 these deductions into f. If substitution succeeds, form a function or
28110 function template f' with the following properties and add it to the set
28113 * The function type of f' is the function type of g.
28115 * If f is a function template, f' is a function template whose template
28116 parameter list consists of all the template parameters of A (including
28117 their default template arguments) that appear in the above deductions or
28118 (recursively) in their default template arguments, followed by the
28119 template parameters of f that were not deduced (including their default
28120 template arguments), otherwise f' is not a function template.
28122 * The associated constraints (13.5.2) are the conjunction of the
28123 associated constraints of g and a constraint that is satisfied if and only
28124 if the arguments of A are deducible (see below) from the return type.
28126 * If f is a copy deduction candidate (12.4.1.8), then f' is considered to
28129 * If f was generated from a deduction-guide (12.4.1.8), then f' is
28130 considered to be so as well.
28132 * The explicit-specifier of f' is the explicit-specifier of g (if
28135 /* This implementation differs from the above in two significant ways:
28137 1) We include all template parameters of A, not just some.
28138 2) The added constraint is same_type instead of deducible.
28140 I believe that while it's probably possible to construct a testcase that
28141 behaves differently with this simplification, it should have the same
28142 effect for real uses. Including all template parameters means that we
28143 deduce all parameters of A when resolving the call, so when we're in the
28144 constraint we don't need to deduce them again, we can just check whether
28145 the deduction produced the desired result. */
28147 tsubst_flags_t complain
= tf_warning_or_error
;
28148 tree atype
= TREE_TYPE (tmpl
);
28149 tree aguides
= NULL_TREE
;
28150 tree atparms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
28151 unsigned natparms
= TREE_VEC_LENGTH (atparms
);
28152 tree utype
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
28153 for (ovl_iterator
iter (uguides
); iter
; ++iter
)
28157 location_t loc
= DECL_SOURCE_LOCATION (f
);
28158 tree ret
= TREE_TYPE (TREE_TYPE (f
));
28160 if (TREE_CODE (f
) == TEMPLATE_DECL
)
28162 processing_template_decl_sentinel
ptds (/*reset*/false);
28163 ++processing_template_decl
;
28165 /* Deduce template arguments for f from the type-id of A. */
28166 tree ftparms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (f
));
28167 unsigned len
= TREE_VEC_LENGTH (ftparms
);
28168 tree targs
= make_tree_vec (len
);
28169 int err
= unify (ftparms
, targs
, ret
, utype
, UNIFY_ALLOW_NONE
, false);
28172 /* The number of parms for f' is the number of parms for A plus
28173 non-deduced parms of f. */
28174 unsigned ndlen
= 0;
28176 for (unsigned i
= 0; i
< len
; ++i
)
28177 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
28179 tree gtparms
= make_tree_vec (natparms
+ ndlen
);
28181 /* First copy over the parms of A. */
28182 for (j
= 0; j
< natparms
; ++j
)
28183 TREE_VEC_ELT (gtparms
, j
) = TREE_VEC_ELT (atparms
, j
);
28184 /* Now rewrite the non-deduced parms of f. */
28185 for (unsigned i
= 0; ndlen
&& i
< len
; ++i
)
28186 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
28189 unsigned index
= j
++;
28190 unsigned level
= 1;
28191 tree oldlist
= TREE_VEC_ELT (ftparms
, i
);
28192 tree list
= rewrite_tparm_list (oldlist
, index
, level
,
28193 targs
, i
, complain
);
28194 TREE_VEC_ELT (gtparms
, index
) = list
;
28196 gtparms
= build_tree_list (size_one_node
, gtparms
);
28198 /* Substitute the deduced arguments plus the rewritten template
28199 parameters into f to get g. This covers the type, copyness,
28200 guideness, and explicit-specifier. */
28201 tree g
= tsubst_decl (DECL_TEMPLATE_RESULT (f
), targs
, complain
);
28202 if (g
== error_mark_node
)
28203 return error_mark_node
;
28204 DECL_USE_TEMPLATE (g
) = 0;
28205 fprime
= build_template_decl (g
, gtparms
, false);
28206 DECL_TEMPLATE_RESULT (fprime
) = g
;
28207 TREE_TYPE (fprime
) = TREE_TYPE (g
);
28208 tree gtargs
= template_parms_to_args (gtparms
);
28209 DECL_TEMPLATE_INFO (g
) = build_template_info (fprime
, gtargs
);
28210 DECL_PRIMARY_TEMPLATE (fprime
) = fprime
;
28212 /* Substitute the associated constraints. */
28213 tree ci
= get_constraints (f
);
28215 ci
= tsubst_constraint_info (ci
, targs
, complain
, in_decl
);
28216 if (ci
== error_mark_node
)
28217 return error_mark_node
;
28219 /* Add a constraint that the return type matches the instantiation of
28220 A with the same template arguments. */
28221 ret
= TREE_TYPE (TREE_TYPE (fprime
));
28222 if (!same_type_p (atype
, ret
)
28223 /* FIXME this should mean they don't compare as equivalent. */
28224 || dependent_alias_template_spec_p (atype
, nt_opaque
))
28226 tree same
= finish_trait_expr (loc
, CPTK_IS_SAME_AS
, atype
, ret
);
28227 ci
= append_constraint (ci
, same
);
28231 set_constraints (fprime
, ci
);
28235 /* For a non-template deduction guide, if the arguments of A aren't
28236 deducible from the return type, don't add the candidate. */
28237 tree targs
= make_tree_vec (natparms
);
28238 int err
= unify (atparms
, targs
, utype
, ret
, UNIFY_ALLOW_NONE
, false);
28239 for (unsigned i
= 0; !err
&& i
< natparms
; ++i
)
28240 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
28246 aguides
= lookup_add (fprime
, aguides
);
28252 /* Return artificial deduction guides built from the constructors of class
28256 ctor_deduction_guides_for (tree tmpl
, tsubst_flags_t complain
)
28258 tree type
= TREE_TYPE (tmpl
);
28259 tree outer_args
= NULL_TREE
;
28260 if (DECL_CLASS_SCOPE_P (tmpl
)
28261 && CLASSTYPE_TEMPLATE_INSTANTIATION (DECL_CONTEXT (tmpl
)))
28263 outer_args
= CLASSTYPE_TI_ARGS (DECL_CONTEXT (tmpl
));
28264 type
= TREE_TYPE (most_general_template (tmpl
));
28267 tree cands
= NULL_TREE
;
28269 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (type
)); iter
; ++iter
)
28271 /* Skip inherited constructors. */
28272 if (iter
.using_p ())
28275 tree guide
= build_deduction_guide (type
, *iter
, outer_args
, complain
);
28276 cands
= lookup_add (guide
, cands
);
28279 /* Add implicit default constructor deduction guide. */
28280 if (!TYPE_HAS_USER_CONSTRUCTOR (type
))
28282 tree guide
= build_deduction_guide (type
, type
, outer_args
,
28284 cands
= lookup_add (guide
, cands
);
28287 /* Add copy guide. */
28289 tree gtype
= build_reference_type (type
);
28290 tree guide
= build_deduction_guide (type
, gtype
, outer_args
,
28292 cands
= lookup_add (guide
, cands
);
28298 static GTY((deletable
)) hash_map
<tree
, tree_pair_p
> *dguide_cache
;
28300 /* Return the non-aggregate deduction guides for deducible template TMPL. The
28301 aggregate candidate is added separately because it depends on the
28305 deduction_guides_for (tree tmpl
, tsubst_flags_t complain
)
28307 tree guides
= NULL_TREE
;
28308 if (DECL_ALIAS_TEMPLATE_P (tmpl
))
28310 tree under
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
28311 tree tinfo
= get_template_info (under
);
28312 guides
= deduction_guides_for (TI_TEMPLATE (tinfo
), complain
);
28316 guides
= lookup_qualified_name (CP_DECL_CONTEXT (tmpl
),
28317 dguide_name (tmpl
),
28318 /*type*/false, /*complain*/false,
28320 if (guides
== error_mark_node
)
28321 guides
= NULL_TREE
;
28324 /* Cache the deduction guides for a template. We also remember the result of
28325 lookup, and rebuild everything if it changes; should be very rare. */
28326 tree_pair_p cache
= NULL
;
28328 = hash_map_safe_get_or_insert
<hm_ggc
> (dguide_cache
, tmpl
))
28331 if (cache
->purpose
== guides
)
28332 return cache
->value
;
28336 r
= cache
= ggc_cleared_alloc
<tree_pair_s
> ();
28337 cache
->purpose
= guides
;
28340 tree cands
= NULL_TREE
;
28341 if (DECL_ALIAS_TEMPLATE_P (tmpl
))
28342 cands
= alias_ctad_tweaks (tmpl
, guides
);
28345 cands
= ctor_deduction_guides_for (tmpl
, complain
);
28346 for (ovl_iterator
it (guides
); it
; ++it
)
28347 cands
= lookup_add (*it
, cands
);
28350 cache
->value
= cands
;
28354 /* Return whether TMPL is a (class template argument-) deducible template. */
28357 ctad_template_p (tree tmpl
)
28359 /* A deducible template is either a class template or is an alias template
28360 whose defining-type-id is of the form
28362 typename(opt) nested-name-specifier(opt) template(opt) simple-template-id
28364 where the nested-name-specifier (if any) is non-dependent and the
28365 template-name of the simple-template-id names a deducible template. */
28367 if (DECL_CLASS_TEMPLATE_P (tmpl
)
28368 || DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
))
28370 if (!DECL_ALIAS_TEMPLATE_P (tmpl
))
28372 tree orig
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
28373 if (tree tinfo
= get_template_info (orig
))
28374 return ctad_template_p (TI_TEMPLATE (tinfo
));
28378 /* Deduce template arguments for the class template placeholder PTYPE for
28379 template TMPL based on the initializer INIT, and return the resulting
28383 do_class_deduction (tree ptype
, tree tmpl
, tree init
,
28384 int flags
, tsubst_flags_t complain
)
28386 /* We should have handled this in the caller. */
28387 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
))
28390 /* Look through alias templates that just rename another template. */
28391 tmpl
= get_underlying_template (tmpl
);
28392 if (!ctad_template_p (tmpl
))
28394 if (complain
& tf_error
)
28395 error ("non-deducible template %qT used without template arguments", tmpl
);
28396 return error_mark_node
;
28398 else if (cxx_dialect
< cxx2a
&& DECL_ALIAS_TEMPLATE_P (tmpl
))
28400 /* This doesn't affect conforming C++17 code, so just pedwarn. */
28401 if (complain
& tf_warning_or_error
)
28402 pedwarn (input_location
, 0, "alias template deduction only available "
28403 "with %<-std=c++2a%> or %<-std=gnu++2a%>");
28406 if (init
&& TREE_TYPE (init
) == ptype
)
28407 /* Using the template parm as its own argument. */
28410 tree type
= TREE_TYPE (tmpl
);
28412 bool try_list_ctor
= false;
28414 releasing_vec rv_args
= NULL
;
28415 vec
<tree
,va_gc
> *&args
= *&rv_args
;
28416 if (init
== NULL_TREE
)
28417 args
= make_tree_vector ();
28418 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
28420 try_list_ctor
= TYPE_HAS_LIST_CTOR (type
);
28421 if (try_list_ctor
&& CONSTRUCTOR_NELTS (init
) == 1)
28423 /* As an exception, the first phase in 16.3.1.7 (considering the
28424 initializer list as a single argument) is omitted if the
28425 initializer list consists of a single expression of type cv U,
28426 where U is a specialization of C or a class derived from a
28427 specialization of C. */
28428 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
28429 if (is_spec_or_derived (TREE_TYPE (elt
), tmpl
))
28430 try_list_ctor
= false;
28432 if (try_list_ctor
|| is_std_init_list (type
))
28433 args
= make_tree_vector_single (init
);
28435 args
= make_tree_vector_from_ctor (init
);
28437 else if (TREE_CODE (init
) == TREE_LIST
)
28438 args
= make_tree_vector_from_list (init
);
28440 args
= make_tree_vector_single (init
);
28442 /* Do this now to avoid problems with erroneous args later on. */
28443 args
= resolve_args (args
, complain
);
28445 return error_mark_node
;
28447 tree cands
= deduction_guides_for (tmpl
, complain
);
28448 if (cands
== error_mark_node
)
28449 return error_mark_node
;
28451 /* Prune explicit deduction guides in copy-initialization context. */
28452 bool elided
= false;
28453 if (flags
& LOOKUP_ONLYCONVERTING
)
28455 for (lkp_iterator
iter (cands
); !elided
&& iter
; ++iter
)
28456 if (DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
28461 /* Found a nonconverting guide, prune the candidates. */
28462 tree pruned
= NULL_TREE
;
28463 for (lkp_iterator
iter (cands
); iter
; ++iter
)
28464 if (!DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
28465 pruned
= lookup_add (*iter
, pruned
);
28471 if (tree guide
= maybe_aggr_guide (tmpl
, init
, args
))
28472 cands
= lookup_add (guide
, cands
);
28474 tree call
= error_mark_node
;
28476 /* If this is list-initialization and the class has a list constructor, first
28477 try deducing from the list as a single argument, as [over.match.list]. */
28478 tree list_cands
= NULL_TREE
;
28479 if (try_list_ctor
&& cands
)
28480 for (lkp_iterator
iter (cands
); iter
; ++iter
)
28483 if (is_list_ctor (dg
))
28484 list_cands
= lookup_add (dg
, list_cands
);
28488 ++cp_unevaluated_operand
;
28489 call
= build_new_function_call (list_cands
, &args
, tf_decltype
);
28490 --cp_unevaluated_operand
;
28492 if (call
== error_mark_node
)
28494 /* That didn't work, now try treating the list as a sequence of
28496 release_tree_vector (args
);
28497 args
= make_tree_vector_from_ctor (init
);
28501 if (elided
&& !cands
)
28503 error ("cannot deduce template arguments for copy-initialization"
28504 " of %qT, as it has no non-explicit deduction guides or "
28505 "user-declared constructors", type
);
28506 return error_mark_node
;
28508 else if (!cands
&& call
== error_mark_node
)
28510 error ("cannot deduce template arguments of %qT, as it has no viable "
28511 "deduction guides", type
);
28512 return error_mark_node
;
28515 if (call
== error_mark_node
)
28517 ++cp_unevaluated_operand
;
28518 call
= build_new_function_call (cands
, &args
, tf_decltype
);
28519 --cp_unevaluated_operand
;
28522 if (call
== error_mark_node
28523 && (complain
& tf_warning_or_error
))
28525 error ("class template argument deduction failed:");
28527 ++cp_unevaluated_operand
;
28528 call
= build_new_function_call (cands
, &args
, complain
| tf_decltype
);
28529 --cp_unevaluated_operand
;
28532 inform (input_location
, "explicit deduction guides not considered "
28533 "for copy-initialization");
28536 return cp_build_qualified_type (TREE_TYPE (call
), cp_type_quals (ptype
));
28539 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
28540 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
28541 The CONTEXT determines the context in which auto deduction is performed
28542 and is used to control error diagnostics. FLAGS are the LOOKUP_* flags.
28543 OUTER_TARGS are used during template argument deduction
28544 (context == adc_unify) to properly substitute the result, and is ignored
28547 For partial-concept-ids, extra args may be appended to the list of deduced
28548 template arguments prior to determining constraint satisfaction. */
28551 do_auto_deduction (tree type
, tree init
, tree auto_node
,
28552 tsubst_flags_t complain
, auto_deduction_context context
,
28553 tree outer_targs
, int flags
)
28557 if (init
== error_mark_node
)
28558 return error_mark_node
;
28560 if (init
&& type_dependent_expression_p (init
)
28561 && context
!= adc_unify
)
28562 /* Defining a subset of type-dependent expressions that we can deduce
28563 from ahead of time isn't worth the trouble. */
28566 /* Similarly, we can't deduce from another undeduced decl. */
28567 if (init
&& undeduced_auto_decl (init
))
28570 /* We may be doing a partial substitution, but we still want to replace
28572 complain
&= ~tf_partial
;
28574 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
28575 /* C++17 class template argument deduction. */
28576 return do_class_deduction (type
, tmpl
, init
, flags
, complain
);
28578 if (init
== NULL_TREE
|| TREE_TYPE (init
) == NULL_TREE
)
28579 /* Nothing we can do with this, even in deduction context. */
28582 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
28583 with either a new invented type template parameter U or, if the
28584 initializer is a braced-init-list (8.5.4), with
28585 std::initializer_list<U>. */
28586 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
28588 if (!DIRECT_LIST_INIT_P (init
))
28589 type
= listify_autos (type
, auto_node
);
28590 else if (CONSTRUCTOR_NELTS (init
) == 1)
28591 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
28594 if (complain
& tf_warning_or_error
)
28596 if (permerror (input_location
, "direct-list-initialization of "
28597 "%<auto%> requires exactly one element"))
28598 inform (input_location
,
28599 "for deduction to %<std::initializer_list%>, use copy-"
28600 "list-initialization (i.e. add %<=%> before the %<{%>)");
28602 type
= listify_autos (type
, auto_node
);
28606 if (type
== error_mark_node
)
28607 return error_mark_node
;
28609 init
= resolve_nondeduced_context (init
, complain
);
28611 if (context
== adc_decomp_type
28612 && auto_node
== type
28613 && init
!= error_mark_node
28614 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
28615 /* [dcl.decomp]/1 - if decomposition declaration has no ref-qualifiers
28616 and initializer has array type, deduce cv-qualified array type. */
28617 return cp_build_qualified_type_real (TREE_TYPE (init
), TYPE_QUALS (type
),
28619 else if (AUTO_IS_DECLTYPE (auto_node
))
28621 tree stripped_init
= tree_strip_any_location_wrapper (init
);
28622 bool id
= (DECL_P (stripped_init
)
28623 || ((TREE_CODE (init
) == COMPONENT_REF
28624 || TREE_CODE (init
) == SCOPE_REF
)
28625 && !REF_PARENTHESIZED_P (init
)));
28626 targs
= make_tree_vec (1);
28627 TREE_VEC_ELT (targs
, 0)
28628 = finish_decltype_type (init
, id
, tf_warning_or_error
);
28629 if (type
!= auto_node
)
28631 if (complain
& tf_error
)
28632 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
28633 return error_mark_node
;
28638 if (error_operand_p (init
))
28639 return error_mark_node
;
28641 tree parms
= build_tree_list (NULL_TREE
, type
);
28645 tparms
= extract_autos (type
);
28648 tparms
= make_tree_vec (1);
28649 TREE_VEC_ELT (tparms
, 0)
28650 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
28653 targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
28654 int val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
28656 NULL
, /*explain_p=*/false);
28659 if (processing_template_decl
)
28660 /* Try again at instantiation time. */
28662 if (type
&& type
!= error_mark_node
28663 && (complain
& tf_error
))
28664 /* If type is error_mark_node a diagnostic must have been
28665 emitted by now. Also, having a mention to '<type error>'
28666 in the diagnostic is not really useful to the user. */
28669 && FNDECL_USED_AUTO (current_function_decl
)
28671 == DECL_SAVED_AUTO_RETURN_TYPE (current_function_decl
))
28672 && LAMBDA_FUNCTION_P (current_function_decl
))
28673 error ("unable to deduce lambda return type from %qE", init
);
28675 error ("unable to deduce %qT from %qE", type
, init
);
28676 type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
28678 NULL
, /*explain_p=*/true);
28680 return error_mark_node
;
28684 /* Check any placeholder constraints against the deduced type. */
28685 if (flag_concepts
&& !processing_template_decl
)
28686 if (tree check
= NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS (auto_node
)))
28688 /* Use the deduced type to check the associated constraints. If we
28689 have a partial-concept-id, rebuild the argument list so that
28690 we check using the extra arguments. */
28691 check
= unpack_concept_check (check
);
28692 gcc_assert (TREE_CODE (check
) == TEMPLATE_ID_EXPR
);
28693 tree
cdecl = TREE_OPERAND (check
, 0);
28695 cdecl = OVL_FIRST (cdecl);
28696 tree cargs
= TREE_OPERAND (check
, 1);
28697 if (TREE_VEC_LENGTH (cargs
) > 1)
28699 cargs
= copy_node (cargs
);
28700 TREE_VEC_ELT (cargs
, 0) = TREE_VEC_ELT (targs
, 0);
28705 /* Rebuild the check using the deduced arguments. */
28706 check
= build_concept_check (cdecl, cargs
, tf_none
);
28708 if (!constraints_satisfied_p (check
))
28710 if (complain
& tf_warning_or_error
)
28712 auto_diagnostic_group d
;
28715 case adc_unspecified
:
28717 error("placeholder constraints not satisfied");
28719 case adc_variable_type
:
28720 case adc_decomp_type
:
28721 error ("deduced initializer does not satisfy "
28722 "placeholder constraints");
28724 case adc_return_type
:
28725 error ("deduced return type does not satisfy "
28726 "placeholder constraints");
28728 case adc_requirement
:
28729 error ("deduced expression type does not satisfy "
28730 "placeholder constraints");
28733 diagnose_constraints (input_location
, check
, targs
);
28735 return error_mark_node
;
28739 if (processing_template_decl
&& context
!= adc_unify
)
28740 outer_targs
= current_template_args ();
28741 targs
= add_to_template_args (outer_targs
, targs
);
28742 return tsubst (type
, targs
, complain
, NULL_TREE
);
28745 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
28749 splice_late_return_type (tree type
, tree late_return_type
)
28751 if (is_auto (type
))
28753 if (late_return_type
)
28754 return late_return_type
;
28756 tree idx
= get_template_parm_index (type
);
28757 if (TEMPLATE_PARM_LEVEL (idx
) <= processing_template_decl
)
28758 /* In an abbreviated function template we didn't know we were dealing
28759 with a function template when we saw the auto return type, so update
28760 it to have the correct level. */
28761 return make_auto_1 (TYPE_IDENTIFIER (type
), true);
28766 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
28767 'decltype(auto)' or a deduced class template. */
28770 is_auto (const_tree type
)
28772 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
28773 && (TYPE_IDENTIFIER (type
) == auto_identifier
28774 || TYPE_IDENTIFIER (type
) == decltype_auto_identifier
))
28780 /* for_each_template_parm callback for type_uses_auto. */
28783 is_auto_r (tree tp
, void */
*data*/
)
28785 return is_auto (tp
);
28788 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
28789 a use of `auto'. Returns NULL_TREE otherwise. */
28792 type_uses_auto (tree type
)
28794 if (type
== NULL_TREE
)
28796 else if (flag_concepts
)
28798 /* The Concepts TS allows multiple autos in one type-specifier; just
28799 return the first one we find, do_auto_deduction will collect all of
28801 if (uses_template_parms (type
))
28802 return for_each_template_parm (type
, is_auto_r
, /*data*/NULL
,
28803 /*visited*/NULL
, /*nondeduced*/false);
28808 return find_type_usage (type
, is_auto
);
28811 /* Report ill-formed occurrences of auto types in ARGUMENTS. If
28812 concepts are enabled, auto is acceptable in template arguments, but
28813 only when TEMPL identifies a template class. Return TRUE if any
28814 such errors were reported. */
28817 check_auto_in_tmpl_args (tree tmpl
, tree args
)
28819 /* If there were previous errors, nevermind. */
28820 if (!args
|| TREE_CODE (args
) != TREE_VEC
)
28823 /* If TMPL is an identifier, we're parsing and we can't tell yet
28824 whether TMPL is supposed to be a type, a function or a variable.
28825 We'll only be able to tell during template substitution, so we
28826 expect to be called again then. If concepts are enabled and we
28827 know we have a type, we're ok. */
28829 && (identifier_p (tmpl
)
28831 && (DECL_TYPE_TEMPLATE_P (tmpl
)
28832 || DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)))))
28835 /* Quickly search for any occurrences of auto; usually there won't
28836 be any, and then we'll avoid allocating the vector. */
28837 if (!type_uses_auto (args
))
28840 bool errors
= false;
28842 tree vec
= extract_autos (args
);
28843 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); i
++)
28845 tree xauto
= TREE_VALUE (TREE_VEC_ELT (vec
, i
));
28846 error_at (DECL_SOURCE_LOCATION (xauto
),
28847 "invalid use of %qT in template argument", xauto
);
28854 /* For a given template T, return the vector of typedefs referenced
28855 in T for which access check is needed at T instantiation time.
28856 T is either a FUNCTION_DECL or a RECORD_TYPE.
28857 Those typedefs were added to T by the function
28858 append_type_to_template_for_access_check. */
28860 vec
<qualified_typedef_usage_t
, va_gc
> *
28861 get_types_needing_access_check (tree t
)
28864 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
28866 if (!t
|| t
== error_mark_node
)
28869 if (!(ti
= get_template_info (t
)))
28872 if (CLASS_TYPE_P (t
)
28873 || TREE_CODE (t
) == FUNCTION_DECL
)
28875 if (!TI_TEMPLATE (ti
))
28878 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
28884 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
28885 tied to T. That list of typedefs will be access checked at
28886 T instantiation time.
28887 T is either a FUNCTION_DECL or a RECORD_TYPE.
28888 TYPE_DECL is a TYPE_DECL node representing a typedef.
28889 SCOPE is the scope through which TYPE_DECL is accessed.
28890 LOCATION is the location of the usage point of TYPE_DECL.
28892 This function is a subroutine of
28893 append_type_to_template_for_access_check. */
28896 append_type_to_template_for_access_check_1 (tree t
,
28899 location_t location
)
28901 qualified_typedef_usage_t typedef_usage
;
28904 if (!t
|| t
== error_mark_node
)
28907 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
28908 || CLASS_TYPE_P (t
))
28910 && TREE_CODE (type_decl
) == TYPE_DECL
28913 if (!(ti
= get_template_info (t
)))
28916 gcc_assert (TI_TEMPLATE (ti
));
28918 typedef_usage
.typedef_decl
= type_decl
;
28919 typedef_usage
.context
= scope
;
28920 typedef_usage
.locus
= location
;
28922 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
28925 /* Append TYPE_DECL to the template TEMPL.
28926 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
28927 At TEMPL instanciation time, TYPE_DECL will be checked to see
28928 if it can be accessed through SCOPE.
28929 LOCATION is the location of the usage point of TYPE_DECL.
28931 e.g. consider the following code snippet:
28938 template<class U> struct S
28940 C::myint mi; // <-- usage point of the typedef C::myint
28945 At S<char> instantiation time, we need to check the access of C::myint
28946 In other words, we need to check the access of the myint typedef through
28947 the C scope. For that purpose, this function will add the myint typedef
28948 and the scope C through which its being accessed to a list of typedefs
28949 tied to the template S. That list will be walked at template instantiation
28950 time and access check performed on each typedefs it contains.
28951 Note that this particular code snippet should yield an error because
28952 myint is private to C. */
28955 append_type_to_template_for_access_check (tree templ
,
28958 location_t location
)
28960 qualified_typedef_usage_t
*iter
;
28963 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
28965 /* Make sure we don't append the type to the template twice. */
28966 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
28967 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
28970 append_type_to_template_for_access_check_1 (templ
, type_decl
,
28974 /* Recursively walk over && expressions searching for EXPR. Return a reference
28975 to that expression. */
28977 static tree
*find_template_requirement (tree
*t
, tree key
)
28981 if (TREE_CODE (*t
) == TRUTH_ANDIF_EXPR
)
28983 if (tree
*p
= find_template_requirement (&TREE_OPERAND (*t
, 0), key
))
28985 if (tree
*p
= find_template_requirement (&TREE_OPERAND (*t
, 1), key
))
28991 /* Convert the generic type parameters in PARM that match the types given in the
28992 range [START_IDX, END_IDX) from the current_template_parms into generic type
28996 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
28998 tree current
= current_template_parms
;
28999 int depth
= TMPL_PARMS_DEPTH (current
);
29000 current
= INNERMOST_TEMPLATE_PARMS (current
);
29001 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
29003 for (int i
= 0; i
< start_idx
; ++i
)
29004 TREE_VEC_ELT (replacement
, i
)
29005 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
29007 for (int i
= start_idx
; i
< end_idx
; ++i
)
29009 /* Create a distinct parameter pack type from the current parm and add it
29010 to the replacement args to tsubst below into the generic function
29012 tree node
= TREE_VEC_ELT (current
, i
);
29013 tree o
= TREE_TYPE (TREE_VALUE (node
));
29014 tree t
= copy_type (o
);
29015 TEMPLATE_TYPE_PARM_INDEX (t
)
29016 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
29018 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
29019 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
29020 TYPE_MAIN_VARIANT (t
) = t
;
29021 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
29022 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
29023 TREE_VEC_ELT (replacement
, i
) = t
;
29025 /* Replace the current template parameter with new pack. */
29026 TREE_VALUE (node
) = TREE_CHAIN (t
);
29028 /* Surgically adjust the associated constraint of adjusted parameter
29029 and it's corresponding contribution to the current template
29031 if (tree constr
= TEMPLATE_PARM_CONSTRAINTS (node
))
29033 tree id
= unpack_concept_check (constr
);
29034 TREE_VEC_ELT (TREE_OPERAND (id
, 1), 0) = template_parm_to_arg (t
);
29035 tree fold
= finish_left_unary_fold_expr (constr
, TRUTH_ANDIF_EXPR
);
29036 TEMPLATE_PARM_CONSTRAINTS (node
) = fold
;
29038 /* If there was a constraint, we also need to replace that in
29039 the template requirements, which we've already built. */
29040 tree
*reqs
= &TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
29041 reqs
= find_template_requirement (reqs
, constr
);
29046 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
29047 TREE_VEC_ELT (replacement
, i
)
29048 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
29050 /* If there are more levels then build up the replacement with the outer
29053 replacement
= add_to_template_args (template_parms_to_args
29054 (TREE_CHAIN (current_template_parms
)),
29057 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
29060 /* __integer_pack(N) in a pack expansion expands to a sequence of numbers from
29064 declare_integer_pack (void)
29066 tree ipfn
= push_library_fn (get_identifier ("__integer_pack"),
29067 build_function_type_list (integer_type_node
,
29070 NULL_TREE
, ECF_CONST
);
29071 DECL_DECLARED_CONSTEXPR_P (ipfn
) = true;
29072 set_decl_built_in_function (ipfn
, BUILT_IN_FRONTEND
,
29073 CP_BUILT_IN_INTEGER_PACK
);
29076 /* Set up the hash tables for template instantiations. */
29079 init_template_processing (void)
29081 /* FIXME: enable sanitization (PR87847) */
29082 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37, false);
29083 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37, false);
29085 if (cxx_dialect
>= cxx11
)
29086 declare_integer_pack ();
29089 /* Print stats about the template hash tables for -fstats. */
29092 print_template_statistics (void)
29094 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
29095 "%f collisions\n", (long) decl_specializations
->size (),
29096 (long) decl_specializations
->elements (),
29097 decl_specializations
->collisions ());
29098 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
29099 "%f collisions\n", (long) type_specializations
->size (),
29100 (long) type_specializations
->elements (),
29101 type_specializations
->collisions ());
29106 namespace selftest
{
29108 /* Verify that build_non_dependent_expr () works, for various expressions,
29109 and that location wrappers don't affect the results. */
29112 test_build_non_dependent_expr ()
29114 location_t loc
= BUILTINS_LOCATION
;
29116 /* Verify constants, without and with location wrappers. */
29117 tree int_cst
= build_int_cst (integer_type_node
, 42);
29118 ASSERT_EQ (int_cst
, build_non_dependent_expr (int_cst
));
29120 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
29121 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
29122 ASSERT_EQ (wrapped_int_cst
, build_non_dependent_expr (wrapped_int_cst
));
29124 tree string_lit
= build_string (4, "foo");
29125 TREE_TYPE (string_lit
) = char_array_type_node
;
29126 string_lit
= fix_string_type (string_lit
);
29127 ASSERT_EQ (string_lit
, build_non_dependent_expr (string_lit
));
29129 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
29130 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
29131 ASSERT_EQ (wrapped_string_lit
,
29132 build_non_dependent_expr (wrapped_string_lit
));
29135 /* Verify that type_dependent_expression_p () works correctly, even
29136 in the presence of location wrapper nodes. */
29139 test_type_dependent_expression_p ()
29141 location_t loc
= BUILTINS_LOCATION
;
29143 tree name
= get_identifier ("foo");
29145 /* If no templates are involved, nothing is type-dependent. */
29146 gcc_assert (!processing_template_decl
);
29147 ASSERT_FALSE (type_dependent_expression_p (name
));
29149 ++processing_template_decl
;
29151 /* Within a template, an unresolved name is always type-dependent. */
29152 ASSERT_TRUE (type_dependent_expression_p (name
));
29154 /* Ensure it copes with NULL_TREE and errors. */
29155 ASSERT_FALSE (type_dependent_expression_p (NULL_TREE
));
29156 ASSERT_FALSE (type_dependent_expression_p (error_mark_node
));
29158 /* A USING_DECL in a template should be type-dependent, even if wrapped
29159 with a location wrapper (PR c++/83799). */
29160 tree using_decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
29161 TREE_TYPE (using_decl
) = integer_type_node
;
29162 ASSERT_TRUE (type_dependent_expression_p (using_decl
));
29163 tree wrapped_using_decl
= maybe_wrap_with_location (using_decl
, loc
);
29164 ASSERT_TRUE (location_wrapper_p (wrapped_using_decl
));
29165 ASSERT_TRUE (type_dependent_expression_p (wrapped_using_decl
));
29167 --processing_template_decl
;
29170 /* Run all of the selftests within this file. */
29175 test_build_non_dependent_expr ();
29176 test_type_dependent_expression_p ();
29179 } // namespace selftest
29181 #endif /* #if CHECKING_P */
29183 #include "gt-cp-pt.h"