1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2017 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Known bugs or deficiencies include:
24 all methods must be provided in header files; can't use a source
25 file that contains only the method templates and "just win". */
29 #include "coretypes.h"
32 #include "stringpool.h"
35 #include "stor-layout.h"
37 #include "c-family/c-objc.h"
38 #include "cp-objcp-common.h"
40 #include "tree-iterator.h"
41 #include "type-utils.h"
43 #include "gcc-rich-location.h"
45 /* The type of functions taking a tree, and some additional data, and
47 typedef int (*tree_fn_t
) (tree
, void*);
49 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
50 instantiations have been deferred, either because their definitions
51 were not yet available, or because we were putting off doing the work. */
52 struct GTY ((chain_next ("%h.next"))) pending_template
{
53 struct pending_template
*next
;
54 struct tinst_level
*tinst
;
57 static GTY(()) struct pending_template
*pending_templates
;
58 static GTY(()) struct pending_template
*last_pending_template
;
60 int processing_template_parmlist
;
61 static int template_header_count
;
63 static GTY(()) tree saved_trees
;
64 static vec
<int> inline_parm_levels
;
66 static GTY(()) struct tinst_level
*current_tinst_level
;
68 static GTY(()) tree saved_access_scope
;
70 /* Live only within one (recursive) call to tsubst_expr. We use
71 this to pass the statement expression node from the STMT_EXPR
72 to the EXPR_STMT that is its result. */
73 static tree cur_stmt_expr
;
75 // -------------------------------------------------------------------------- //
76 // Local Specialization Stack
78 // Implementation of the RAII helper for creating new local
80 local_specialization_stack::local_specialization_stack (lss_policy policy
)
81 : saved (local_specializations
)
83 if (policy
== lss_blank
|| !saved
)
84 local_specializations
= new hash_map
<tree
, tree
>;
86 local_specializations
= new hash_map
<tree
, tree
>(*saved
);
89 local_specialization_stack::~local_specialization_stack ()
91 delete local_specializations
;
92 local_specializations
= saved
;
95 /* True if we've recursed into fn_type_unification too many times. */
96 static bool excessive_deduction_depth
;
98 struct GTY((for_user
)) spec_entry
105 struct spec_hasher
: ggc_ptr_hash
<spec_entry
>
107 static hashval_t
hash (spec_entry
*);
108 static bool equal (spec_entry
*, spec_entry
*);
111 static GTY (()) hash_table
<spec_hasher
> *decl_specializations
;
113 static GTY (()) hash_table
<spec_hasher
> *type_specializations
;
115 /* Contains canonical template parameter types. The vector is indexed by
116 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
117 TREE_LIST, whose TREE_VALUEs contain the canonical template
118 parameters of various types and levels. */
119 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
121 #define UNIFY_ALLOW_NONE 0
122 #define UNIFY_ALLOW_MORE_CV_QUAL 1
123 #define UNIFY_ALLOW_LESS_CV_QUAL 2
124 #define UNIFY_ALLOW_DERIVED 4
125 #define UNIFY_ALLOW_INTEGER 8
126 #define UNIFY_ALLOW_OUTER_LEVEL 16
127 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
128 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
130 enum template_base_result
{
132 tbr_ambiguous_baseclass
,
136 static void push_access_scope (tree
);
137 static void pop_access_scope (tree
);
138 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
139 unification_kind_t
, int,
141 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
142 unification_kind_t
, int, bool, bool);
143 static int unify (tree
, tree
, tree
, tree
, int, bool);
144 static void add_pending_template (tree
);
145 static tree
reopen_tinst_level (struct tinst_level
*);
146 static tree
tsubst_initializer_list (tree
, tree
);
147 static tree
get_partial_spec_bindings (tree
, tree
, tree
);
148 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
150 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
152 static void tsubst_enum (tree
, tree
, tree
);
153 static tree
add_to_template_args (tree
, tree
);
154 static tree
add_outermost_template_args (tree
, tree
);
155 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
156 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
158 static int type_unification_real (tree
, tree
, tree
, const tree
*,
159 unsigned int, int, unification_kind_t
, int,
160 vec
<deferred_access_check
, va_gc
> **,
162 static void note_template_header (int);
163 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
164 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
165 static tree
convert_template_argument (tree
, tree
, tree
,
166 tsubst_flags_t
, int, tree
);
167 static tree
for_each_template_parm (tree
, tree_fn_t
, void*,
168 hash_set
<tree
> *, bool, tree_fn_t
= NULL
);
169 static tree
expand_template_argument_pack (tree
);
170 static tree
build_template_parm_index (int, int, int, tree
, tree
);
171 static bool inline_needs_template_parms (tree
, bool);
172 static void push_inline_template_parms_recursive (tree
, int);
173 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
174 static int mark_template_parm (tree
, void *);
175 static int template_parm_this_level_p (tree
, void *);
176 static tree
tsubst_friend_function (tree
, tree
);
177 static tree
tsubst_friend_class (tree
, tree
);
178 static int can_complete_type_without_circularity (tree
);
179 static tree
get_bindings (tree
, tree
, tree
, bool);
180 static int template_decl_level (tree
);
181 static int check_cv_quals_for_unify (int, tree
, tree
);
182 static void template_parm_level_and_index (tree
, int*, int*);
183 static int unify_pack_expansion (tree
, tree
, tree
,
184 tree
, unification_kind_t
, bool, bool);
185 static tree
copy_template_args (tree
);
186 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
187 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
188 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
189 static tree
most_specialized_partial_spec (tree
, tsubst_flags_t
);
190 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
191 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
192 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
193 static bool check_specialization_scope (void);
194 static tree
process_partial_specialization (tree
);
195 static void set_current_access_from_decl (tree
);
196 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
198 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
199 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
201 static bool template_template_parm_bindings_ok_p (tree
, tree
);
202 static void tsubst_default_arguments (tree
, tsubst_flags_t
);
203 static tree
for_each_template_parm_r (tree
*, int *, void *);
204 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
205 static void copy_default_args_to_explicit_spec (tree
);
206 static bool invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
207 static bool dependent_template_arg_p (tree
);
208 static bool any_template_arguments_need_structural_equality_p (tree
);
209 static bool dependent_type_p_r (tree
);
210 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
211 static tree
tsubst_decl (tree
, tree
, tsubst_flags_t
);
212 static void perform_typedefs_access_check (tree tmpl
, tree targs
);
213 static void append_type_to_template_for_access_check_1 (tree
, tree
, tree
,
215 static tree
listify (tree
);
216 static tree
listify_autos (tree
, tree
);
217 static tree
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
218 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
219 static bool complex_alias_template_p (const_tree tmpl
);
220 static tree
tsubst_attributes (tree
, tree
, tsubst_flags_t
, tree
);
221 static tree
canonicalize_expr_argument (tree
, tsubst_flags_t
);
222 static tree
make_argument_pack (tree
);
223 static void register_parameter_specializations (tree
, tree
);
225 /* Make the current scope suitable for access checking when we are
226 processing T. T can be FUNCTION_DECL for instantiated function
227 template, VAR_DECL for static member variable, or TYPE_DECL for
228 alias template (needed by instantiate_decl). */
231 push_access_scope (tree t
)
233 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
234 || TREE_CODE (t
) == TYPE_DECL
);
236 if (DECL_FRIEND_CONTEXT (t
))
237 push_nested_class (DECL_FRIEND_CONTEXT (t
));
238 else if (DECL_CLASS_SCOPE_P (t
))
239 push_nested_class (DECL_CONTEXT (t
));
241 push_to_top_level ();
243 if (TREE_CODE (t
) == FUNCTION_DECL
)
245 saved_access_scope
= tree_cons
246 (NULL_TREE
, current_function_decl
, saved_access_scope
);
247 current_function_decl
= t
;
251 /* Restore the scope set up by push_access_scope. T is the node we
255 pop_access_scope (tree t
)
257 if (TREE_CODE (t
) == FUNCTION_DECL
)
259 current_function_decl
= TREE_VALUE (saved_access_scope
);
260 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
263 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
266 pop_from_top_level ();
269 /* Do any processing required when DECL (a member template
270 declaration) is finished. Returns the TEMPLATE_DECL corresponding
271 to DECL, unless it is a specialization, in which case the DECL
272 itself is returned. */
275 finish_member_template_decl (tree decl
)
277 if (decl
== error_mark_node
)
278 return error_mark_node
;
280 gcc_assert (DECL_P (decl
));
282 if (TREE_CODE (decl
) == TYPE_DECL
)
286 type
= TREE_TYPE (decl
);
287 if (type
== error_mark_node
)
288 return error_mark_node
;
289 if (MAYBE_CLASS_TYPE_P (type
)
290 && CLASSTYPE_TEMPLATE_INFO (type
)
291 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
293 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
294 check_member_template (tmpl
);
299 else if (TREE_CODE (decl
) == FIELD_DECL
)
300 error ("data member %qD cannot be a member template", decl
);
301 else if (DECL_TEMPLATE_INFO (decl
))
303 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
305 check_member_template (DECL_TI_TEMPLATE (decl
));
306 return DECL_TI_TEMPLATE (decl
);
312 error ("invalid member template declaration %qD", decl
);
314 return error_mark_node
;
317 /* Create a template info node. */
320 build_template_info (tree template_decl
, tree template_args
)
322 tree result
= make_node (TEMPLATE_INFO
);
323 TI_TEMPLATE (result
) = template_decl
;
324 TI_ARGS (result
) = template_args
;
328 /* Return the template info node corresponding to T, whatever T is. */
331 get_template_info (const_tree t
)
333 tree tinfo
= NULL_TREE
;
335 if (!t
|| t
== error_mark_node
)
338 if (TREE_CODE (t
) == NAMESPACE_DECL
339 || TREE_CODE (t
) == PARM_DECL
)
342 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
343 tinfo
= DECL_TEMPLATE_INFO (t
);
345 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
348 if (OVERLOAD_TYPE_P (t
))
349 tinfo
= TYPE_TEMPLATE_INFO (t
);
350 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
351 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
356 /* Returns the template nesting level of the indicated class TYPE.
366 A<T>::B<U> has depth two, while A<T> has depth one.
367 Both A<T>::B<int> and A<int>::B<U> have depth one, if
368 they are instantiations, not specializations.
370 This function is guaranteed to return 0 if passed NULL_TREE so
371 that, for example, `template_class_depth (current_class_type)' is
375 template_class_depth (tree type
)
379 for (depth
= 0; type
&& TREE_CODE (type
) != NAMESPACE_DECL
; )
381 tree tinfo
= get_template_info (type
);
383 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
384 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
388 type
= CP_DECL_CONTEXT (type
);
389 else if (LAMBDA_TYPE_P (type
))
390 type
= LAMBDA_TYPE_EXTRA_SCOPE (type
);
392 type
= CP_TYPE_CONTEXT (type
);
398 /* Subroutine of maybe_begin_member_template_processing.
399 Returns true if processing DECL needs us to push template parms. */
402 inline_needs_template_parms (tree decl
, bool nsdmi
)
404 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
407 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
408 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
411 /* Subroutine of maybe_begin_member_template_processing.
412 Push the template parms in PARMS, starting from LEVELS steps into the
413 chain, and ending at the beginning, since template parms are listed
417 push_inline_template_parms_recursive (tree parmlist
, int levels
)
419 tree parms
= TREE_VALUE (parmlist
);
423 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
425 ++processing_template_decl
;
426 current_template_parms
427 = tree_cons (size_int (processing_template_decl
),
428 parms
, current_template_parms
);
429 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
431 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
433 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
435 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
437 if (error_operand_p (parm
))
440 gcc_assert (DECL_P (parm
));
442 switch (TREE_CODE (parm
))
450 /* Push the CONST_DECL. */
451 pushdecl (TEMPLATE_PARM_DECL (DECL_INITIAL (parm
)));
460 /* Restore the template parameter context for a member template, a
461 friend template defined in a class definition, or a non-template
462 member of template class. */
465 maybe_begin_member_template_processing (tree decl
)
469 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
473 tree ctx
= DECL_CONTEXT (decl
);
474 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
475 /* Disregard full specializations (c++/60999). */
476 && uses_template_parms (ctx
)
477 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
480 if (inline_needs_template_parms (decl
, nsdmi
))
482 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
483 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
485 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
488 parms
= TREE_CHAIN (parms
);
491 push_inline_template_parms_recursive (parms
, levels
);
494 /* Remember how many levels of template parameters we pushed so that
495 we can pop them later. */
496 inline_parm_levels
.safe_push (levels
);
499 /* Undo the effects of maybe_begin_member_template_processing. */
502 maybe_end_member_template_processing (void)
507 if (inline_parm_levels
.length () == 0)
510 last
= inline_parm_levels
.pop ();
511 for (i
= 0; i
< last
; ++i
)
513 --processing_template_decl
;
514 current_template_parms
= TREE_CHAIN (current_template_parms
);
519 /* Return a new template argument vector which contains all of ARGS,
520 but has as its innermost set of arguments the EXTRA_ARGS. */
523 add_to_template_args (tree args
, tree extra_args
)
530 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
533 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
534 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
536 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
537 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
539 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
540 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
545 /* Like add_to_template_args, but only the outermost ARGS are added to
546 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
547 (EXTRA_ARGS) levels are added. This function is used to combine
548 the template arguments from a partial instantiation with the
549 template arguments used to attain the full instantiation from the
550 partial instantiation. */
553 add_outermost_template_args (tree args
, tree extra_args
)
557 /* If there are more levels of EXTRA_ARGS than there are ARGS,
558 something very fishy is going on. */
559 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
561 /* If *all* the new arguments will be the EXTRA_ARGS, just return
563 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
566 /* For the moment, we make ARGS look like it contains fewer levels. */
567 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
569 new_args
= add_to_template_args (args
, extra_args
);
571 /* Now, we restore ARGS to its full dimensions. */
572 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
577 /* Return the N levels of innermost template arguments from the ARGS. */
580 get_innermost_template_args (tree args
, int n
)
588 /* If N is 1, just return the innermost set of template arguments. */
590 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
592 /* If we're not removing anything, just return the arguments we were
594 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
595 gcc_assert (extra_levels
>= 0);
596 if (extra_levels
== 0)
599 /* Make a new set of arguments, not containing the outer arguments. */
600 new_args
= make_tree_vec (n
);
601 for (i
= 1; i
<= n
; ++i
)
602 SET_TMPL_ARGS_LEVEL (new_args
, i
,
603 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
608 /* The inverse of get_innermost_template_args: Return all but the innermost
609 EXTRA_LEVELS levels of template arguments from the ARGS. */
612 strip_innermost_template_args (tree args
, int extra_levels
)
615 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
620 /* If N is 1, just return the outermost set of template arguments. */
622 return TMPL_ARGS_LEVEL (args
, 1);
624 /* If we're not removing anything, just return the arguments we were
626 gcc_assert (extra_levels
>= 0);
627 if (extra_levels
== 0)
630 /* Make a new set of arguments, not containing the inner arguments. */
631 new_args
= make_tree_vec (n
);
632 for (i
= 1; i
<= n
; ++i
)
633 SET_TMPL_ARGS_LEVEL (new_args
, i
,
634 TMPL_ARGS_LEVEL (args
, i
));
639 /* We've got a template header coming up; push to a new level for storing
643 begin_template_parm_list (void)
645 /* We use a non-tag-transparent scope here, which causes pushtag to
646 put tags in this scope, rather than in the enclosing class or
647 namespace scope. This is the right thing, since we want
648 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
649 global template class, push_template_decl handles putting the
650 TEMPLATE_DECL into top-level scope. For a nested template class,
653 template <class T> struct S1 {
654 template <class T> struct S2 {};
657 pushtag contains special code to insert the TEMPLATE_DECL for S2
658 at the right scope. */
659 begin_scope (sk_template_parms
, NULL
);
660 ++processing_template_decl
;
661 ++processing_template_parmlist
;
662 note_template_header (0);
664 /* Add a dummy parameter level while we process the parameter list. */
665 current_template_parms
666 = tree_cons (size_int (processing_template_decl
),
668 current_template_parms
);
671 /* This routine is called when a specialization is declared. If it is
672 invalid to declare a specialization here, an error is reported and
673 false is returned, otherwise this routine will return true. */
676 check_specialization_scope (void)
678 tree scope
= current_scope ();
682 An explicit specialization shall be declared in the namespace of
683 which the template is a member, or, for member templates, in the
684 namespace of which the enclosing class or enclosing class
685 template is a member. An explicit specialization of a member
686 function, member class or static data member of a class template
687 shall be declared in the namespace of which the class template
689 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
691 error ("explicit specialization in non-namespace scope %qD", scope
);
697 In an explicit specialization declaration for a member of a class
698 template or a member template that appears in namespace scope,
699 the member template and some of its enclosing class templates may
700 remain unspecialized, except that the declaration shall not
701 explicitly specialize a class member template if its enclosing
702 class templates are not explicitly specialized as well. */
703 if (current_template_parms
)
705 error ("enclosing class templates are not explicitly specialized");
712 /* We've just seen template <>. */
715 begin_specialization (void)
717 begin_scope (sk_template_spec
, NULL
);
718 note_template_header (1);
719 return check_specialization_scope ();
722 /* Called at then end of processing a declaration preceded by
726 end_specialization (void)
729 reset_specialization ();
732 /* Any template <>'s that we have seen thus far are not referring to a
733 function specialization. */
736 reset_specialization (void)
738 processing_specialization
= 0;
739 template_header_count
= 0;
742 /* We've just seen a template header. If SPECIALIZATION is nonzero,
743 it was of the form template <>. */
746 note_template_header (int specialization
)
748 processing_specialization
= specialization
;
749 template_header_count
++;
752 /* We're beginning an explicit instantiation. */
755 begin_explicit_instantiation (void)
757 gcc_assert (!processing_explicit_instantiation
);
758 processing_explicit_instantiation
= true;
763 end_explicit_instantiation (void)
765 gcc_assert (processing_explicit_instantiation
);
766 processing_explicit_instantiation
= false;
769 /* An explicit specialization or partial specialization of TMPL is being
770 declared. Check that the namespace in which the specialization is
771 occurring is permissible. Returns false iff it is invalid to
772 specialize TMPL in the current namespace. */
775 check_specialization_namespace (tree tmpl
)
777 tree tpl_ns
= decl_namespace_context (tmpl
);
781 An explicit specialization shall be declared in a namespace enclosing the
782 specialized template. An explicit specialization whose declarator-id is
783 not qualified shall be declared in the nearest enclosing namespace of the
784 template, or, if the namespace is inline (7.3.1), any namespace from its
785 enclosing namespace set. */
786 if (current_scope() != DECL_CONTEXT (tmpl
)
787 && !at_namespace_scope_p ())
789 error ("specialization of %qD must appear at namespace scope", tmpl
);
793 if (is_nested_namespace (current_namespace
, tpl_ns
, cxx_dialect
< cxx11
))
794 /* Same or enclosing namespace. */
798 permerror (input_location
,
799 "specialization of %qD in different namespace", tmpl
);
800 inform (DECL_SOURCE_LOCATION (tmpl
),
801 " from definition of %q#D", tmpl
);
806 /* SPEC is an explicit instantiation. Check that it is valid to
807 perform this explicit instantiation in the current namespace. */
810 check_explicit_instantiation_namespace (tree spec
)
814 /* DR 275: An explicit instantiation shall appear in an enclosing
815 namespace of its template. */
816 ns
= decl_namespace_context (spec
);
817 if (!is_nested_namespace (current_namespace
, ns
))
818 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
819 "(which does not enclose namespace %qD)",
820 spec
, current_namespace
, ns
);
823 // Returns the type of a template specialization only if that
824 // specialization needs to be defined. Otherwise (e.g., if the type has
825 // already been defined), the function returns NULL_TREE.
827 maybe_new_partial_specialization (tree type
)
829 // An implicit instantiation of an incomplete type implies
830 // the definition of a new class template.
832 // template<typename T>
835 // template<typename T>
838 // Here, S<T*> is an implicit instantiation of S whose type
840 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
) && !COMPLETE_TYPE_P (type
))
843 // It can also be the case that TYPE is a completed specialization.
844 // Continuing the previous example, suppose we also declare:
846 // template<typename T>
847 // requires Integral<T>
850 // Here, S<T*> refers to the specialization S<T*> defined
851 // above. However, we need to differentiate definitions because
852 // we intend to define a new partial specialization. In this case,
853 // we rely on the fact that the constraints are different for
854 // this declaration than that above.
856 // Note that we also get here for injected class names and
857 // late-parsed template definitions. We must ensure that we
858 // do not create new type declarations for those cases.
859 if (flag_concepts
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
861 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
862 tree args
= CLASSTYPE_TI_ARGS (type
);
864 // If there are no template parameters, this cannot be a new
865 // partial template specializtion?
866 if (!current_template_parms
)
869 // The injected-class-name is not a new partial specialization.
870 if (DECL_SELF_REFERENCE_P (TYPE_NAME (type
)))
873 // If the constraints are not the same as those of the primary
874 // then, we can probably create a new specialization.
875 tree type_constr
= current_template_constraints ();
877 if (type
== TREE_TYPE (tmpl
))
879 tree main_constr
= get_constraints (tmpl
);
880 if (equivalent_constraints (type_constr
, main_constr
))
884 // Also, if there's a pre-existing specialization with matching
885 // constraints, then this also isn't new.
886 tree specs
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
889 tree spec_tmpl
= TREE_VALUE (specs
);
890 tree spec_args
= TREE_PURPOSE (specs
);
891 tree spec_constr
= get_constraints (spec_tmpl
);
892 if (comp_template_args (args
, spec_args
)
893 && equivalent_constraints (type_constr
, spec_constr
))
895 specs
= TREE_CHAIN (specs
);
898 // Create a new type node (and corresponding type decl)
899 // for the newly declared specialization.
900 tree t
= make_class_type (TREE_CODE (type
));
901 CLASSTYPE_DECLARED_CLASS (t
) = CLASSTYPE_DECLARED_CLASS (type
);
902 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (tmpl
, args
));
904 /* We only need a separate type node for storing the definition of this
905 partial specialization; uses of S<T*> are unconstrained, so all are
906 equivalent. So keep TYPE_CANONICAL the same. */
907 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
909 // Build the corresponding type decl.
910 tree d
= create_implicit_typedef (DECL_NAME (tmpl
), t
);
911 DECL_CONTEXT (d
) = TYPE_CONTEXT (t
);
912 DECL_SOURCE_LOCATION (d
) = input_location
;
920 /* The TYPE is being declared. If it is a template type, that means it
921 is a partial specialization. Do appropriate error-checking. */
924 maybe_process_partial_specialization (tree type
)
928 if (type
== error_mark_node
)
929 return error_mark_node
;
931 /* A lambda that appears in specialization context is not itself a
933 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
936 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
938 error ("name of class shadows template template parameter %qD",
940 return error_mark_node
;
943 context
= TYPE_CONTEXT (type
);
945 if (TYPE_ALIAS_P (type
))
947 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (type
);
949 if (tinfo
&& DECL_ALIAS_TEMPLATE_P (TI_TEMPLATE (tinfo
)))
950 error ("specialization of alias template %qD",
951 TI_TEMPLATE (tinfo
));
953 error ("explicit specialization of non-template %qT", type
);
954 return error_mark_node
;
956 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
958 /* This is for ordinary explicit specialization and partial
959 specialization of a template class such as:
961 template <> class C<int>;
965 template <class T> class C<T*>;
967 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
969 if (tree t
= maybe_new_partial_specialization (type
))
971 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (t
))
972 && !at_namespace_scope_p ())
973 return error_mark_node
;
974 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t
);
975 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (t
)) = input_location
;
976 if (processing_template_decl
)
978 tree decl
= push_template_decl (TYPE_MAIN_DECL (t
));
979 if (decl
== error_mark_node
)
980 return error_mark_node
;
981 return TREE_TYPE (decl
);
984 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
985 error ("specialization of %qT after instantiation", type
);
986 else if (errorcount
&& !processing_specialization
987 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
988 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
989 /* Trying to define a specialization either without a template<> header
990 or in an inappropriate place. We've already given an error, so just
991 bail now so we don't actually define the specialization. */
992 return error_mark_node
;
994 else if (CLASS_TYPE_P (type
)
995 && !CLASSTYPE_USE_TEMPLATE (type
)
996 && CLASSTYPE_TEMPLATE_INFO (type
)
997 && context
&& CLASS_TYPE_P (context
)
998 && CLASSTYPE_TEMPLATE_INFO (context
))
1000 /* This is for an explicit specialization of member class
1001 template according to [temp.expl.spec/18]:
1003 template <> template <class U> class C<int>::D;
1005 The context `C<int>' must be an implicit instantiation.
1006 Otherwise this is just a member class template declared
1009 template <> class C<int> { template <class U> class D; };
1010 template <> template <class U> class C<int>::D;
1012 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1013 while in the second case, `C<int>::D' is a primary template
1014 and `C<T>::D' may not exist. */
1016 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
1017 && !COMPLETE_TYPE_P (type
))
1020 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1022 if (current_namespace
1023 != decl_namespace_context (tmpl
))
1025 permerror (input_location
,
1026 "specializing %q#T in different namespace", type
);
1027 permerror (DECL_SOURCE_LOCATION (tmpl
),
1028 " from definition of %q#D", tmpl
);
1031 /* Check for invalid specialization after instantiation:
1033 template <> template <> class C<int>::D<int>;
1034 template <> template <class U> class C<int>::D; */
1036 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
1037 t
; t
= TREE_CHAIN (t
))
1039 tree inst
= TREE_VALUE (t
);
1040 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
1041 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
1043 /* We already have a full specialization of this partial
1044 instantiation, or a full specialization has been
1045 looked up but not instantiated. Reassign it to the
1046 new member specialization template. */
1050 elt
.tmpl
= most_general_template (tmpl
);
1051 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
1054 type_specializations
->remove_elt (&elt
);
1057 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
1060 = type_specializations
->find_slot (&elt
, INSERT
);
1061 entry
= ggc_alloc
<spec_entry
> ();
1066 /* But if we've had an implicit instantiation, that's a
1067 problem ([temp.expl.spec]/6). */
1068 error ("specialization %qT after instantiation %qT",
1072 /* Mark TYPE as a specialization. And as a result, we only
1073 have one level of template argument for the innermost
1075 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
1076 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
1077 CLASSTYPE_TI_ARGS (type
)
1078 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
1081 else if (processing_specialization
)
1083 /* Someday C++0x may allow for enum template specialization. */
1084 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
1085 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
1086 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
1087 "of %qD not allowed by ISO C++", type
);
1090 error ("explicit specialization of non-template %qT", type
);
1091 return error_mark_node
;
1098 /* Returns nonzero if we can optimize the retrieval of specializations
1099 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1100 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1103 optimize_specialization_lookup_p (tree tmpl
)
1105 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
1106 && DECL_CLASS_SCOPE_P (tmpl
)
1107 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1109 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
1110 /* The optimized lookup depends on the fact that the
1111 template arguments for the member function template apply
1112 purely to the containing class, which is not true if the
1113 containing class is an explicit or partial
1115 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1116 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1117 && !DECL_CONV_FN_P (tmpl
)
1118 /* It is possible to have a template that is not a member
1119 template and is not a member of a template class:
1121 template <typename T>
1122 struct S { friend A::f(); };
1124 Here, the friend function is a template, but the context does
1125 not have template information. The optimized lookup relies
1126 on having ARGS be the template arguments for both the class
1127 and the function template. */
1128 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1131 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1132 gone through coerce_template_parms by now. */
1135 verify_unstripped_args (tree args
)
1137 ++processing_template_decl
;
1138 if (!any_dependent_template_arguments_p (args
))
1140 tree inner
= INNERMOST_TEMPLATE_ARGS (args
);
1141 for (int i
= 0; i
< TREE_VEC_LENGTH (inner
); ++i
)
1143 tree arg
= TREE_VEC_ELT (inner
, i
);
1144 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1146 else if (TYPE_P (arg
))
1147 gcc_assert (strip_typedefs (arg
, NULL
) == arg
);
1148 else if (strip_typedefs (TREE_TYPE (arg
), NULL
) != TREE_TYPE (arg
))
1149 /* Allow typedefs on the type of a non-type argument, since a
1150 parameter can have them. */;
1152 gcc_assert (strip_typedefs_expr (arg
, NULL
) == arg
);
1155 --processing_template_decl
;
1158 /* Retrieve the specialization (in the sense of [temp.spec] - a
1159 specialization is either an instantiation or an explicit
1160 specialization) of TMPL for the given template ARGS. If there is
1161 no such specialization, return NULL_TREE. The ARGS are a vector of
1162 arguments, or a vector of vectors of arguments, in the case of
1163 templates with more than one level of parameters.
1165 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1166 then we search for a partial specialization matching ARGS. This
1167 parameter is ignored if TMPL is not a class template.
1169 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1170 result is a NONTYPE_ARGUMENT_PACK. */
1173 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1175 if (tmpl
== NULL_TREE
)
1178 if (args
== error_mark_node
)
1181 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1182 || TREE_CODE (tmpl
) == FIELD_DECL
);
1184 /* There should be as many levels of arguments as there are
1185 levels of parameters. */
1186 gcc_assert (TMPL_ARGS_DEPTH (args
)
1187 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1188 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1189 : template_class_depth (DECL_CONTEXT (tmpl
))));
1192 verify_unstripped_args (args
);
1194 /* Lambda functions in templates aren't instantiated normally, but through
1195 tsubst_lambda_expr. */
1196 if (lambda_fn_in_template_p (tmpl
))
1199 if (optimize_specialization_lookup_p (tmpl
))
1201 /* The template arguments actually apply to the containing
1202 class. Find the class specialization with those
1204 tree class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1205 tree class_specialization
1206 = retrieve_specialization (class_template
, args
, 0);
1207 if (!class_specialization
)
1210 /* Find the instance of TMPL. */
1211 tree fns
= get_class_binding (class_specialization
, DECL_NAME (tmpl
));
1212 for (ovl_iterator
iter (fns
); iter
; ++iter
)
1215 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1216 /* using-declarations can add base methods to the method vec,
1217 and we don't want those here. */
1218 && DECL_CONTEXT (fn
) == class_specialization
)
1227 hash_table
<spec_hasher
> *specializations
;
1231 elt
.spec
= NULL_TREE
;
1233 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1234 specializations
= type_specializations
;
1236 specializations
= decl_specializations
;
1239 hash
= spec_hasher::hash (&elt
);
1240 found
= specializations
->find_with_hash (&elt
, hash
);
1248 /* Like retrieve_specialization, but for local declarations. */
1251 retrieve_local_specialization (tree tmpl
)
1253 if (local_specializations
== NULL
)
1256 tree
*slot
= local_specializations
->get (tmpl
);
1257 return slot
? *slot
: NULL_TREE
;
1260 /* Returns nonzero iff DECL is a specialization of TMPL. */
1263 is_specialization_of (tree decl
, tree tmpl
)
1267 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1271 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1277 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1279 for (t
= TREE_TYPE (decl
);
1281 t
= CLASSTYPE_USE_TEMPLATE (t
)
1282 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1283 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1290 /* Returns nonzero iff DECL is a specialization of friend declaration
1291 FRIEND_DECL according to [temp.friend]. */
1294 is_specialization_of_friend (tree decl
, tree friend_decl
)
1296 bool need_template
= true;
1299 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1300 || TREE_CODE (decl
) == TYPE_DECL
);
1302 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1303 of a template class, we want to check if DECL is a specialization
1305 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1306 && DECL_TEMPLATE_INFO (friend_decl
)
1307 && !DECL_USE_TEMPLATE (friend_decl
))
1309 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1310 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1311 need_template
= false;
1313 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1314 && !PRIMARY_TEMPLATE_P (friend_decl
))
1315 need_template
= false;
1317 /* There is nothing to do if this is not a template friend. */
1318 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1321 if (is_specialization_of (decl
, friend_decl
))
1325 A member of a class template may be declared to be a friend of a
1326 non-template class. In this case, the corresponding member of
1327 every specialization of the class template is a friend of the
1328 class granting friendship.
1330 For example, given a template friend declaration
1332 template <class T> friend void A<T>::f();
1334 the member function below is considered a friend
1336 template <> struct A<int> {
1340 For this type of template friend, TEMPLATE_DEPTH below will be
1341 nonzero. To determine if DECL is a friend of FRIEND, we first
1342 check if the enclosing class is a specialization of another. */
1344 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1346 && DECL_CLASS_SCOPE_P (decl
)
1347 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1348 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1350 /* Next, we check the members themselves. In order to handle
1351 a few tricky cases, such as when FRIEND_DECL's are
1353 template <class T> friend void A<T>::g(T t);
1354 template <class T> template <T t> friend void A<T>::h();
1358 void A<int>::g(int);
1359 template <int> void A<int>::h();
1361 we need to figure out ARGS, the template arguments from
1362 the context of DECL. This is required for template substitution
1363 of `T' in the function parameter of `g' and template parameter
1364 of `h' in the above examples. Here ARGS corresponds to `int'. */
1366 tree context
= DECL_CONTEXT (decl
);
1367 tree args
= NULL_TREE
;
1368 int current_depth
= 0;
1370 while (current_depth
< template_depth
)
1372 if (CLASSTYPE_TEMPLATE_INFO (context
))
1374 if (current_depth
== 0)
1375 args
= TYPE_TI_ARGS (context
);
1377 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1380 context
= TYPE_CONTEXT (context
);
1383 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1388 tree friend_args_type
;
1389 tree decl_args_type
;
1391 /* Make sure that both DECL and FRIEND_DECL are templates or
1393 is_template
= DECL_TEMPLATE_INFO (decl
)
1394 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1395 if (need_template
^ is_template
)
1397 else if (is_template
)
1399 /* If both are templates, check template parameter list. */
1401 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1403 if (!comp_template_parms
1404 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1408 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1411 decl_type
= TREE_TYPE (decl
);
1413 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1414 tf_none
, NULL_TREE
);
1415 if (friend_type
== error_mark_node
)
1418 /* Check if return types match. */
1419 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1422 /* Check if function parameter types match, ignoring the
1423 `this' parameter. */
1424 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1425 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1426 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1427 friend_args_type
= TREE_CHAIN (friend_args_type
);
1428 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1429 decl_args_type
= TREE_CHAIN (decl_args_type
);
1431 return compparms (decl_args_type
, friend_args_type
);
1435 /* DECL is a TYPE_DECL */
1437 tree decl_type
= TREE_TYPE (decl
);
1439 /* Make sure that both DECL and FRIEND_DECL are templates or
1442 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1443 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1445 if (need_template
^ is_template
)
1447 else if (is_template
)
1450 /* If both are templates, check the name of the two
1451 TEMPLATE_DECL's first because is_friend didn't. */
1452 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1453 != DECL_NAME (friend_decl
))
1456 /* Now check template parameter list. */
1458 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1460 return comp_template_parms
1461 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1465 return (DECL_NAME (decl
)
1466 == DECL_NAME (friend_decl
));
1472 /* Register the specialization SPEC as a specialization of TMPL with
1473 the indicated ARGS. IS_FRIEND indicates whether the specialization
1474 is actually just a friend declaration. Returns SPEC, or an
1475 equivalent prior declaration, if available.
1477 We also store instantiations of field packs in the hash table, even
1478 though they are not themselves templates, to make lookup easier. */
1481 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1485 spec_entry
**slot
= NULL
;
1488 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1489 || (TREE_CODE (tmpl
) == FIELD_DECL
1490 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1492 if (TREE_CODE (spec
) == FUNCTION_DECL
1493 && uses_template_parms (DECL_TI_ARGS (spec
)))
1494 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1495 register it; we want the corresponding TEMPLATE_DECL instead.
1496 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1497 the more obvious `uses_template_parms (spec)' to avoid problems
1498 with default function arguments. In particular, given
1499 something like this:
1501 template <class T> void f(T t1, T t = T())
1503 the default argument expression is not substituted for in an
1504 instantiation unless and until it is actually needed. */
1507 if (optimize_specialization_lookup_p (tmpl
))
1508 /* We don't put these specializations in the hash table, but we might
1509 want to give an error about a mismatch. */
1510 fn
= retrieve_specialization (tmpl
, args
, 0);
1518 hash
= spec_hasher::hash (&elt
);
1521 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1523 fn
= ((spec_entry
*) *slot
)->spec
;
1528 /* We can sometimes try to re-register a specialization that we've
1529 already got. In particular, regenerate_decl_from_template calls
1530 duplicate_decls which will update the specialization list. But,
1531 we'll still get called again here anyhow. It's more convenient
1532 to simply allow this than to try to prevent it. */
1535 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1537 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1539 if (DECL_ODR_USED (fn
)
1540 || DECL_EXPLICIT_INSTANTIATION (fn
))
1542 error ("specialization of %qD after instantiation",
1544 return error_mark_node
;
1549 /* This situation should occur only if the first
1550 specialization is an implicit instantiation, the
1551 second is an explicit specialization, and the
1552 implicit instantiation has not yet been used. That
1553 situation can occur if we have implicitly
1554 instantiated a member function and then specialized
1557 We can also wind up here if a friend declaration that
1558 looked like an instantiation turns out to be a
1561 template <class T> void foo(T);
1562 class S { friend void foo<>(int) };
1563 template <> void foo(int);
1565 We transform the existing DECL in place so that any
1566 pointers to it become pointers to the updated
1569 If there was a definition for the template, but not
1570 for the specialization, we want this to look as if
1571 there were no definition, and vice versa. */
1572 DECL_INITIAL (fn
) = NULL_TREE
;
1573 duplicate_decls (spec
, fn
, is_friend
);
1574 /* The call to duplicate_decls will have applied
1577 An explicit specialization of a function template
1578 is inline only if it is explicitly declared to be,
1579 and independently of whether its function template
1582 to the primary function; now copy the inline bits to
1583 the various clones. */
1584 FOR_EACH_CLONE (clone
, fn
)
1586 DECL_DECLARED_INLINE_P (clone
)
1587 = DECL_DECLARED_INLINE_P (fn
);
1588 DECL_SOURCE_LOCATION (clone
)
1589 = DECL_SOURCE_LOCATION (fn
);
1590 DECL_DELETED_FN (clone
)
1591 = DECL_DELETED_FN (fn
);
1593 check_specialization_namespace (tmpl
);
1598 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1600 tree dd
= duplicate_decls (spec
, fn
, is_friend
);
1601 if (dd
== error_mark_node
)
1602 /* We've already complained in duplicate_decls. */
1603 return error_mark_node
;
1605 if (dd
== NULL_TREE
&& DECL_INITIAL (spec
))
1606 /* Dup decl failed, but this is a new definition. Set the
1607 line number so any errors match this new
1609 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1615 return duplicate_decls (spec
, fn
, is_friend
);
1617 /* A specialization must be declared in the same namespace as the
1618 template it is specializing. */
1619 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1620 && !check_specialization_namespace (tmpl
))
1621 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1623 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1625 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1626 gcc_assert (tmpl
&& args
&& spec
);
1629 if ((TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1630 && PRIMARY_TEMPLATE_P (tmpl
)
1631 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1632 || variable_template_p (tmpl
))
1633 /* If TMPL is a forward declaration of a template function, keep a list
1634 of all specializations in case we need to reassign them to a friend
1635 template later in tsubst_friend_function.
1637 Also keep a list of all variable template instantiations so that
1638 process_partial_specialization can check whether a later partial
1639 specialization would have used it. */
1640 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1641 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1647 /* Returns true iff two spec_entry nodes are equivalent. */
1649 int comparing_specializations
;
1652 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1656 ++comparing_specializations
;
1657 equal
= (e1
->tmpl
== e2
->tmpl
1658 && comp_template_args (e1
->args
, e2
->args
));
1659 if (equal
&& flag_concepts
1660 /* tmpl could be a FIELD_DECL for a capture pack. */
1661 && TREE_CODE (e1
->tmpl
) == TEMPLATE_DECL
1662 && VAR_P (DECL_TEMPLATE_RESULT (e1
->tmpl
))
1663 && uses_template_parms (e1
->args
))
1665 /* Partial specializations of a variable template can be distinguished by
1667 tree c1
= e1
->spec
? get_constraints (e1
->spec
) : NULL_TREE
;
1668 tree c2
= e2
->spec
? get_constraints (e2
->spec
) : NULL_TREE
;
1669 equal
= equivalent_constraints (c1
, c2
);
1671 --comparing_specializations
;
1676 /* Returns a hash for a template TMPL and template arguments ARGS. */
1679 hash_tmpl_and_args (tree tmpl
, tree args
)
1681 hashval_t val
= iterative_hash_object (DECL_UID (tmpl
), 0);
1682 return iterative_hash_template_arg (args
, val
);
1685 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1689 spec_hasher::hash (spec_entry
*e
)
1691 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1694 /* Recursively calculate a hash value for a template argument ARG, for use
1695 in the hash tables of template specializations. */
1698 iterative_hash_template_arg (tree arg
, hashval_t val
)
1700 unsigned HOST_WIDE_INT i
;
1701 enum tree_code code
;
1704 if (arg
== NULL_TREE
)
1705 return iterative_hash_object (arg
, val
);
1710 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1713 code
= TREE_CODE (arg
);
1714 tclass
= TREE_CODE_CLASS (code
);
1716 val
= iterative_hash_object (code
, val
);
1723 case IDENTIFIER_NODE
:
1724 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1728 int i
, len
= TREE_VEC_LENGTH (arg
);
1729 for (i
= 0; i
< len
; ++i
)
1730 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1734 case TYPE_PACK_EXPANSION
:
1735 case EXPR_PACK_EXPANSION
:
1736 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1737 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1739 case TYPE_ARGUMENT_PACK
:
1740 case NONTYPE_ARGUMENT_PACK
:
1741 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1744 for (; arg
; arg
= TREE_CHAIN (arg
))
1745 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1749 for (lkp_iterator
iter (arg
); iter
; ++iter
)
1750 val
= iterative_hash_template_arg (*iter
, val
);
1756 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1757 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1759 val
= iterative_hash_template_arg (field
, val
);
1760 val
= iterative_hash_template_arg (value
, val
);
1766 if (!DECL_ARTIFICIAL (arg
))
1768 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1769 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1771 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1774 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1777 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1778 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1780 case TEMPLATE_PARM_INDEX
:
1781 val
= iterative_hash_template_arg
1782 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1783 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1784 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1787 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1788 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1789 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1792 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1794 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1798 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1799 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1800 val
= iterative_hash_object (code
, val
);
1801 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1804 /* A lambda can't appear in a template arg, but don't crash on
1806 gcc_assert (seen_error ());
1810 case IMPLICIT_CONV_EXPR
:
1811 case STATIC_CAST_EXPR
:
1812 case REINTERPRET_CAST_EXPR
:
1813 case CONST_CAST_EXPR
:
1814 case DYNAMIC_CAST_EXPR
:
1816 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1817 /* Now hash operands as usual. */
1827 if (alias_template_specialization_p (arg
))
1829 // We want an alias specialization that survived strip_typedefs
1830 // to hash differently from its TYPE_CANONICAL, to avoid hash
1831 // collisions that compare as different in template_args_equal.
1832 // These could be dependent specializations that strip_typedefs
1833 // left alone, or untouched specializations because
1834 // coerce_template_parms returns the unconverted template
1835 // arguments if it sees incomplete argument packs.
1836 tree ti
= TYPE_ALIAS_TEMPLATE_INFO (arg
);
1837 return hash_tmpl_and_args (TI_TEMPLATE (ti
), TI_ARGS (ti
));
1839 if (TYPE_CANONICAL (arg
))
1840 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1842 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1843 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1844 /* Otherwise just compare the types during lookup. */
1847 case tcc_declaration
:
1849 return iterative_hash_expr (arg
, val
);
1852 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1854 unsigned n
= cp_tree_operand_length (arg
);
1855 for (i
= 0; i
< n
; ++i
)
1856 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1864 /* Unregister the specialization SPEC as a specialization of TMPL.
1865 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1866 if the SPEC was listed as a specialization of TMPL.
1868 Note that SPEC has been ggc_freed, so we can't look inside it. */
1871 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1876 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1877 elt
.args
= TI_ARGS (tinfo
);
1878 elt
.spec
= NULL_TREE
;
1880 entry
= decl_specializations
->find (&elt
);
1883 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1884 gcc_assert (new_spec
!= NULL_TREE
);
1885 entry
->spec
= new_spec
;
1892 /* Like register_specialization, but for local declarations. We are
1893 registering SPEC, an instantiation of TMPL. */
1896 register_local_specialization (tree spec
, tree tmpl
)
1898 gcc_assert (tmpl
!= spec
);
1899 local_specializations
->put (tmpl
, spec
);
1902 /* TYPE is a class type. Returns true if TYPE is an explicitly
1903 specialized class. */
1906 explicit_class_specialization_p (tree type
)
1908 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1910 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1913 /* Print the list of functions at FNS, going through all the overloads
1914 for each element of the list. Alternatively, FNS can not be a
1915 TREE_LIST, in which case it will be printed together with all the
1918 MORE and *STR should respectively be FALSE and NULL when the function
1919 is called from the outside. They are used internally on recursive
1920 calls. print_candidates manages the two parameters and leaves NULL
1921 in *STR when it ends. */
1924 print_candidates_1 (tree fns
, char **str
, bool more
= false)
1926 if (TREE_CODE (fns
) == TREE_LIST
)
1927 for (; fns
; fns
= TREE_CHAIN (fns
))
1928 print_candidates_1 (TREE_VALUE (fns
), str
, more
|| TREE_CHAIN (fns
));
1930 for (lkp_iterator
iter (fns
); iter
;)
1935 const char *pfx
= *str
;
1939 pfx
= _("candidates are:");
1941 pfx
= _("candidate is:");
1942 *str
= get_spaces (pfx
);
1944 inform (DECL_SOURCE_LOCATION (cand
), "%s %#qD", pfx
, cand
);
1948 /* Print the list of candidate FNS in an error message. FNS can also
1949 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1952 print_candidates (tree fns
)
1955 print_candidates_1 (fns
, &str
);
1959 /* Get a (possibly) constrained template declaration for the
1960 purpose of ordering candidates. */
1962 get_template_for_ordering (tree list
)
1964 gcc_assert (TREE_CODE (list
) == TREE_LIST
);
1965 tree f
= TREE_VALUE (list
);
1966 if (tree ti
= DECL_TEMPLATE_INFO (f
))
1967 return TI_TEMPLATE (ti
);
1971 /* Among candidates having the same signature, return the
1972 most constrained or NULL_TREE if there is no best candidate.
1973 If the signatures of candidates vary (e.g., template
1974 specialization vs. member function), then there can be no
1977 Note that we don't compare constraints on the functions
1978 themselves, but rather those of their templates. */
1980 most_constrained_function (tree candidates
)
1982 // Try to find the best candidate in a first pass.
1983 tree champ
= candidates
;
1984 for (tree c
= TREE_CHAIN (champ
); c
; c
= TREE_CHAIN (c
))
1986 int winner
= more_constrained (get_template_for_ordering (champ
),
1987 get_template_for_ordering (c
));
1989 champ
= c
; // The candidate is more constrained
1990 else if (winner
== 0)
1991 return NULL_TREE
; // Neither is more constrained
1994 // Verify that the champ is better than previous candidates.
1995 for (tree c
= candidates
; c
!= champ
; c
= TREE_CHAIN (c
)) {
1996 if (!more_constrained (get_template_for_ordering (champ
),
1997 get_template_for_ordering (c
)))
2005 /* Returns the template (one of the functions given by TEMPLATE_ID)
2006 which can be specialized to match the indicated DECL with the
2007 explicit template args given in TEMPLATE_ID. The DECL may be
2008 NULL_TREE if none is available. In that case, the functions in
2009 TEMPLATE_ID are non-members.
2011 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2012 specialization of a member template.
2014 The TEMPLATE_COUNT is the number of references to qualifying
2015 template classes that appeared in the name of the function. See
2016 check_explicit_specialization for a more accurate description.
2018 TSK indicates what kind of template declaration (if any) is being
2019 declared. TSK_TEMPLATE indicates that the declaration given by
2020 DECL, though a FUNCTION_DECL, has template parameters, and is
2021 therefore a template function.
2023 The template args (those explicitly specified and those deduced)
2024 are output in a newly created vector *TARGS_OUT.
2026 If it is impossible to determine the result, an error message is
2027 issued. The error_mark_node is returned to indicate failure. */
2030 determine_specialization (tree template_id
,
2033 int need_member_template
,
2039 tree explicit_targs
;
2040 tree candidates
= NULL_TREE
;
2042 /* A TREE_LIST of templates of which DECL may be a specialization.
2043 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2044 corresponding TREE_PURPOSE is the set of template arguments that,
2045 when used to instantiate the template, would produce a function
2046 with the signature of DECL. */
2047 tree templates
= NULL_TREE
;
2049 cp_binding_level
*b
;
2051 *targs_out
= NULL_TREE
;
2053 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
2054 return error_mark_node
;
2056 /* We shouldn't be specializing a member template of an
2057 unspecialized class template; we already gave an error in
2058 check_specialization_scope, now avoid crashing. */
2059 if (template_count
&& DECL_CLASS_SCOPE_P (decl
)
2060 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
2062 gcc_assert (errorcount
);
2063 return error_mark_node
;
2066 fns
= TREE_OPERAND (template_id
, 0);
2067 explicit_targs
= TREE_OPERAND (template_id
, 1);
2069 if (fns
== error_mark_node
)
2070 return error_mark_node
;
2072 /* Check for baselinks. */
2073 if (BASELINK_P (fns
))
2074 fns
= BASELINK_FUNCTIONS (fns
);
2076 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
2078 error ("%qD is not a function template", fns
);
2079 return error_mark_node
;
2081 else if (VAR_P (decl
) && !variable_template_p (fns
))
2083 error ("%qD is not a variable template", fns
);
2084 return error_mark_node
;
2087 /* Count the number of template headers specified for this
2090 for (b
= current_binding_level
;
2091 b
->kind
== sk_template_parms
;
2095 tree orig_fns
= fns
;
2097 if (variable_template_p (fns
))
2099 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns
));
2100 targs
= coerce_template_parms (parms
, explicit_targs
, fns
,
2101 tf_warning_or_error
,
2102 /*req_all*/true, /*use_defarg*/true);
2103 if (targs
!= error_mark_node
)
2104 templates
= tree_cons (targs
, fns
, templates
);
2106 else for (lkp_iterator
iter (fns
); iter
; ++iter
)
2110 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2112 tree decl_arg_types
;
2116 /* In case of explicit specialization, we need to check if
2117 the number of template headers appearing in the specialization
2118 is correct. This is usually done in check_explicit_specialization,
2119 but the check done there cannot be exhaustive when specializing
2120 member functions. Consider the following code:
2122 template <> void A<int>::f(int);
2123 template <> template <> void A<int>::f(int);
2125 Assuming that A<int> is not itself an explicit specialization
2126 already, the first line specializes "f" which is a non-template
2127 member function, whilst the second line specializes "f" which
2128 is a template member function. So both lines are syntactically
2129 correct, and check_explicit_specialization does not reject
2132 Here, we can do better, as we are matching the specialization
2133 against the declarations. We count the number of template
2134 headers, and we check if they match TEMPLATE_COUNT + 1
2135 (TEMPLATE_COUNT is the number of qualifying template classes,
2136 plus there must be another header for the member template
2139 Notice that if header_count is zero, this is not a
2140 specialization but rather a template instantiation, so there
2141 is no check we can perform here. */
2142 if (header_count
&& header_count
!= template_count
+ 1)
2145 /* Check that the number of template arguments at the
2146 innermost level for DECL is the same as for FN. */
2147 if (current_binding_level
->kind
== sk_template_parms
2148 && !current_binding_level
->explicit_spec_p
2149 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
2150 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
2151 (current_template_parms
))))
2154 /* DECL might be a specialization of FN. */
2155 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2156 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2158 /* For a non-static member function, we need to make sure
2159 that the const qualification is the same. Since
2160 get_bindings does not try to merge the "this" parameter,
2161 we must do the comparison explicitly. */
2162 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2163 && !same_type_p (TREE_VALUE (fn_arg_types
),
2164 TREE_VALUE (decl_arg_types
)))
2167 /* Skip the "this" parameter and, for constructors of
2168 classes with virtual bases, the VTT parameter. A
2169 full specialization of a constructor will have a VTT
2170 parameter, but a template never will. */
2172 = skip_artificial_parms_for (decl
, decl_arg_types
);
2174 = skip_artificial_parms_for (fn
, fn_arg_types
);
2176 /* Function templates cannot be specializations; there are
2177 no partial specializations of functions. Therefore, if
2178 the type of DECL does not match FN, there is no
2181 Note that it should never be the case that we have both
2182 candidates added here, and for regular member functions
2184 if (tsk
== tsk_template
)
2186 if (compparms (fn_arg_types
, decl_arg_types
))
2187 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2191 /* See whether this function might be a specialization of this
2192 template. Suppress access control because we might be trying
2193 to make this specialization a friend, and we have already done
2194 access control for the declaration of the specialization. */
2195 push_deferring_access_checks (dk_no_check
);
2196 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
2197 pop_deferring_access_checks ();
2200 /* We cannot deduce template arguments that when used to
2201 specialize TMPL will produce DECL. */
2204 /* Remove, from the set of candidates, all those functions
2205 whose constraints are not satisfied. */
2206 if (flag_concepts
&& !constraints_satisfied_p (fn
, targs
))
2209 // Then, try to form the new function type.
2210 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_fndecl_type
, NULL_TREE
);
2211 if (insttype
== error_mark_node
)
2214 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
2215 if (!compparms (fn_arg_types
, decl_arg_types
))
2218 /* Save this template, and the arguments deduced. */
2219 templates
= tree_cons (targs
, fn
, templates
);
2221 else if (need_member_template
)
2222 /* FN is an ordinary member function, and we need a
2223 specialization of a member template. */
2225 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2226 /* We can get IDENTIFIER_NODEs here in certain erroneous
2229 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2230 /* This is just an ordinary non-member function. Nothing can
2231 be a specialization of that. */
2233 else if (DECL_ARTIFICIAL (fn
))
2234 /* Cannot specialize functions that are created implicitly. */
2238 tree decl_arg_types
;
2240 /* This is an ordinary member function. However, since
2241 we're here, we can assume its enclosing class is a
2242 template class. For example,
2244 template <typename T> struct S { void f(); };
2245 template <> void S<int>::f() {}
2247 Here, S<int>::f is a non-template, but S<int> is a
2248 template class. If FN has the same type as DECL, we
2249 might be in business. */
2251 if (!DECL_TEMPLATE_INFO (fn
))
2252 /* Its enclosing class is an explicit specialization
2253 of a template class. This is not a candidate. */
2256 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2257 TREE_TYPE (TREE_TYPE (fn
))))
2258 /* The return types differ. */
2261 /* Adjust the type of DECL in case FN is a static member. */
2262 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2263 if (DECL_STATIC_FUNCTION_P (fn
)
2264 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2265 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2267 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2271 // If the deduced arguments do not satisfy the constraints,
2272 // this is not a candidate.
2273 if (flag_concepts
&& !constraints_satisfied_p (fn
))
2276 // Add the candidate.
2277 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2281 if (templates
&& TREE_CHAIN (templates
))
2287 It is possible for a specialization with a given function
2288 signature to be instantiated from more than one function
2289 template. In such cases, explicit specification of the
2290 template arguments must be used to uniquely identify the
2291 function template specialization being specialized.
2293 Note that here, there's no suggestion that we're supposed to
2294 determine which of the candidate templates is most
2295 specialized. However, we, also have:
2299 Partial ordering of overloaded function template
2300 declarations is used in the following contexts to select
2301 the function template to which a function template
2302 specialization refers:
2304 -- when an explicit specialization refers to a function
2307 So, we do use the partial ordering rules, at least for now.
2308 This extension can only serve to make invalid programs valid,
2309 so it's safe. And, there is strong anecdotal evidence that
2310 the committee intended the partial ordering rules to apply;
2311 the EDG front end has that behavior, and John Spicer claims
2312 that the committee simply forgot to delete the wording in
2313 [temp.expl.spec]. */
2314 tree tmpl
= most_specialized_instantiation (templates
);
2315 if (tmpl
!= error_mark_node
)
2318 TREE_CHAIN (templates
) = NULL_TREE
;
2322 // Concepts allows multiple declarations of member functions
2323 // with the same signature. Like above, we need to rely on
2324 // on the partial ordering of those candidates to determine which
2326 if (flag_concepts
&& candidates
&& TREE_CHAIN (candidates
))
2328 if (tree cand
= most_constrained_function (candidates
))
2331 TREE_CHAIN (cand
) = NULL_TREE
;
2335 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2337 error ("template-id %qD for %q+D does not match any template "
2338 "declaration", template_id
, decl
);
2339 if (header_count
&& header_count
!= template_count
+ 1)
2340 inform (input_location
, "saw %d %<template<>%>, need %d for "
2341 "specializing a member function template",
2342 header_count
, template_count
+ 1);
2344 print_candidates (orig_fns
);
2345 return error_mark_node
;
2347 else if ((templates
&& TREE_CHAIN (templates
))
2348 || (candidates
&& TREE_CHAIN (candidates
))
2349 || (templates
&& candidates
))
2351 error ("ambiguous template specialization %qD for %q+D",
2353 candidates
= chainon (candidates
, templates
);
2354 print_candidates (candidates
);
2355 return error_mark_node
;
2358 /* We have one, and exactly one, match. */
2361 tree fn
= TREE_VALUE (candidates
);
2362 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2364 // Propagate the candidate's constraints to the declaration.
2365 set_constraints (decl
, get_constraints (fn
));
2367 /* DECL is a re-declaration or partial instantiation of a template
2369 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2371 /* It was a specialization of an ordinary member function in a
2373 return DECL_TI_TEMPLATE (fn
);
2376 /* It was a specialization of a template. */
2377 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2378 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2380 *targs_out
= copy_node (targs
);
2381 SET_TMPL_ARGS_LEVEL (*targs_out
,
2382 TMPL_ARGS_DEPTH (*targs_out
),
2383 TREE_PURPOSE (templates
));
2386 *targs_out
= TREE_PURPOSE (templates
);
2387 return TREE_VALUE (templates
);
2390 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2391 but with the default argument values filled in from those in the
2395 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2398 tree new_spec_types
;
2403 if (spec_types
== void_list_node
)
2404 return void_list_node
;
2406 /* Substitute into the rest of the list. */
2408 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2409 TREE_CHAIN (tmpl_types
));
2411 /* Add the default argument for this parameter. */
2412 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2413 TREE_VALUE (spec_types
),
2417 /* DECL is an explicit specialization. Replicate default arguments
2418 from the template it specializes. (That way, code like:
2420 template <class T> void f(T = 3);
2421 template <> void f(double);
2424 works, as required.) An alternative approach would be to look up
2425 the correct default arguments at the call-site, but this approach
2426 is consistent with how implicit instantiations are handled. */
2429 copy_default_args_to_explicit_spec (tree decl
)
2434 tree new_spec_types
;
2438 tree object_type
= NULL_TREE
;
2439 tree in_charge
= NULL_TREE
;
2440 tree vtt
= NULL_TREE
;
2442 /* See if there's anything we need to do. */
2443 tmpl
= DECL_TI_TEMPLATE (decl
);
2444 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2445 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2446 if (TREE_PURPOSE (t
))
2451 old_type
= TREE_TYPE (decl
);
2452 spec_types
= TYPE_ARG_TYPES (old_type
);
2454 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2456 /* Remove the this pointer, but remember the object's type for
2458 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2459 spec_types
= TREE_CHAIN (spec_types
);
2460 tmpl_types
= TREE_CHAIN (tmpl_types
);
2462 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2464 /* DECL may contain more parameters than TMPL due to the extra
2465 in-charge parameter in constructors and destructors. */
2466 in_charge
= spec_types
;
2467 spec_types
= TREE_CHAIN (spec_types
);
2469 if (DECL_HAS_VTT_PARM_P (decl
))
2472 spec_types
= TREE_CHAIN (spec_types
);
2476 /* Compute the merged default arguments. */
2478 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2480 /* Compute the new FUNCTION_TYPE. */
2484 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2489 /* Put the in-charge parameter back. */
2490 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2491 TREE_VALUE (in_charge
),
2494 new_type
= build_method_type_directly (object_type
,
2495 TREE_TYPE (old_type
),
2499 new_type
= build_function_type (TREE_TYPE (old_type
),
2501 new_type
= cp_build_type_attribute_variant (new_type
,
2502 TYPE_ATTRIBUTES (old_type
));
2503 new_type
= build_exception_variant (new_type
,
2504 TYPE_RAISES_EXCEPTIONS (old_type
));
2506 if (TYPE_HAS_LATE_RETURN_TYPE (old_type
))
2507 TYPE_HAS_LATE_RETURN_TYPE (new_type
) = 1;
2509 TREE_TYPE (decl
) = new_type
;
2512 /* Return the number of template headers we expect to see for a definition
2513 or specialization of CTYPE or one of its non-template members. */
2516 num_template_headers_for_class (tree ctype
)
2518 int num_templates
= 0;
2520 while (ctype
&& CLASS_TYPE_P (ctype
))
2522 /* You're supposed to have one `template <...>' for every
2523 template class, but you don't need one for a full
2524 specialization. For example:
2526 template <class T> struct S{};
2527 template <> struct S<int> { void f(); };
2528 void S<int>::f () {}
2530 is correct; there shouldn't be a `template <>' for the
2531 definition of `S<int>::f'. */
2532 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2533 /* If CTYPE does not have template information of any
2534 kind, then it is not a template, nor is it nested
2535 within a template. */
2537 if (explicit_class_specialization_p (ctype
))
2539 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2542 ctype
= TYPE_CONTEXT (ctype
);
2545 return num_templates
;
2548 /* Do a simple sanity check on the template headers that precede the
2549 variable declaration DECL. */
2552 check_template_variable (tree decl
)
2554 tree ctx
= CP_DECL_CONTEXT (decl
);
2555 int wanted
= num_template_headers_for_class (ctx
);
2556 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2557 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2559 if (cxx_dialect
< cxx14
)
2560 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2561 "variable templates only available with "
2562 "-std=c++14 or -std=gnu++14");
2564 // Namespace-scope variable templates should have a template header.
2567 if (template_header_count
> wanted
)
2569 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2570 "too many template headers for %qD "
2573 if (warned
&& CLASS_TYPE_P (ctx
)
2574 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2575 inform (DECL_SOURCE_LOCATION (decl
),
2576 "members of an explicitly specialized class are defined "
2577 "without a template header");
2581 /* An explicit specialization whose declarator-id or class-head-name is not
2582 qualified shall be declared in the nearest enclosing namespace of the
2583 template, or, if the namespace is inline (7.3.1), any namespace from its
2584 enclosing namespace set.
2586 If the name declared in the explicit instantiation is an unqualified name,
2587 the explicit instantiation shall appear in the namespace where its template
2588 is declared or, if that namespace is inline (7.3.1), any namespace from its
2589 enclosing namespace set. */
2592 check_unqualified_spec_or_inst (tree t
, location_t loc
)
2594 tree tmpl
= most_general_template (t
);
2595 if (DECL_NAMESPACE_SCOPE_P (tmpl
)
2596 && !is_nested_namespace (current_namespace
,
2597 CP_DECL_CONTEXT (tmpl
), true))
2599 if (processing_specialization
)
2600 permerror (loc
, "explicit specialization of %qD outside its "
2601 "namespace must use a nested-name-specifier", tmpl
);
2602 else if (processing_explicit_instantiation
2603 && cxx_dialect
>= cxx11
)
2604 /* This was allowed in C++98, so only pedwarn. */
2605 pedwarn (loc
, OPT_Wpedantic
, "explicit instantiation of %qD "
2606 "outside its namespace must use a nested-name-"
2611 /* Check to see if the function just declared, as indicated in
2612 DECLARATOR, and in DECL, is a specialization of a function
2613 template. We may also discover that the declaration is an explicit
2614 instantiation at this point.
2616 Returns DECL, or an equivalent declaration that should be used
2617 instead if all goes well. Issues an error message if something is
2618 amiss. Returns error_mark_node if the error is not easily
2621 FLAGS is a bitmask consisting of the following flags:
2623 2: The function has a definition.
2624 4: The function is a friend.
2626 The TEMPLATE_COUNT is the number of references to qualifying
2627 template classes that appeared in the name of the function. For
2630 template <class T> struct S { void f(); };
2633 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2634 classes are not counted in the TEMPLATE_COUNT, so that in
2636 template <class T> struct S {};
2637 template <> struct S<int> { void f(); }
2638 template <> void S<int>::f();
2640 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2641 invalid; there should be no template <>.)
2643 If the function is a specialization, it is marked as such via
2644 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2645 is set up correctly, and it is added to the list of specializations
2646 for that template. */
2649 check_explicit_specialization (tree declarator
,
2654 int have_def
= flags
& 2;
2655 int is_friend
= flags
& 4;
2656 bool is_concept
= flags
& 8;
2657 int specialization
= 0;
2658 int explicit_instantiation
= 0;
2659 int member_specialization
= 0;
2660 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2661 tree dname
= DECL_NAME (decl
);
2666 if (!processing_specialization
)
2669 tsk
= tsk_excessive_parms
;
2672 tsk
= current_tmpl_spec_kind (template_count
);
2677 if (processing_specialization
&& !VAR_P (decl
))
2680 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2682 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2685 /* This could be something like:
2687 template <class T> void f(T);
2688 class S { friend void f<>(int); } */
2692 /* This case handles bogus declarations like template <>
2693 template <class T> void f<int>(); */
2695 error ("template-id %qD in declaration of primary template",
2702 case tsk_invalid_member_spec
:
2703 /* The error has already been reported in
2704 check_specialization_scope. */
2705 return error_mark_node
;
2707 case tsk_invalid_expl_inst
:
2708 error ("template parameter list used in explicit instantiation");
2714 error ("definition provided for explicit instantiation");
2716 explicit_instantiation
= 1;
2719 case tsk_excessive_parms
:
2720 case tsk_insufficient_parms
:
2721 if (tsk
== tsk_excessive_parms
)
2722 error ("too many template parameter lists in declaration of %qD",
2724 else if (template_header_count
)
2725 error("too few template parameter lists in declaration of %qD", decl
);
2727 error("explicit specialization of %qD must be introduced by "
2728 "%<template <>%>", decl
);
2733 error ("explicit specialization declared %<concept%>");
2735 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2736 /* In cases like template<> constexpr bool v = true;
2737 We'll give an error in check_template_variable. */
2740 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2742 member_specialization
= 1;
2748 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2750 /* This case handles bogus declarations like template <>
2751 template <class T> void f<int>(); */
2753 if (!uses_template_parms (declarator
))
2754 error ("template-id %qD in declaration of primary template",
2756 else if (variable_template_p (TREE_OPERAND (declarator
, 0)))
2758 /* Partial specialization of variable template. */
2759 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2763 else if (cxx_dialect
< cxx14
)
2764 error ("non-type partial specialization %qD "
2765 "is not allowed", declarator
);
2767 error ("non-class, non-variable partial specialization %qD "
2768 "is not allowed", declarator
);
2773 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2774 /* This is a specialization of a member template, without
2775 specialization the containing class. Something like:
2777 template <class T> struct S {
2778 template <class U> void f (U);
2780 template <> template <class U> void S<int>::f(U) {}
2782 That's a specialization -- but of the entire template. */
2790 if ((specialization
|| member_specialization
)
2791 /* This doesn't apply to variable templates. */
2792 && (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
2793 || TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
))
2795 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2796 for (; t
; t
= TREE_CHAIN (t
))
2797 if (TREE_PURPOSE (t
))
2799 permerror (input_location
,
2800 "default argument specified in explicit specialization");
2805 if (specialization
|| member_specialization
|| explicit_instantiation
)
2807 tree tmpl
= NULL_TREE
;
2808 tree targs
= NULL_TREE
;
2809 bool was_template_id
= (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
);
2811 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2812 if (!was_template_id
)
2816 gcc_assert (identifier_p (declarator
));
2821 /* If there is no class context, the explicit instantiation
2822 must be at namespace scope. */
2823 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2825 /* Find the namespace binding, using the declaration
2827 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2829 if (fns
== error_mark_node
)
2830 /* If lookup fails, look for a friend declaration so we can
2831 give a better diagnostic. */
2832 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2833 /*type*/false, /*complain*/true,
2836 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2838 error ("%qD is not a template function", dname
);
2839 fns
= error_mark_node
;
2843 declarator
= lookup_template_function (fns
, NULL_TREE
);
2846 if (declarator
== error_mark_node
)
2847 return error_mark_node
;
2849 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2851 if (!explicit_instantiation
)
2852 /* A specialization in class scope. This is invalid,
2853 but the error will already have been flagged by
2854 check_specialization_scope. */
2855 return error_mark_node
;
2858 /* It's not valid to write an explicit instantiation in
2861 class C { template void f(); }
2863 This case is caught by the parser. However, on
2866 template class C { void f(); };
2868 (which is invalid) we can get here. The error will be
2875 else if (ctype
!= NULL_TREE
2876 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2878 // We'll match variable templates in start_decl.
2882 /* Find the list of functions in ctype that have the same
2883 name as the declared function. */
2884 tree name
= TREE_OPERAND (declarator
, 0);
2886 if (constructor_name_p (name
, ctype
))
2888 if (DECL_CONSTRUCTOR_P (decl
)
2889 ? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2890 : !CLASSTYPE_DESTRUCTOR (ctype
))
2892 /* From [temp.expl.spec]:
2894 If such an explicit specialization for the member
2895 of a class template names an implicitly-declared
2896 special member function (clause _special_), the
2897 program is ill-formed.
2899 Similar language is found in [temp.explicit]. */
2900 error ("specialization of implicitly-declared special member function");
2901 return error_mark_node
;
2904 name
= DECL_NAME (decl
);
2907 /* For a type-conversion operator, We might be looking for
2908 `operator int' which will be a specialization of
2909 `operator T'. Grab all the conversion operators, and
2910 then select from them. */
2911 tree fns
= get_class_binding (ctype
, IDENTIFIER_CONV_OP_P (name
)
2912 ? conv_op_identifier
: name
);
2914 if (fns
== NULL_TREE
)
2916 error ("no member function %qD declared in %qT", name
, ctype
);
2917 return error_mark_node
;
2920 TREE_OPERAND (declarator
, 0) = fns
;
2923 /* Figure out what exactly is being specialized at this point.
2924 Note that for an explicit instantiation, even one for a
2925 member function, we cannot tell a priori whether the
2926 instantiation is for a member template, or just a member
2927 function of a template class. Even if a member template is
2928 being instantiated, the member template arguments may be
2929 elided if they can be deduced from the rest of the
2931 tmpl
= determine_specialization (declarator
, decl
,
2933 member_specialization
,
2937 if (!tmpl
|| tmpl
== error_mark_node
)
2938 /* We couldn't figure out what this declaration was
2940 return error_mark_node
;
2943 if (TREE_CODE (decl
) == FUNCTION_DECL
2944 && DECL_HIDDEN_FRIEND_P (tmpl
))
2946 if (pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2947 "friend declaration %qD is not visible to "
2948 "explicit specialization", tmpl
))
2949 inform (DECL_SOURCE_LOCATION (tmpl
),
2950 "friend declaration here");
2952 else if (!ctype
&& !is_friend
2953 && CP_DECL_CONTEXT (decl
) == current_namespace
)
2954 check_unqualified_spec_or_inst (tmpl
, DECL_SOURCE_LOCATION (decl
));
2956 tree gen_tmpl
= most_general_template (tmpl
);
2958 if (explicit_instantiation
)
2960 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2961 is done by do_decl_instantiation later. */
2963 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2964 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2966 if (arg_depth
> parm_depth
)
2968 /* If TMPL is not the most general template (for
2969 example, if TMPL is a friend template that is
2970 injected into namespace scope), then there will
2971 be too many levels of TARGS. Remove some of them
2976 new_targs
= make_tree_vec (parm_depth
);
2977 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2978 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2979 = TREE_VEC_ELT (targs
, i
);
2983 return instantiate_template (tmpl
, targs
, tf_error
);
2986 /* If we thought that the DECL was a member function, but it
2987 turns out to be specializing a static member function,
2988 make DECL a static member function as well. */
2989 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
2990 && DECL_STATIC_FUNCTION_P (tmpl
)
2991 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2992 revert_static_member_fn (decl
);
2994 /* If this is a specialization of a member template of a
2995 template class, we want to return the TEMPLATE_DECL, not
2996 the specialization of it. */
2997 if (tsk
== tsk_template
&& !was_template_id
)
2999 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
3000 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
3001 DECL_INITIAL (result
) = NULL_TREE
;
3005 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
3006 DECL_SOURCE_LOCATION (result
)
3007 = DECL_SOURCE_LOCATION (decl
);
3008 /* We want to use the argument list specified in the
3009 definition, not in the original declaration. */
3010 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
3011 for (parm
= DECL_ARGUMENTS (result
); parm
;
3012 parm
= DECL_CHAIN (parm
))
3013 DECL_CONTEXT (parm
) = result
;
3015 return register_specialization (tmpl
, gen_tmpl
, targs
,
3019 /* Set up the DECL_TEMPLATE_INFO for DECL. */
3020 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
3022 if (was_template_id
)
3023 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
)) = true;
3025 /* Inherit default function arguments from the template
3026 DECL is specializing. */
3027 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
3028 copy_default_args_to_explicit_spec (decl
);
3030 /* This specialization has the same protection as the
3031 template it specializes. */
3032 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
3033 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
3035 /* 7.1.1-1 [dcl.stc]
3037 A storage-class-specifier shall not be specified in an
3038 explicit specialization...
3040 The parser rejects these, so unless action is taken here,
3041 explicit function specializations will always appear with
3044 The action recommended by the C++ CWG in response to C++
3045 defect report 605 is to make the storage class and linkage
3046 of the explicit specialization match the templated function:
3048 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3050 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
3052 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
3053 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
3055 /* A concept cannot be specialized. */
3056 if (DECL_DECLARED_CONCEPT_P (tmpl_func
))
3058 error ("explicit specialization of function concept %qD",
3060 return error_mark_node
;
3063 /* This specialization has the same linkage and visibility as
3064 the function template it specializes. */
3065 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
3066 if (! TREE_PUBLIC (decl
))
3068 DECL_INTERFACE_KNOWN (decl
) = 1;
3069 DECL_NOT_REALLY_EXTERN (decl
) = 1;
3071 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
3072 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
3074 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3075 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
3079 /* If DECL is a friend declaration, declared using an
3080 unqualified name, the namespace associated with DECL may
3081 have been set incorrectly. For example, in:
3083 template <typename T> void f(T);
3085 struct S { friend void f<int>(int); }
3088 we will have set the DECL_CONTEXT for the friend
3089 declaration to N, rather than to the global namespace. */
3090 if (DECL_NAMESPACE_SCOPE_P (decl
))
3091 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
3093 if (is_friend
&& !have_def
)
3094 /* This is not really a declaration of a specialization.
3095 It's just the name of an instantiation. But, it's not
3096 a request for an instantiation, either. */
3097 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
3098 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3099 /* A specialization is not necessarily COMDAT. */
3100 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
3101 && DECL_DECLARED_INLINE_P (decl
));
3102 else if (VAR_P (decl
))
3103 DECL_COMDAT (decl
) = false;
3105 /* If this is a full specialization, register it so that we can find
3106 it again. Partial specializations will be registered in
3107 process_partial_specialization. */
3108 if (!processing_template_decl
)
3109 decl
= register_specialization (decl
, gen_tmpl
, targs
,
3112 /* A 'structor should already have clones. */
3113 gcc_assert (decl
== error_mark_node
3114 || variable_template_p (tmpl
)
3115 || !(DECL_CONSTRUCTOR_P (decl
)
3116 || DECL_DESTRUCTOR_P (decl
))
3117 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
3124 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3125 parameters. These are represented in the same format used for
3126 DECL_TEMPLATE_PARMS. */
3129 comp_template_parms (const_tree parms1
, const_tree parms2
)
3134 if (parms1
== parms2
)
3137 for (p1
= parms1
, p2
= parms2
;
3138 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
3139 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
3141 tree t1
= TREE_VALUE (p1
);
3142 tree t2
= TREE_VALUE (p2
);
3145 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
3146 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
3148 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3151 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
3153 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
3154 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
3156 /* If either of the template parameters are invalid, assume
3157 they match for the sake of error recovery. */
3158 if (error_operand_p (parm1
) || error_operand_p (parm2
))
3161 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
3164 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
3165 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
3166 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
3168 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
3173 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
3174 /* One set of parameters has more parameters lists than the
3181 /* Determine whether PARM is a parameter pack. */
3184 template_parameter_pack_p (const_tree parm
)
3186 /* Determine if we have a non-type template parameter pack. */
3187 if (TREE_CODE (parm
) == PARM_DECL
)
3188 return (DECL_TEMPLATE_PARM_P (parm
)
3189 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
3190 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
3191 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
3193 /* If this is a list of template parameters, we could get a
3194 TYPE_DECL or a TEMPLATE_DECL. */
3195 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
3196 parm
= TREE_TYPE (parm
);
3198 /* Otherwise it must be a type template parameter. */
3199 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
3200 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
3201 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
3204 /* Determine if T is a function parameter pack. */
3207 function_parameter_pack_p (const_tree t
)
3209 if (t
&& TREE_CODE (t
) == PARM_DECL
)
3210 return DECL_PACK_P (t
);
3214 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3215 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3218 get_function_template_decl (const_tree primary_func_tmpl_inst
)
3220 if (! primary_func_tmpl_inst
3221 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
3222 || ! primary_template_specialization_p (primary_func_tmpl_inst
))
3225 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
3228 /* Return true iff the function parameter PARAM_DECL was expanded
3229 from the function parameter pack PACK. */
3232 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
3234 if (DECL_ARTIFICIAL (param_decl
)
3235 || !function_parameter_pack_p (pack
))
3238 /* The parameter pack and its pack arguments have the same
3240 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
3243 /* Determine whether ARGS describes a variadic template args list,
3244 i.e., one that is terminated by a template argument pack. */
3247 template_args_variadic_p (tree args
)
3252 if (args
== NULL_TREE
)
3255 args
= INNERMOST_TEMPLATE_ARGS (args
);
3256 nargs
= TREE_VEC_LENGTH (args
);
3261 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
3263 return ARGUMENT_PACK_P (last_parm
);
3266 /* Generate a new name for the parameter pack name NAME (an
3267 IDENTIFIER_NODE) that incorporates its */
3270 make_ith_pack_parameter_name (tree name
, int i
)
3272 /* Munge the name to include the parameter index. */
3273 #define NUMBUF_LEN 128
3274 char numbuf
[NUMBUF_LEN
];
3278 if (name
== NULL_TREE
)
3280 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
3281 newname_len
= IDENTIFIER_LENGTH (name
)
3282 + strlen (numbuf
) + 2;
3283 newname
= (char*)alloca (newname_len
);
3284 snprintf (newname
, newname_len
,
3285 "%s#%i", IDENTIFIER_POINTER (name
), i
);
3286 return get_identifier (newname
);
3289 /* Return true if T is a primary function, class or alias template
3290 specialization, not including the template pattern. */
3293 primary_template_specialization_p (const_tree t
)
3298 if (TREE_CODE (t
) == FUNCTION_DECL
|| VAR_P (t
))
3299 return (DECL_LANG_SPECIFIC (t
)
3300 && DECL_USE_TEMPLATE (t
)
3301 && DECL_TEMPLATE_INFO (t
)
3302 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)));
3303 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3304 return (CLASSTYPE_TEMPLATE_INFO (t
)
3305 && CLASSTYPE_USE_TEMPLATE (t
)
3306 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
3307 else if (alias_template_specialization_p (t
))
3312 /* Return true if PARM is a template template parameter. */
3315 template_template_parameter_p (const_tree parm
)
3317 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3320 /* Return true iff PARM is a DECL representing a type template
3324 template_type_parameter_p (const_tree parm
)
3327 && (TREE_CODE (parm
) == TYPE_DECL
3328 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3329 && DECL_TEMPLATE_PARM_P (parm
));
3332 /* Return the template parameters of T if T is a
3333 primary template instantiation, NULL otherwise. */
3336 get_primary_template_innermost_parameters (const_tree t
)
3338 tree parms
= NULL
, template_info
= NULL
;
3340 if ((template_info
= get_template_info (t
))
3341 && primary_template_specialization_p (t
))
3342 parms
= INNERMOST_TEMPLATE_PARMS
3343 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3348 /* Return the template parameters of the LEVELth level from the full list
3349 of template parameters PARMS. */
3352 get_template_parms_at_level (tree parms
, int level
)
3356 || TREE_CODE (parms
) != TREE_LIST
3357 || level
> TMPL_PARMS_DEPTH (parms
))
3360 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3361 if (TMPL_PARMS_DEPTH (p
) == level
)
3367 /* Returns the template arguments of T if T is a template instantiation,
3371 get_template_innermost_arguments (const_tree t
)
3373 tree args
= NULL
, template_info
= NULL
;
3375 if ((template_info
= get_template_info (t
))
3376 && TI_ARGS (template_info
))
3377 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3382 /* Return the argument pack elements of T if T is a template argument pack,
3386 get_template_argument_pack_elems (const_tree t
)
3388 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3389 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3392 return ARGUMENT_PACK_ARGS (t
);
3395 /* True iff FN is a function representing a built-in variadic parameter
3399 builtin_pack_fn_p (tree fn
)
3402 || TREE_CODE (fn
) != FUNCTION_DECL
3403 || !DECL_IS_BUILTIN (fn
))
3406 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3412 /* True iff CALL is a call to a function representing a built-in variadic
3416 builtin_pack_call_p (tree call
)
3418 if (TREE_CODE (call
) != CALL_EXPR
)
3420 return builtin_pack_fn_p (CALL_EXPR_FN (call
));
3423 /* Return a TREE_VEC for the expansion of __integer_pack(HI). */
3426 expand_integer_pack (tree call
, tree args
, tsubst_flags_t complain
,
3429 tree ohi
= CALL_EXPR_ARG (call
, 0);
3430 tree hi
= tsubst_copy_and_build (ohi
, args
, complain
, in_decl
,
3431 false/*fn*/, true/*int_cst*/);
3433 if (value_dependent_expression_p (hi
))
3437 call
= copy_node (call
);
3438 CALL_EXPR_ARG (call
, 0) = hi
;
3440 tree ex
= make_pack_expansion (call
, complain
);
3441 tree vec
= make_tree_vec (1);
3442 TREE_VEC_ELT (vec
, 0) = ex
;
3447 hi
= cxx_constant_value (hi
);
3448 int len
= valid_constant_size_p (hi
) ? tree_to_shwi (hi
) : -1;
3450 /* Calculate the largest value of len that won't make the size of the vec
3451 overflow an int. The compiler will exceed resource limits long before
3452 this, but it seems a decent place to diagnose. */
3453 int max
= ((INT_MAX
- sizeof (tree_vec
)) / sizeof (tree
)) + 1;
3455 if (len
< 0 || len
> max
)
3457 if ((complain
& tf_error
)
3458 && hi
!= error_mark_node
)
3459 error ("argument to __integer_pack must be between 0 and %d", max
);
3460 return error_mark_node
;
3463 tree vec
= make_tree_vec (len
);
3465 for (int i
= 0; i
< len
; ++i
)
3466 TREE_VEC_ELT (vec
, i
) = size_int (i
);
3472 /* Return a TREE_VEC for the expansion of built-in template parameter pack
3476 expand_builtin_pack_call (tree call
, tree args
, tsubst_flags_t complain
,
3479 if (!builtin_pack_call_p (call
))
3482 tree fn
= CALL_EXPR_FN (call
);
3484 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3485 return expand_integer_pack (call
, args
, complain
, in_decl
);
3490 /* Structure used to track the progress of find_parameter_packs_r. */
3491 struct find_parameter_pack_data
3493 /* TREE_LIST that will contain all of the parameter packs found by
3495 tree
* parameter_packs
;
3497 /* Set of AST nodes that have been visited by the traversal. */
3498 hash_set
<tree
> *visited
;
3500 /* True iff we're making a type pack expansion. */
3501 bool type_pack_expansion_p
;
3504 /* Identifies all of the argument packs that occur in a template
3505 argument and appends them to the TREE_LIST inside DATA, which is a
3506 find_parameter_pack_data structure. This is a subroutine of
3507 make_pack_expansion and uses_parameter_packs. */
3509 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3512 struct find_parameter_pack_data
* ppd
=
3513 (struct find_parameter_pack_data
*)data
;
3514 bool parameter_pack_p
= false;
3516 /* Handle type aliases/typedefs. */
3517 if (TYPE_ALIAS_P (t
))
3519 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
3520 cp_walk_tree (&TI_ARGS (tinfo
),
3521 &find_parameter_packs_r
,
3527 /* Identify whether this is a parameter pack or not. */
3528 switch (TREE_CODE (t
))
3530 case TEMPLATE_PARM_INDEX
:
3531 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3532 parameter_pack_p
= true;
3535 case TEMPLATE_TYPE_PARM
:
3536 t
= TYPE_MAIN_VARIANT (t
);
3538 case TEMPLATE_TEMPLATE_PARM
:
3539 /* If the placeholder appears in the decl-specifier-seq of a function
3540 parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3541 is a pack expansion, the invented template parameter is a template
3543 if (ppd
->type_pack_expansion_p
&& is_auto (t
))
3544 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
3545 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3546 parameter_pack_p
= true;
3551 if (DECL_PACK_P (t
))
3553 /* We don't want to walk into the type of a PARM_DECL,
3554 because we don't want to see the type parameter pack. */
3556 parameter_pack_p
= true;
3560 /* Look through a lambda capture proxy to the field pack. */
3562 if (DECL_HAS_VALUE_EXPR_P (t
))
3564 tree v
= DECL_VALUE_EXPR (t
);
3566 &find_parameter_packs_r
,
3570 else if (variable_template_specialization_p (t
))
3572 cp_walk_tree (&DECL_TI_ARGS (t
),
3573 find_parameter_packs_r
,
3580 if (builtin_pack_call_p (t
))
3581 parameter_pack_p
= true;
3585 parameter_pack_p
= true;
3588 /* Not a parameter pack. */
3592 if (parameter_pack_p
)
3594 /* Add this parameter pack to the list. */
3595 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3599 cp_walk_tree (&TYPE_CONTEXT (t
),
3600 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3602 /* This switch statement will return immediately if we don't find a
3604 switch (TREE_CODE (t
))
3606 case TEMPLATE_PARM_INDEX
:
3609 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3610 /* Check the template itself. */
3611 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3612 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3613 /* Check the template arguments. */
3614 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3619 case TEMPLATE_TYPE_PARM
:
3620 case TEMPLATE_TEMPLATE_PARM
:
3627 /* Ignore the declaration of a capture proxy for a parameter pack. */
3628 if (is_capture_proxy (DECL_EXPR_DECL (t
)))
3633 if (TYPE_PTRMEMFUNC_P (t
))
3639 if (TYPE_TEMPLATE_INFO (t
))
3640 cp_walk_tree (&TYPE_TI_ARGS (t
),
3641 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3647 if (!DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
3652 cp_walk_tree (&TREE_TYPE (t
),
3653 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3657 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3662 case TYPE_PACK_EXPANSION
:
3663 case EXPR_PACK_EXPANSION
:
3668 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3673 case IDENTIFIER_NODE
:
3674 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3681 tree fn
= lambda_function (t
);
3682 cp_walk_tree (&DECL_SAVED_TREE (fn
), &find_parameter_packs_r
, ppd
,
3690 /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
3691 type_pack_expansion_p to false so that any placeholders
3692 within the expression don't get marked as parameter packs. */
3693 bool type_pack_expansion_p
= ppd
->type_pack_expansion_p
;
3694 ppd
->type_pack_expansion_p
= false;
3695 cp_walk_tree (&DECLTYPE_TYPE_EXPR (t
), &find_parameter_packs_r
,
3697 ppd
->type_pack_expansion_p
= type_pack_expansion_p
;
3709 /* Determines if the expression or type T uses any parameter packs. */
3711 uses_parameter_packs (tree t
)
3713 tree parameter_packs
= NULL_TREE
;
3714 struct find_parameter_pack_data ppd
;
3715 ppd
.parameter_packs
= ¶meter_packs
;
3716 ppd
.visited
= new hash_set
<tree
>;
3717 ppd
.type_pack_expansion_p
= false;
3718 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3720 return parameter_packs
!= NULL_TREE
;
3723 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3724 representation a base-class initializer into a parameter pack
3725 expansion. If all goes well, the resulting node will be an
3726 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3729 make_pack_expansion (tree arg
, tsubst_flags_t complain
)
3732 tree parameter_packs
= NULL_TREE
;
3733 bool for_types
= false;
3734 struct find_parameter_pack_data ppd
;
3736 if (!arg
|| arg
== error_mark_node
)
3739 if (TREE_CODE (arg
) == TREE_LIST
&& TREE_PURPOSE (arg
))
3741 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3742 class initializer. In this case, the TREE_PURPOSE will be a
3743 _TYPE node (representing the base class expansion we're
3744 initializing) and the TREE_VALUE will be a TREE_LIST
3745 containing the initialization arguments.
3747 The resulting expansion looks somewhat different from most
3748 expansions. Rather than returning just one _EXPANSION, we
3749 return a TREE_LIST whose TREE_PURPOSE is a
3750 TYPE_PACK_EXPANSION containing the bases that will be
3751 initialized. The TREE_VALUE will be identical to the
3752 original TREE_VALUE, which is a list of arguments that will
3753 be passed to each base. We do not introduce any new pack
3754 expansion nodes into the TREE_VALUE (although it is possible
3755 that some already exist), because the TREE_PURPOSE and
3756 TREE_VALUE all need to be expanded together with the same
3757 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3758 resulting TREE_PURPOSE will mention the parameter packs in
3759 both the bases and the arguments to the bases. */
3762 tree parameter_packs
= NULL_TREE
;
3764 /* Determine which parameter packs will be used by the base
3766 ppd
.visited
= new hash_set
<tree
>;
3767 ppd
.parameter_packs
= ¶meter_packs
;
3768 ppd
.type_pack_expansion_p
= true;
3769 gcc_assert (TYPE_P (TREE_PURPOSE (arg
)));
3770 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3773 if (parameter_packs
== NULL_TREE
)
3775 if (complain
& tf_error
)
3776 error ("base initializer expansion %qT contains no parameter packs",
3779 return error_mark_node
;
3782 if (TREE_VALUE (arg
) != void_type_node
)
3784 /* Collect the sets of parameter packs used in each of the
3785 initialization arguments. */
3786 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3788 /* Determine which parameter packs will be expanded in this
3790 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3797 /* Create the pack expansion type for the base type. */
3798 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3799 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3800 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3801 PACK_EXPANSION_LOCAL_P (purpose
) = at_function_scope_p ();
3803 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3804 they will rarely be compared to anything. */
3805 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3807 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3810 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3813 /* Build the PACK_EXPANSION_* node. */
3815 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3816 : make_node (EXPR_PACK_EXPANSION
);
3817 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3818 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3820 /* Propagate type and const-expression information. */
3821 TREE_TYPE (result
) = TREE_TYPE (arg
);
3822 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3823 /* Mark this read now, since the expansion might be length 0. */
3824 mark_exp_read (arg
);
3827 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3828 they will rarely be compared to anything. */
3829 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3831 /* Determine which parameter packs will be expanded. */
3832 ppd
.parameter_packs
= ¶meter_packs
;
3833 ppd
.visited
= new hash_set
<tree
>;
3834 ppd
.type_pack_expansion_p
= TYPE_P (arg
);
3835 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3838 /* Make sure we found some parameter packs. */
3839 if (parameter_packs
== NULL_TREE
)
3841 if (complain
& tf_error
)
3844 error ("expansion pattern %qT contains no argument packs", arg
);
3846 error ("expansion pattern %qE contains no argument packs", arg
);
3848 return error_mark_node
;
3850 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3852 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3857 /* Checks T for any "bare" parameter packs, which have not yet been
3858 expanded, and issues an error if any are found. This operation can
3859 only be done on full expressions or types (e.g., an expression
3860 statement, "if" condition, etc.), because we could have expressions like:
3862 foo(f(g(h(args)))...)
3864 where "args" is a parameter pack. check_for_bare_parameter_packs
3865 should not be called for the subexpressions args, h(args),
3866 g(h(args)), or f(g(h(args))), because we would produce erroneous
3869 Returns TRUE and emits an error if there were bare parameter packs,
3870 returns FALSE otherwise. */
3872 check_for_bare_parameter_packs (tree t
)
3874 tree parameter_packs
= NULL_TREE
;
3875 struct find_parameter_pack_data ppd
;
3877 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3880 /* A lambda might use a parameter pack from the containing context. */
3881 if (current_function_decl
&& LAMBDA_FUNCTION_P (current_function_decl
))
3884 if (TREE_CODE (t
) == TYPE_DECL
)
3887 ppd
.parameter_packs
= ¶meter_packs
;
3888 ppd
.visited
= new hash_set
<tree
>;
3889 ppd
.type_pack_expansion_p
= false;
3890 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3893 if (parameter_packs
)
3895 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
3896 error_at (loc
, "parameter packs not expanded with %<...%>:");
3897 while (parameter_packs
)
3899 tree pack
= TREE_VALUE (parameter_packs
);
3900 tree name
= NULL_TREE
;
3902 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3903 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3904 name
= TYPE_NAME (pack
);
3905 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3906 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3907 else if (TREE_CODE (pack
) == CALL_EXPR
)
3908 name
= DECL_NAME (CALL_EXPR_FN (pack
));
3910 name
= DECL_NAME (pack
);
3913 inform (loc
, " %qD", name
);
3915 inform (loc
, " <anonymous>");
3917 parameter_packs
= TREE_CHAIN (parameter_packs
);
3926 /* Expand any parameter packs that occur in the template arguments in
3929 expand_template_argument_pack (tree args
)
3931 if (args
== error_mark_node
)
3932 return error_mark_node
;
3934 tree result_args
= NULL_TREE
;
3935 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3936 int num_result_args
= -1;
3937 int non_default_args_count
= -1;
3939 /* First, determine if we need to expand anything, and the number of
3940 slots we'll need. */
3941 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3943 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3944 if (arg
== NULL_TREE
)
3946 if (ARGUMENT_PACK_P (arg
))
3948 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3949 if (num_result_args
< 0)
3950 num_result_args
= in_arg
+ num_packed
;
3952 num_result_args
+= num_packed
;
3956 if (num_result_args
>= 0)
3961 /* If no expansion is necessary, we're done. */
3962 if (num_result_args
< 0)
3965 /* Expand arguments. */
3966 result_args
= make_tree_vec (num_result_args
);
3967 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3968 non_default_args_count
=
3969 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3970 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3972 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3973 if (ARGUMENT_PACK_P (arg
))
3975 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3976 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3977 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3978 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3979 if (non_default_args_count
> 0)
3980 non_default_args_count
+= num_packed
- 1;
3984 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3988 if (non_default_args_count
>= 0)
3989 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3993 /* Checks if DECL shadows a template parameter.
3995 [temp.local]: A template-parameter shall not be redeclared within its
3996 scope (including nested scopes).
3998 Emits an error and returns TRUE if the DECL shadows a parameter,
3999 returns FALSE otherwise. */
4002 check_template_shadow (tree decl
)
4006 /* If we're not in a template, we can't possibly shadow a template
4008 if (!current_template_parms
)
4011 /* Figure out what we're shadowing. */
4012 decl
= OVL_FIRST (decl
);
4013 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
4015 /* If there's no previous binding for this name, we're not shadowing
4016 anything, let alone a template parameter. */
4020 /* If we're not shadowing a template parameter, we're done. Note
4021 that OLDDECL might be an OVERLOAD (or perhaps even an
4022 ERROR_MARK), so we can't just blithely assume it to be a _DECL
4024 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
4027 /* We check for decl != olddecl to avoid bogus errors for using a
4028 name inside a class. We check TPFI to avoid duplicate errors for
4029 inline member templates. */
4031 || (DECL_TEMPLATE_PARM_P (decl
)
4032 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
4035 /* Don't complain about the injected class name, as we've already
4036 complained about the class itself. */
4037 if (DECL_SELF_REFERENCE_P (decl
))
4040 if (DECL_TEMPLATE_PARM_P (decl
))
4041 error ("declaration of template parameter %q+D shadows "
4042 "template parameter", decl
);
4044 error ("declaration of %q+#D shadows template parameter", decl
);
4045 inform (DECL_SOURCE_LOCATION (olddecl
),
4046 "template parameter %qD declared here", olddecl
);
4050 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
4051 ORIG_LEVEL, DECL, and TYPE. */
4054 build_template_parm_index (int index
,
4060 tree t
= make_node (TEMPLATE_PARM_INDEX
);
4061 TEMPLATE_PARM_IDX (t
) = index
;
4062 TEMPLATE_PARM_LEVEL (t
) = level
;
4063 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
4064 TEMPLATE_PARM_DECL (t
) = decl
;
4065 TREE_TYPE (t
) = type
;
4066 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
4067 TREE_READONLY (t
) = TREE_READONLY (decl
);
4072 /* Find the canonical type parameter for the given template type
4073 parameter. Returns the canonical type parameter, which may be TYPE
4074 if no such parameter existed. */
4077 canonical_type_parameter (tree type
)
4080 int idx
= TEMPLATE_TYPE_IDX (type
);
4081 if (!canonical_template_parms
)
4082 vec_alloc (canonical_template_parms
, idx
+ 1);
4084 if (canonical_template_parms
->length () <= (unsigned) idx
)
4085 vec_safe_grow_cleared (canonical_template_parms
, idx
+ 1);
4087 list
= (*canonical_template_parms
)[idx
];
4088 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
4089 list
= TREE_CHAIN (list
);
4092 return TREE_VALUE (list
);
4095 (*canonical_template_parms
)[idx
]
4096 = tree_cons (NULL_TREE
, type
, (*canonical_template_parms
)[idx
]);
4101 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
4102 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
4103 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
4104 new one is created. */
4107 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
4108 tsubst_flags_t complain
)
4110 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
4111 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
4112 != TEMPLATE_PARM_LEVEL (index
) - levels
)
4113 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
4115 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
4118 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
4119 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
4120 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
4121 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
4122 DECL_ARTIFICIAL (decl
) = 1;
4123 SET_DECL_TEMPLATE_PARM_P (decl
);
4125 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
4126 TEMPLATE_PARM_LEVEL (index
) - levels
,
4127 TEMPLATE_PARM_ORIG_LEVEL (index
),
4129 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
4130 TEMPLATE_PARM_PARAMETER_PACK (t
)
4131 = TEMPLATE_PARM_PARAMETER_PACK (index
);
4133 /* Template template parameters need this. */
4134 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4136 DECL_TEMPLATE_RESULT (decl
)
4137 = build_decl (DECL_SOURCE_LOCATION (decl
),
4138 TYPE_DECL
, DECL_NAME (decl
), type
);
4139 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (decl
)) = true;
4140 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
4141 (DECL_TEMPLATE_PARMS (orig_decl
), args
, complain
);
4145 return TEMPLATE_PARM_DESCENDANTS (index
);
4148 /* Process information from new template parameter PARM and append it
4149 to the LIST being built. This new parameter is a non-type
4150 parameter iff IS_NON_TYPE is true. This new parameter is a
4151 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4155 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
4156 bool is_non_type
, bool is_parameter_pack
)
4161 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
4162 tree defval
= TREE_PURPOSE (parm
);
4163 tree constr
= TREE_TYPE (parm
);
4167 tree p
= tree_last (list
);
4169 if (p
&& TREE_VALUE (p
) != error_mark_node
)
4172 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
4173 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
4175 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
4183 parm
= TREE_VALUE (parm
);
4185 SET_DECL_TEMPLATE_PARM_P (parm
);
4187 if (TREE_TYPE (parm
) != error_mark_node
)
4191 The top-level cv-qualifiers on the template-parameter are
4192 ignored when determining its type. */
4193 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
4194 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
4195 TREE_TYPE (parm
) = error_mark_node
;
4196 else if (uses_parameter_packs (TREE_TYPE (parm
))
4197 && !is_parameter_pack
4198 /* If we're in a nested template parameter list, the template
4199 template parameter could be a parameter pack. */
4200 && processing_template_parmlist
== 1)
4202 /* This template parameter is not a parameter pack, but it
4203 should be. Complain about "bare" parameter packs. */
4204 check_for_bare_parameter_packs (TREE_TYPE (parm
));
4206 /* Recover by calling this a parameter pack. */
4207 is_parameter_pack
= true;
4211 /* A template parameter is not modifiable. */
4212 TREE_CONSTANT (parm
) = 1;
4213 TREE_READONLY (parm
) = 1;
4214 decl
= build_decl (parm_loc
,
4215 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
4216 TREE_CONSTANT (decl
) = 1;
4217 TREE_READONLY (decl
) = 1;
4218 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
4219 = build_template_parm_index (idx
, processing_template_decl
,
4220 processing_template_decl
,
4221 decl
, TREE_TYPE (parm
));
4223 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
4224 = is_parameter_pack
;
4229 parm
= TREE_VALUE (TREE_VALUE (parm
));
4231 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
4233 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
4234 /* This is for distinguishing between real templates and template
4235 template parameters */
4236 TREE_TYPE (parm
) = t
;
4237 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
4242 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
4243 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4244 decl
= build_decl (parm_loc
,
4245 TYPE_DECL
, parm
, t
);
4248 TYPE_NAME (t
) = decl
;
4249 TYPE_STUB_DECL (t
) = decl
;
4251 TEMPLATE_TYPE_PARM_INDEX (t
)
4252 = build_template_parm_index (idx
, processing_template_decl
,
4253 processing_template_decl
,
4254 decl
, TREE_TYPE (parm
));
4255 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
4256 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
4258 DECL_ARTIFICIAL (decl
) = 1;
4259 SET_DECL_TEMPLATE_PARM_P (decl
);
4261 /* Build requirements for the type/template parameter.
4262 This must be done after SET_DECL_TEMPLATE_PARM_P or
4263 process_template_parm could fail. */
4264 tree reqs
= finish_shorthand_constraint (parm
, constr
);
4268 /* Build the parameter node linking the parameter declaration,
4269 its default argument (if any), and its constraints (if any). */
4270 parm
= build_tree_list (defval
, parm
);
4271 TEMPLATE_PARM_CONSTRAINTS (parm
) = reqs
;
4273 return chainon (list
, parm
);
4276 /* The end of a template parameter list has been reached. Process the
4277 tree list into a parameter vector, converting each parameter into a more
4278 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4282 end_template_parm_list (tree parms
)
4286 tree saved_parmlist
= make_tree_vec (list_length (parms
));
4288 /* Pop the dummy parameter level and add the real one. */
4289 current_template_parms
= TREE_CHAIN (current_template_parms
);
4291 current_template_parms
4292 = tree_cons (size_int (processing_template_decl
),
4293 saved_parmlist
, current_template_parms
);
4295 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
4297 next
= TREE_CHAIN (parm
);
4298 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
4299 TREE_CHAIN (parm
) = NULL_TREE
;
4302 --processing_template_parmlist
;
4304 return saved_parmlist
;
4307 // Explicitly indicate the end of the template parameter list. We assume
4308 // that the current template parameters have been constructed and/or
4309 // managed explicitly, as when creating new template template parameters
4310 // from a shorthand constraint.
4312 end_template_parm_list ()
4314 --processing_template_parmlist
;
4317 /* end_template_decl is called after a template declaration is seen. */
4320 end_template_decl (void)
4322 reset_specialization ();
4324 if (! processing_template_decl
)
4327 /* This matches the pushlevel in begin_template_parm_list. */
4330 --processing_template_decl
;
4331 current_template_parms
= TREE_CHAIN (current_template_parms
);
4334 /* Takes a TREE_LIST representing a template parameter and convert it
4335 into an argument suitable to be passed to the type substitution
4336 functions. Note that If the TREE_LIST contains an error_mark
4337 node, the returned argument is error_mark_node. */
4340 template_parm_to_arg (tree t
)
4344 || TREE_CODE (t
) != TREE_LIST
)
4347 if (error_operand_p (TREE_VALUE (t
)))
4348 return error_mark_node
;
4352 if (TREE_CODE (t
) == TYPE_DECL
4353 || TREE_CODE (t
) == TEMPLATE_DECL
)
4357 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
4359 /* Turn this argument into a TYPE_ARGUMENT_PACK
4360 with a single element, which expands T. */
4361 tree vec
= make_tree_vec (1);
4363 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4365 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4367 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
4368 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4373 t
= DECL_INITIAL (t
);
4375 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
4377 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4378 with a single element, which expands T. */
4379 tree vec
= make_tree_vec (1);
4381 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4383 t
= convert_from_reference (t
);
4384 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4386 t
= make_node (NONTYPE_ARGUMENT_PACK
);
4387 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4390 t
= convert_from_reference (t
);
4395 /* Given a single level of template parameters (a TREE_VEC), return it
4396 as a set of template arguments. */
4399 template_parms_level_to_args (tree parms
)
4401 tree a
= copy_node (parms
);
4402 TREE_TYPE (a
) = NULL_TREE
;
4403 for (int i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
4404 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
4407 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
4412 /* Given a set of template parameters, return them as a set of template
4413 arguments. The template parameters are represented as a TREE_VEC, in
4414 the form documented in cp-tree.h for template arguments. */
4417 template_parms_to_args (tree parms
)
4420 tree args
= NULL_TREE
;
4421 int length
= TMPL_PARMS_DEPTH (parms
);
4424 /* If there is only one level of template parameters, we do not
4425 create a TREE_VEC of TREE_VECs. Instead, we return a single
4426 TREE_VEC containing the arguments. */
4428 args
= make_tree_vec (length
);
4430 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
4432 tree a
= template_parms_level_to_args (TREE_VALUE (header
));
4435 TREE_VEC_ELT (args
, --l
) = a
;
4443 /* Within the declaration of a template, return the currently active
4444 template parameters as an argument TREE_VEC. */
4447 current_template_args (void)
4449 return template_parms_to_args (current_template_parms
);
4452 /* Update the declared TYPE by doing any lookups which were thought to be
4453 dependent, but are not now that we know the SCOPE of the declarator. */
4456 maybe_update_decl_type (tree orig_type
, tree scope
)
4458 tree type
= orig_type
;
4460 if (type
== NULL_TREE
)
4463 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4464 type
= TREE_TYPE (type
);
4466 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
4467 && dependent_type_p (type
)
4468 /* Don't bother building up the args in this case. */
4469 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
4471 /* tsubst in the args corresponding to the template parameters,
4472 including auto if present. Most things will be unchanged, but
4473 make_typename_type and tsubst_qualified_id will resolve
4474 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4475 tree args
= current_template_args ();
4476 tree auto_node
= type_uses_auto (type
);
4480 tree auto_vec
= make_tree_vec (1);
4481 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4482 args
= add_to_template_args (args
, auto_vec
);
4484 pushed
= push_scope (scope
);
4485 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4490 if (type
== error_mark_node
)
4493 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4495 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4498 type
= TYPE_NAME (type
);
4503 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4504 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4505 the new template is a member template. */
4508 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4510 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4511 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4512 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4513 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4514 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4519 struct template_parm_data
4521 /* The level of the template parameters we are currently
4525 /* The index of the specialization argument we are currently
4529 /* An array whose size is the number of template parameters. The
4530 elements are nonzero if the parameter has been used in any one
4531 of the arguments processed so far. */
4534 /* An array whose size is the number of template arguments. The
4535 elements are nonzero if the argument makes use of template
4536 parameters of this level. */
4537 int* arg_uses_template_parms
;
4540 /* Subroutine of push_template_decl used to see if each template
4541 parameter in a partial specialization is used in the explicit
4542 argument list. If T is of the LEVEL given in DATA (which is
4543 treated as a template_parm_data*), then DATA->PARMS is marked
4547 mark_template_parm (tree t
, void* data
)
4551 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4553 template_parm_level_and_index (t
, &level
, &idx
);
4555 if (level
== tpd
->level
)
4557 tpd
->parms
[idx
] = 1;
4558 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4561 /* In C++17 the type of a non-type argument is a deduced context. */
4562 if (cxx_dialect
>= cxx17
4563 && TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4564 for_each_template_parm (TREE_TYPE (t
),
4565 &mark_template_parm
,
4568 /*include_nondeduced_p=*/false);
4570 /* Return zero so that for_each_template_parm will continue the
4571 traversal of the tree; we want to mark *every* template parm. */
4575 /* Process the partial specialization DECL. */
4578 process_partial_specialization (tree decl
)
4580 tree type
= TREE_TYPE (decl
);
4581 tree tinfo
= get_template_info (decl
);
4582 tree maintmpl
= TI_TEMPLATE (tinfo
);
4583 tree specargs
= TI_ARGS (tinfo
);
4584 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4585 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4588 int nargs
= TREE_VEC_LENGTH (inner_args
);
4591 bool did_error_intro
= false;
4592 struct template_parm_data tpd
;
4593 struct template_parm_data tpd2
;
4595 gcc_assert (current_template_parms
);
4597 /* A concept cannot be specialized. */
4598 if (flag_concepts
&& variable_concept_p (maintmpl
))
4600 error ("specialization of variable concept %q#D", maintmpl
);
4601 return error_mark_node
;
4604 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4605 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4607 /* We check that each of the template parameters given in the
4608 partial specialization is used in the argument list to the
4609 specialization. For example:
4611 template <class T> struct S;
4612 template <class T> struct S<T*>;
4614 The second declaration is OK because `T*' uses the template
4615 parameter T, whereas
4617 template <class T> struct S<int>;
4619 is no good. Even trickier is:
4630 The S2<T> declaration is actually invalid; it is a
4631 full-specialization. Of course,
4634 struct S2<T (*)(U)>;
4636 or some such would have been OK. */
4637 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4638 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4639 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4641 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4642 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4643 for (i
= 0; i
< nargs
; ++i
)
4645 tpd
.current_arg
= i
;
4646 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4647 &mark_template_parm
,
4650 /*include_nondeduced_p=*/false);
4652 for (i
= 0; i
< ntparms
; ++i
)
4653 if (tpd
.parms
[i
] == 0)
4655 /* One of the template parms was not used in a deduced context in the
4657 if (!did_error_intro
)
4659 error ("template parameters not deducible in "
4660 "partial specialization:");
4661 did_error_intro
= true;
4664 inform (input_location
, " %qD",
4665 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4668 if (did_error_intro
)
4669 return error_mark_node
;
4671 /* [temp.class.spec]
4673 The argument list of the specialization shall not be identical to
4674 the implicit argument list of the primary template. */
4676 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl
)));
4677 if (comp_template_args (inner_args
, INNERMOST_TEMPLATE_ARGS (main_args
))
4679 || !strictly_subsumes (current_template_constraints (),
4680 get_constraints (maintmpl
))))
4683 error ("partial specialization %q+D does not specialize "
4684 "any template arguments", decl
);
4686 error ("partial specialization %q+D does not specialize any "
4687 "template arguments and is not more constrained than", decl
);
4688 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4691 /* A partial specialization that replaces multiple parameters of the
4692 primary template with a pack expansion is less specialized for those
4694 if (nargs
< DECL_NTPARMS (maintmpl
))
4696 error ("partial specialization is not more specialized than the "
4697 "primary template because it replaces multiple parameters "
4698 "with a pack expansion");
4699 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4700 /* Avoid crash in process_partial_specialization. */
4704 /* If we aren't in a dependent class, we can actually try deduction. */
4705 else if (tpd
.level
== 1
4706 /* FIXME we should be able to handle a partial specialization of a
4707 partial instantiation, but currently we can't (c++/41727). */
4708 && TMPL_ARGS_DEPTH (specargs
) == 1
4709 && !get_partial_spec_bindings (maintmpl
, maintmpl
, specargs
))
4711 if (permerror (input_location
, "partial specialization %qD is not "
4712 "more specialized than", decl
))
4713 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template %qD",
4717 /* [temp.class.spec]
4719 A partially specialized non-type argument expression shall not
4720 involve template parameters of the partial specialization except
4721 when the argument expression is a simple identifier.
4723 The type of a template parameter corresponding to a specialized
4724 non-type argument shall not be dependent on a parameter of the
4727 Also, we verify that pack expansions only occur at the
4728 end of the argument list. */
4729 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4731 for (i
= 0; i
< nargs
; ++i
)
4733 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4734 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4735 tree packed_args
= NULL_TREE
;
4738 if (ARGUMENT_PACK_P (arg
))
4740 /* Extract the arguments from the argument pack. We'll be
4741 iterating over these in the following loop. */
4742 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4743 len
= TREE_VEC_LENGTH (packed_args
);
4746 for (j
= 0; j
< len
; j
++)
4749 /* Get the Jth argument in the parameter pack. */
4750 arg
= TREE_VEC_ELT (packed_args
, j
);
4752 if (PACK_EXPANSION_P (arg
))
4754 /* Pack expansions must come at the end of the
4756 if ((packed_args
&& j
< len
- 1)
4757 || (!packed_args
&& i
< nargs
- 1))
4759 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4760 error ("parameter pack argument %qE must be at the "
4761 "end of the template argument list", arg
);
4763 error ("parameter pack argument %qT must be at the "
4764 "end of the template argument list", arg
);
4768 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4769 /* We only care about the pattern. */
4770 arg
= PACK_EXPANSION_PATTERN (arg
);
4772 if (/* These first two lines are the `non-type' bit. */
4774 && TREE_CODE (arg
) != TEMPLATE_DECL
4775 /* This next two lines are the `argument expression is not just a
4776 simple identifier' condition and also the `specialized
4777 non-type argument' bit. */
4778 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4779 && !(REFERENCE_REF_P (arg
)
4780 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4782 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4783 || (packed_args
&& uses_template_parms (arg
)))
4784 error ("template argument %qE involves template parameter(s)",
4788 /* Look at the corresponding template parameter,
4789 marking which template parameters its type depends
4791 tree type
= TREE_TYPE (parm
);
4795 /* We haven't yet initialized TPD2. Do so now. */
4796 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4797 /* The number of parameters here is the number in the
4798 main template, which, as checked in the assertion
4800 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4802 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4805 /* Mark the template parameters. But this time, we're
4806 looking for the template parameters of the main
4807 template, not in the specialization. */
4808 tpd2
.current_arg
= i
;
4809 tpd2
.arg_uses_template_parms
[i
] = 0;
4810 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4811 for_each_template_parm (type
,
4812 &mark_template_parm
,
4815 /*include_nondeduced_p=*/false);
4817 if (tpd2
.arg_uses_template_parms
[i
])
4819 /* The type depended on some template parameters.
4820 If they are fully specialized in the
4821 specialization, that's OK. */
4824 for (j
= 0; j
< nargs
; ++j
)
4825 if (tpd2
.parms
[j
] != 0
4826 && tpd
.arg_uses_template_parms
[j
])
4829 error_n (input_location
, count
,
4830 "type %qT of template argument %qE depends "
4831 "on a template parameter",
4832 "type %qT of template argument %qE depends "
4833 "on template parameters",
4842 /* We should only get here once. */
4843 if (TREE_CODE (decl
) == TYPE_DECL
)
4844 gcc_assert (!COMPLETE_TYPE_P (type
));
4846 // Build the template decl.
4847 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4848 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4849 TREE_TYPE (tmpl
) = type
;
4850 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4851 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4852 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4853 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4855 /* Give template template parms a DECL_CONTEXT of the template
4856 for which they are a parameter. */
4857 for (i
= 0; i
< ntparms
; ++i
)
4859 tree parm
= TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
));
4860 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
4861 DECL_CONTEXT (parm
) = tmpl
;
4865 /* We didn't register this in check_explicit_specialization so we could
4866 wait until the constraints were set. */
4867 decl
= register_specialization (decl
, maintmpl
, specargs
, false, 0);
4869 associate_classtype_constraints (type
);
4871 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4872 = tree_cons (specargs
, tmpl
,
4873 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4874 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4876 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4877 inst
= TREE_CHAIN (inst
))
4879 tree instance
= TREE_VALUE (inst
);
4880 if (TYPE_P (instance
)
4881 ? (COMPLETE_TYPE_P (instance
)
4882 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance
))
4883 : DECL_TEMPLATE_INSTANTIATION (instance
))
4885 tree spec
= most_specialized_partial_spec (instance
, tf_none
);
4886 tree inst_decl
= (DECL_P (instance
)
4887 ? instance
: TYPE_NAME (instance
));
4890 else if (spec
== error_mark_node
)
4891 permerror (input_location
,
4892 "declaration of %qD ambiguates earlier template "
4893 "instantiation for %qD", decl
, inst_decl
);
4894 else if (TREE_VALUE (spec
) == tmpl
)
4895 permerror (input_location
,
4896 "partial specialization of %qD after instantiation "
4897 "of %qD", decl
, inst_decl
);
4904 /* PARM is a template parameter of some form; return the corresponding
4905 TEMPLATE_PARM_INDEX. */
4908 get_template_parm_index (tree parm
)
4910 if (TREE_CODE (parm
) == PARM_DECL
4911 || TREE_CODE (parm
) == CONST_DECL
)
4912 parm
= DECL_INITIAL (parm
);
4913 else if (TREE_CODE (parm
) == TYPE_DECL
4914 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4915 parm
= TREE_TYPE (parm
);
4916 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4917 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
4918 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4919 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4920 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4924 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4925 parameter packs used by the template parameter PARM. */
4928 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4930 /* A type parm can't refer to another parm. */
4931 if (TREE_CODE (parm
) == TYPE_DECL
)
4933 else if (TREE_CODE (parm
) == PARM_DECL
)
4935 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4940 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4942 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4943 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4944 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4947 /* PARM is a template parameter pack. Return any parameter packs used in
4948 its type or the type of any of its template parameters. If there are
4949 any such packs, it will be instantiated into a fixed template parameter
4950 list by partial instantiation rather than be fully deduced. */
4953 fixed_parameter_pack_p (tree parm
)
4955 /* This can only be true in a member template. */
4956 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4958 /* This can only be true for a parameter pack. */
4959 if (!template_parameter_pack_p (parm
))
4961 /* A type parm can't refer to another parm. */
4962 if (TREE_CODE (parm
) == TYPE_DECL
)
4965 tree parameter_packs
= NULL_TREE
;
4966 struct find_parameter_pack_data ppd
;
4967 ppd
.parameter_packs
= ¶meter_packs
;
4968 ppd
.visited
= new hash_set
<tree
>;
4969 ppd
.type_pack_expansion_p
= false;
4971 fixed_parameter_pack_p_1 (parm
, &ppd
);
4974 return parameter_packs
;
4977 /* Check that a template declaration's use of default arguments and
4978 parameter packs is not invalid. Here, PARMS are the template
4979 parameters. IS_PRIMARY is true if DECL is the thing declared by
4980 a primary template. IS_PARTIAL is true if DECL is a partial
4983 IS_FRIEND_DECL is nonzero if DECL is either a non-defining friend
4984 function template declaration or a friend class template
4985 declaration. In the function case, 1 indicates a declaration, 2
4986 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4987 emitted for extraneous default arguments.
4989 Returns TRUE if there were no errors found, FALSE otherwise. */
4992 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4993 bool is_partial
, int is_friend_decl
)
4996 int last_level_to_check
;
4998 bool no_errors
= true;
5002 A default template-argument shall not be specified in a
5003 function template declaration or a function template definition, nor
5004 in the template-parameter-list of the definition of a member of a
5007 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
5008 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
5009 /* You can't have a function template declaration in a local
5010 scope, nor you can you define a member of a class template in a
5014 if ((TREE_CODE (decl
) == TYPE_DECL
5016 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5017 || (TREE_CODE (decl
) == FUNCTION_DECL
5018 && LAMBDA_FUNCTION_P (decl
)))
5019 /* A lambda doesn't have an explicit declaration; don't complain
5020 about the parms of the enclosing class. */
5023 if (current_class_type
5024 && !TYPE_BEING_DEFINED (current_class_type
)
5025 && DECL_LANG_SPECIFIC (decl
)
5026 && DECL_DECLARES_FUNCTION_P (decl
)
5027 /* If this is either a friend defined in the scope of the class
5028 or a member function. */
5029 && (DECL_FUNCTION_MEMBER_P (decl
)
5030 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
5031 : DECL_FRIEND_CONTEXT (decl
)
5032 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
5034 /* And, if it was a member function, it really was defined in
5035 the scope of the class. */
5036 && (!DECL_FUNCTION_MEMBER_P (decl
)
5037 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
5038 /* We already checked these parameters when the template was
5039 declared, so there's no need to do it again now. This function
5040 was defined in class scope, but we're processing its body now
5041 that the class is complete. */
5044 /* Core issue 226 (C++0x only): the following only applies to class
5047 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
5051 If a template-parameter has a default template-argument, all
5052 subsequent template-parameters shall have a default
5053 template-argument supplied. */
5054 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
5056 tree inner_parms
= TREE_VALUE (parm_level
);
5057 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
5058 int seen_def_arg_p
= 0;
5061 for (i
= 0; i
< ntparms
; ++i
)
5063 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
5065 if (parm
== error_mark_node
)
5068 if (TREE_PURPOSE (parm
))
5070 else if (seen_def_arg_p
5071 && !template_parameter_pack_p (TREE_VALUE (parm
)))
5073 error ("no default argument for %qD", TREE_VALUE (parm
));
5074 /* For better subsequent error-recovery, we indicate that
5075 there should have been a default argument. */
5076 TREE_PURPOSE (parm
) = error_mark_node
;
5079 else if (!is_partial
5081 /* Don't complain about an enclosing partial
5083 && parm_level
== parms
5084 && TREE_CODE (decl
) == TYPE_DECL
5086 && template_parameter_pack_p (TREE_VALUE (parm
))
5087 /* A fixed parameter pack will be partially
5088 instantiated into a fixed length list. */
5089 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
5091 /* A primary class template can only have one
5092 parameter pack, at the end of the template
5095 error ("parameter pack %q+D must be at the end of the"
5096 " template parameter list", TREE_VALUE (parm
));
5098 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
5106 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
5110 /* For an ordinary class template, default template arguments are
5111 allowed at the innermost level, e.g.:
5112 template <class T = int>
5114 but, in a partial specialization, they're not allowed even
5115 there, as we have in [temp.class.spec]:
5117 The template parameter list of a specialization shall not
5118 contain default template argument values.
5120 So, for a partial specialization, or for a function template
5121 (in C++98/C++03), we look at all of them. */
5124 /* But, for a primary class template that is not a partial
5125 specialization we look at all template parameters except the
5127 parms
= TREE_CHAIN (parms
);
5129 /* Figure out what error message to issue. */
5130 if (is_friend_decl
== 2)
5131 msg
= G_("default template arguments may not be used in function template "
5132 "friend re-declaration");
5133 else if (is_friend_decl
)
5134 msg
= G_("default template arguments may not be used in template "
5135 "friend declarations");
5136 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
5137 msg
= G_("default template arguments may not be used in function templates "
5138 "without -std=c++11 or -std=gnu++11");
5139 else if (is_partial
)
5140 msg
= G_("default template arguments may not be used in "
5141 "partial specializations");
5142 else if (current_class_type
&& CLASSTYPE_IS_TEMPLATE (current_class_type
))
5143 msg
= G_("default argument for template parameter for class enclosing %qD");
5145 /* Per [temp.param]/9, "A default template-argument shall not be
5146 specified in the template-parameter-lists of the definition of
5147 a member of a class template that appears outside of the member's
5148 class.", thus if we aren't handling a member of a class template
5149 there is no need to examine the parameters. */
5152 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
5153 /* If we're inside a class definition, there's no need to
5154 examine the parameters to the class itself. On the one
5155 hand, they will be checked when the class is defined, and,
5156 on the other, default arguments are valid in things like:
5157 template <class T = double>
5158 struct S { template <class U> void f(U); };
5159 Here the default argument for `S' has no bearing on the
5160 declaration of `f'. */
5161 last_level_to_check
= template_class_depth (current_class_type
) + 1;
5163 /* Check everything. */
5164 last_level_to_check
= 0;
5166 for (parm_level
= parms
;
5167 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
5168 parm_level
= TREE_CHAIN (parm_level
))
5170 tree inner_parms
= TREE_VALUE (parm_level
);
5174 ntparms
= TREE_VEC_LENGTH (inner_parms
);
5175 for (i
= 0; i
< ntparms
; ++i
)
5177 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
5180 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
5185 if (is_friend_decl
== 2)
5192 /* Clear out the default argument so that we are not
5194 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
5198 /* At this point, if we're still interested in issuing messages,
5199 they must apply to classes surrounding the object declared. */
5201 msg
= G_("default argument for template parameter for class "
5208 /* Worker for push_template_decl_real, called via
5209 for_each_template_parm. DATA is really an int, indicating the
5210 level of the parameters we are interested in. If T is a template
5211 parameter of that level, return nonzero. */
5214 template_parm_this_level_p (tree t
, void* data
)
5216 int this_level
= *(int *)data
;
5219 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5220 level
= TEMPLATE_PARM_LEVEL (t
);
5222 level
= TEMPLATE_TYPE_LEVEL (t
);
5223 return level
== this_level
;
5226 /* Worker for uses_outer_template_parms, called via for_each_template_parm.
5227 DATA is really an int, indicating the innermost outer level of parameters.
5228 If T is a template parameter of that level or further out, return
5232 template_parm_outer_level (tree t
, void *data
)
5234 int this_level
= *(int *)data
;
5237 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5238 level
= TEMPLATE_PARM_LEVEL (t
);
5240 level
= TEMPLATE_TYPE_LEVEL (t
);
5241 return level
<= this_level
;
5244 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5245 parameters given by current_template_args, or reuses a
5246 previously existing one, if appropriate. Returns the DECL, or an
5247 equivalent one, if it is replaced via a call to duplicate_decls.
5249 If IS_FRIEND is true, DECL is a friend declaration. */
5252 push_template_decl_real (tree decl
, bool is_friend
)
5260 int new_template_p
= 0;
5261 /* True if the template is a member template, in the sense of
5263 bool member_template_p
= false;
5265 if (decl
== error_mark_node
|| !current_template_parms
)
5266 return error_mark_node
;
5268 /* See if this is a partial specialization. */
5269 is_partial
= ((DECL_IMPLICIT_TYPEDEF_P (decl
)
5270 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
5271 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
5273 && DECL_LANG_SPECIFIC (decl
)
5274 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5275 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
))));
5277 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
5281 /* For a friend, we want the context of the friend, not
5282 the type of which it is a friend. */
5283 ctx
= CP_DECL_CONTEXT (decl
);
5284 else if (CP_DECL_CONTEXT (decl
)
5285 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
5286 /* In the case of a virtual function, we want the class in which
5288 ctx
= CP_DECL_CONTEXT (decl
);
5290 /* Otherwise, if we're currently defining some class, the DECL
5291 is assumed to be a member of the class. */
5292 ctx
= current_scope ();
5294 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5297 if (!DECL_CONTEXT (decl
))
5298 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
5300 /* See if this is a primary template. */
5301 if (is_friend
&& ctx
5302 && uses_template_parms_level (ctx
, processing_template_decl
))
5303 /* A friend template that specifies a class context, i.e.
5304 template <typename T> friend void A<T>::f();
5307 else if (TREE_CODE (decl
) == TYPE_DECL
5308 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5311 is_primary
= template_parm_scope_p ();
5315 warning (OPT_Wtemplates
, "template %qD declared", decl
);
5317 if (DECL_CLASS_SCOPE_P (decl
))
5318 member_template_p
= true;
5319 if (TREE_CODE (decl
) == TYPE_DECL
5320 && anon_aggrname_p (DECL_NAME (decl
)))
5322 error ("template class without a name");
5323 return error_mark_node
;
5325 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
5327 if (member_template_p
)
5329 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
5330 error ("member template %qD may not have virt-specifiers", decl
);
5332 if (DECL_DESTRUCTOR_P (decl
))
5336 A destructor shall not be a member template. */
5337 error ("destructor %qD declared as member template", decl
);
5338 return error_mark_node
;
5340 if (IDENTIFIER_NEWDEL_OP_P (DECL_NAME (decl
))
5341 && (!prototype_p (TREE_TYPE (decl
))
5342 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
5343 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5344 || (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5345 == void_list_node
)))
5347 /* [basic.stc.dynamic.allocation]
5349 An allocation function can be a function
5350 template. ... Template allocation functions shall
5351 have two or more parameters. */
5352 error ("invalid template declaration of %qD", decl
);
5353 return error_mark_node
;
5356 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5357 && CLASS_TYPE_P (TREE_TYPE (decl
)))
5359 /* Class template, set TEMPLATE_TYPE_PARM_FOR_CLASS. */
5360 tree parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
5361 for (int i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
5363 tree t
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5364 if (TREE_CODE (t
) == TYPE_DECL
)
5366 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
5367 TEMPLATE_TYPE_PARM_FOR_CLASS (t
) = true;
5370 else if (TREE_CODE (decl
) == TYPE_DECL
5371 && TYPE_DECL_ALIAS_P (decl
))
5372 /* alias-declaration */
5373 gcc_assert (!DECL_ARTIFICIAL (decl
));
5374 else if (VAR_P (decl
))
5375 /* C++14 variable template. */;
5378 error ("template declaration of %q#D", decl
);
5379 return error_mark_node
;
5383 /* Check to see that the rules regarding the use of default
5384 arguments are not being violated. We check args for a friend
5385 functions when we know whether it's a definition, introducing
5386 declaration or re-declaration. */
5387 if (!is_friend
|| TREE_CODE (decl
) != FUNCTION_DECL
)
5388 check_default_tmpl_args (decl
, current_template_parms
,
5389 is_primary
, is_partial
, is_friend
);
5391 /* Ensure that there are no parameter packs in the type of this
5392 declaration that have not been expanded. */
5393 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5395 /* Check each of the arguments individually to see if there are
5396 any bare parameter packs. */
5397 tree type
= TREE_TYPE (decl
);
5398 tree arg
= DECL_ARGUMENTS (decl
);
5399 tree argtype
= TYPE_ARG_TYPES (type
);
5401 while (arg
&& argtype
)
5403 if (!DECL_PACK_P (arg
)
5404 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
5406 /* This is a PARM_DECL that contains unexpanded parameter
5407 packs. We have already complained about this in the
5408 check_for_bare_parameter_packs call, so just replace
5409 these types with ERROR_MARK_NODE. */
5410 TREE_TYPE (arg
) = error_mark_node
;
5411 TREE_VALUE (argtype
) = error_mark_node
;
5414 arg
= DECL_CHAIN (arg
);
5415 argtype
= TREE_CHAIN (argtype
);
5418 /* Check for bare parameter packs in the return type and the
5419 exception specifiers. */
5420 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
5421 /* Errors were already issued, set return type to int
5422 as the frontend doesn't expect error_mark_node as
5424 TREE_TYPE (type
) = integer_type_node
;
5425 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
5426 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
5428 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
5429 && TYPE_DECL_ALIAS_P (decl
))
5430 ? DECL_ORIGINAL_TYPE (decl
)
5431 : TREE_TYPE (decl
)))
5433 TREE_TYPE (decl
) = error_mark_node
;
5434 return error_mark_node
;
5438 return process_partial_specialization (decl
);
5440 args
= current_template_args ();
5443 || TREE_CODE (ctx
) == FUNCTION_DECL
5444 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
5445 || (TREE_CODE (decl
) == TYPE_DECL
5446 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5447 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
5449 if (DECL_LANG_SPECIFIC (decl
)
5450 && DECL_TEMPLATE_INFO (decl
)
5451 && DECL_TI_TEMPLATE (decl
))
5452 tmpl
= DECL_TI_TEMPLATE (decl
);
5453 /* If DECL is a TYPE_DECL for a class-template, then there won't
5454 be DECL_LANG_SPECIFIC. The information equivalent to
5455 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5456 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5457 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
5458 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
5460 /* Since a template declaration already existed for this
5461 class-type, we must be redeclaring it here. Make sure
5462 that the redeclaration is valid. */
5463 redeclare_class_template (TREE_TYPE (decl
),
5464 current_template_parms
,
5465 current_template_constraints ());
5466 /* We don't need to create a new TEMPLATE_DECL; just use the
5467 one we already had. */
5468 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
5472 tmpl
= build_template_decl (decl
, current_template_parms
,
5476 if (DECL_LANG_SPECIFIC (decl
)
5477 && DECL_TEMPLATE_SPECIALIZATION (decl
))
5479 /* A specialization of a member template of a template
5481 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5482 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
5483 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
5489 tree a
, t
, current
, parms
;
5491 tree tinfo
= get_template_info (decl
);
5495 error ("template definition of non-template %q#D", decl
);
5496 return error_mark_node
;
5499 tmpl
= TI_TEMPLATE (tinfo
);
5501 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
5502 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
5503 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5504 && DECL_MEMBER_TEMPLATE_P (tmpl
))
5508 /* The declaration is a specialization of a member
5509 template, declared outside the class. Therefore, the
5510 innermost template arguments will be NULL, so we
5511 replace them with the arguments determined by the
5512 earlier call to check_explicit_specialization. */
5513 args
= DECL_TI_ARGS (decl
);
5516 = build_template_decl (decl
, current_template_parms
,
5518 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
5519 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
5520 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
5521 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
5522 DECL_TEMPLATE_INFO (new_tmpl
)
5523 = build_template_info (tmpl
, args
);
5525 register_specialization (new_tmpl
,
5526 most_general_template (tmpl
),
5532 /* Make sure the template headers we got make sense. */
5534 parms
= DECL_TEMPLATE_PARMS (tmpl
);
5535 i
= TMPL_PARMS_DEPTH (parms
);
5536 if (TMPL_ARGS_DEPTH (args
) != i
)
5538 error ("expected %d levels of template parms for %q#D, got %d",
5539 i
, decl
, TMPL_ARGS_DEPTH (args
));
5540 DECL_INTERFACE_KNOWN (decl
) = 1;
5541 return error_mark_node
;
5544 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
5546 a
= TMPL_ARGS_LEVEL (args
, i
);
5547 t
= INNERMOST_TEMPLATE_PARMS (parms
);
5549 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
5551 if (current
== decl
)
5552 error ("got %d template parameters for %q#D",
5553 TREE_VEC_LENGTH (a
), decl
);
5555 error ("got %d template parameters for %q#T",
5556 TREE_VEC_LENGTH (a
), current
);
5557 error (" but %d required", TREE_VEC_LENGTH (t
));
5558 /* Avoid crash in import_export_decl. */
5559 DECL_INTERFACE_KNOWN (decl
) = 1;
5560 return error_mark_node
;
5563 if (current
== decl
)
5565 else if (current
== NULL_TREE
)
5566 /* Can happen in erroneous input. */
5569 current
= get_containing_scope (current
);
5572 /* Check that the parms are used in the appropriate qualifying scopes
5573 in the declarator. */
5574 if (!comp_template_args
5576 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
5578 error ("template arguments to %qD do not match original "
5579 "template %qD", decl
, DECL_TEMPLATE_RESULT (tmpl
));
5580 if (!uses_template_parms (TI_ARGS (tinfo
)))
5581 inform (input_location
, "use %<template<>%> for"
5582 " an explicit specialization");
5583 /* Avoid crash in import_export_decl. */
5584 DECL_INTERFACE_KNOWN (decl
) = 1;
5585 return error_mark_node
;
5589 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5590 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5592 /* Push template declarations for global functions and types. Note
5593 that we do not try to push a global template friend declared in a
5594 template class; such a thing may well depend on the template
5595 parameters of the class. */
5596 if (new_template_p
&& !ctx
5597 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5599 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5600 if (tmpl
== error_mark_node
)
5601 return error_mark_node
;
5603 /* Hide template friend classes that haven't been declared yet. */
5604 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5606 DECL_ANTICIPATED (tmpl
) = 1;
5607 DECL_FRIEND_P (tmpl
) = 1;
5613 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5615 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5617 /* Give template template parms a DECL_CONTEXT of the template
5618 for which they are a parameter. */
5619 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5620 for (int i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5622 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5623 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5624 DECL_CONTEXT (parm
) = tmpl
;
5627 if (TREE_CODE (decl
) == TYPE_DECL
5628 && TYPE_DECL_ALIAS_P (decl
)
5629 && complex_alias_template_p (tmpl
))
5630 TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl
) = true;
5633 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5634 back to its most general template. If TMPL is a specialization,
5635 ARGS may only have the innermost set of arguments. Add the missing
5636 argument levels if necessary. */
5637 if (DECL_TEMPLATE_INFO (tmpl
))
5638 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5640 info
= build_template_info (tmpl
, args
);
5642 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5643 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5647 retrofit_lang_decl (decl
);
5648 if (DECL_LANG_SPECIFIC (decl
))
5649 DECL_TEMPLATE_INFO (decl
) = info
;
5652 if (flag_implicit_templates
5654 && TREE_PUBLIC (decl
)
5655 && VAR_OR_FUNCTION_DECL_P (decl
))
5656 /* Set DECL_COMDAT on template instantiations; if we force
5657 them to be emitted by explicit instantiation or -frepo,
5658 mark_needed will tell cgraph to do the right thing. */
5659 DECL_COMDAT (decl
) = true;
5661 return DECL_TEMPLATE_RESULT (tmpl
);
5665 push_template_decl (tree decl
)
5667 return push_template_decl_real (decl
, false);
5670 /* FN is an inheriting constructor that inherits from the constructor
5671 template INHERITED; turn FN into a constructor template with a matching
5675 add_inherited_template_parms (tree fn
, tree inherited
)
5678 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5679 inner_parms
= copy_node (inner_parms
);
5681 = tree_cons (size_int (processing_template_decl
+ 1),
5682 inner_parms
, current_template_parms
);
5683 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5684 tree args
= template_parms_to_args (parms
);
5685 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5686 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5687 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5688 DECL_ARTIFICIAL (tmpl
) = true;
5689 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5693 /* Called when a class template TYPE is redeclared with the indicated
5694 template PARMS, e.g.:
5696 template <class T> struct S;
5697 template <class T> struct S {}; */
5700 redeclare_class_template (tree type
, tree parms
, tree cons
)
5706 if (!TYPE_TEMPLATE_INFO (type
))
5708 error ("%qT is not a template type", type
);
5712 tmpl
= TYPE_TI_TEMPLATE (type
);
5713 if (!PRIMARY_TEMPLATE_P (tmpl
))
5714 /* The type is nested in some template class. Nothing to worry
5715 about here; there are no new template parameters for the nested
5721 error ("template specifiers not specified in declaration of %qD",
5726 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5727 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5729 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5731 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5732 "redeclared with %d template parameter",
5733 "redeclared with %d template parameters",
5734 TREE_VEC_LENGTH (parms
));
5735 inform_n (DECL_SOURCE_LOCATION (tmpl
), TREE_VEC_LENGTH (tmpl_parms
),
5736 "previous declaration %qD used %d template parameter",
5737 "previous declaration %qD used %d template parameters",
5738 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5742 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5749 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5750 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5753 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5754 if (error_operand_p (tmpl_parm
))
5757 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5758 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5759 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5761 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5763 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5764 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5765 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5766 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5767 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5768 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5769 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5770 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5771 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5773 error ("template parameter %q+#D", tmpl_parm
);
5774 error ("redeclared here as %q#D", parm
);
5778 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5780 /* We have in [temp.param]:
5782 A template-parameter may not be given default arguments
5783 by two different declarations in the same scope. */
5784 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5785 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5786 "original definition appeared here");
5790 if (parm_default
!= NULL_TREE
)
5791 /* Update the previous template parameters (which are the ones
5792 that will really count) with the new default value. */
5793 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5794 else if (tmpl_default
!= NULL_TREE
)
5795 /* Update the new parameters, too; they'll be used as the
5796 parameters for any members. */
5797 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5799 /* Give each template template parm in this redeclaration a
5800 DECL_CONTEXT of the template for which they are a parameter. */
5801 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5803 gcc_assert (DECL_CONTEXT (parm
) == NULL_TREE
);
5804 DECL_CONTEXT (parm
) = tmpl
;
5807 if (TREE_CODE (parm
) == TYPE_DECL
)
5808 TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (parm
)) = true;
5811 // Cannot redeclare a class template with a different set of constraints.
5812 if (!equivalent_constraints (get_constraints (tmpl
), cons
))
5814 error_at (input_location
, "redeclaration %q#D with different "
5815 "constraints", tmpl
);
5816 inform (DECL_SOURCE_LOCATION (tmpl
),
5817 "original declaration appeared here");
5823 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5824 to be used when the caller has already checked
5825 (processing_template_decl
5826 && !instantiation_dependent_expression_p (expr)
5827 && potential_constant_expression (expr))
5828 and cleared processing_template_decl. */
5831 instantiate_non_dependent_expr_internal (tree expr
, tsubst_flags_t complain
)
5833 return tsubst_copy_and_build (expr
,
5836 /*in_decl=*/NULL_TREE
,
5837 /*function_p=*/false,
5838 /*integral_constant_expression_p=*/true);
5841 /* Simplify EXPR if it is a non-dependent expression. Returns the
5842 (possibly simplified) expression. */
5845 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5847 if (expr
== NULL_TREE
)
5850 /* If we're in a template, but EXPR isn't value dependent, simplify
5851 it. We're supposed to treat:
5853 template <typename T> void f(T[1 + 1]);
5854 template <typename T> void f(T[2]);
5856 as two declarations of the same function, for example. */
5857 if (processing_template_decl
5858 && is_nondependent_constant_expression (expr
))
5860 processing_template_decl_sentinel s
;
5861 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
5867 instantiate_non_dependent_expr (tree expr
)
5869 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
5872 /* Like instantiate_non_dependent_expr, but return NULL_TREE rather than
5873 an uninstantiated expression. */
5876 instantiate_non_dependent_or_null (tree expr
)
5878 if (expr
== NULL_TREE
)
5880 if (processing_template_decl
)
5882 if (!is_nondependent_constant_expression (expr
))
5886 processing_template_decl_sentinel s
;
5887 expr
= instantiate_non_dependent_expr_internal (expr
, tf_error
);
5893 /* True iff T is a specialization of a variable template. */
5896 variable_template_specialization_p (tree t
)
5898 if (!VAR_P (t
) || !DECL_LANG_SPECIFIC (t
) || !DECL_TEMPLATE_INFO (t
))
5900 tree tmpl
= DECL_TI_TEMPLATE (t
);
5901 return variable_template_p (tmpl
);
5904 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5905 template declaration, or a TYPE_DECL for an alias declaration. */
5908 alias_type_or_template_p (tree t
)
5912 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5915 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5916 || DECL_ALIAS_TEMPLATE_P (t
));
5919 /* Return TRUE iff T is a specialization of an alias template. */
5922 alias_template_specialization_p (const_tree t
)
5924 /* It's an alias template specialization if it's an alias and its
5925 TYPE_NAME is a specialization of a primary template. */
5926 if (TYPE_ALIAS_P (t
))
5927 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
5928 return PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
));
5933 /* An alias template is complex from a SFINAE perspective if a template-id
5934 using that alias can be ill-formed when the expansion is not, as with
5935 the void_t template. We determine this by checking whether the
5936 expansion for the alias template uses all its template parameters. */
5938 struct uses_all_template_parms_data
5945 uses_all_template_parms_r (tree t
, void *data_
)
5947 struct uses_all_template_parms_data
&data
5948 = *(struct uses_all_template_parms_data
*)data_
;
5949 tree idx
= get_template_parm_index (t
);
5951 if (TEMPLATE_PARM_LEVEL (idx
) == data
.level
)
5952 data
.seen
[TEMPLATE_PARM_IDX (idx
)] = true;
5957 complex_alias_template_p (const_tree tmpl
)
5959 struct uses_all_template_parms_data data
;
5960 tree pat
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5961 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5962 data
.level
= TMPL_PARMS_DEPTH (parms
);
5963 int len
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms
));
5964 data
.seen
= XALLOCAVEC (bool, len
);
5965 for (int i
= 0; i
< len
; ++i
)
5966 data
.seen
[i
] = false;
5968 for_each_template_parm (pat
, uses_all_template_parms_r
, &data
, NULL
, true);
5969 for (int i
= 0; i
< len
; ++i
)
5975 /* Return TRUE iff T is a specialization of a complex alias template with
5976 dependent template-arguments. */
5979 dependent_alias_template_spec_p (const_tree t
)
5981 if (!alias_template_specialization_p (t
))
5984 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
);
5985 if (!TEMPLATE_DECL_COMPLEX_ALIAS_P (TI_TEMPLATE (tinfo
)))
5988 tree args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
));
5989 if (!any_dependent_template_arguments_p (args
))
5995 /* Return the number of innermost template parameters in TMPL. */
5998 num_innermost_template_parms (tree tmpl
)
6000 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
6001 return TREE_VEC_LENGTH (parms
);
6004 /* Return either TMPL or another template that it is equivalent to under DR
6005 1286: An alias that just changes the name of a template is equivalent to
6006 the other template. */
6009 get_underlying_template (tree tmpl
)
6011 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
6012 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
6014 /* Determine if the alias is equivalent to an underlying template. */
6015 tree orig_type
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
6016 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (orig_type
);
6020 tree underlying
= TI_TEMPLATE (tinfo
);
6021 if (!PRIMARY_TEMPLATE_P (underlying
)
6022 || (num_innermost_template_parms (tmpl
)
6023 != num_innermost_template_parms (underlying
)))
6026 tree alias_args
= INNERMOST_TEMPLATE_ARGS
6027 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
6028 if (!comp_template_args (TI_ARGS (tinfo
), alias_args
))
6031 /* Alias is equivalent. Strip it and repeat. */
6038 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
6039 must be a reference-to-function or a pointer-to-function type, as specified
6040 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
6041 and check that the resulting function has external linkage. */
6044 convert_nontype_argument_function (tree type
, tree expr
,
6045 tsubst_flags_t complain
)
6049 linkage_kind linkage
;
6051 fn
= instantiate_type (type
, fns
, tf_none
);
6052 if (fn
== error_mark_node
)
6053 return error_mark_node
;
6055 if (value_dependent_expression_p (fn
))
6058 fn_no_ptr
= strip_fnptr_conv (fn
);
6059 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
6060 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
6061 if (BASELINK_P (fn_no_ptr
))
6062 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
6064 /* [temp.arg.nontype]/1
6066 A template-argument for a non-type, non-template template-parameter
6069 -- the address of an object or function with external [C++11: or
6070 internal] linkage. */
6072 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
6074 if (complain
& tf_error
)
6076 error ("%qE is not a valid template argument for type %qT",
6078 if (TYPE_PTR_P (type
))
6079 inform (input_location
, "it must be the address of a function "
6080 "with external linkage");
6082 inform (input_location
, "it must be the name of a function with "
6083 "external linkage");
6088 linkage
= decl_linkage (fn_no_ptr
);
6089 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
6091 if (complain
& tf_error
)
6093 if (cxx_dialect
>= cxx11
)
6094 error ("%qE is not a valid template argument for type %qT "
6095 "because %qD has no linkage",
6096 expr
, type
, fn_no_ptr
);
6098 error ("%qE is not a valid template argument for type %qT "
6099 "because %qD does not have external linkage",
6100 expr
, type
, fn_no_ptr
);
6106 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6107 fn
= build_address (fn
);
6108 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (fn
)))
6109 fn
= build_nop (type
, fn
);
6114 /* Subroutine of convert_nontype_argument.
6115 Check if EXPR of type TYPE is a valid pointer-to-member constant.
6116 Emit an error otherwise. */
6119 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
6120 tsubst_flags_t complain
)
6122 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6123 tree orig_expr
= expr
;
6125 if (null_ptr_cst_p (expr
))
6127 if (TREE_CODE (expr
) == PTRMEM_CST
6128 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
6129 PTRMEM_CST_CLASS (expr
)))
6131 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
6133 if (processing_template_decl
6134 && TREE_CODE (expr
) == ADDR_EXPR
6135 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
6137 if (complain
& tf_error
)
6139 error_at (loc
, "%qE is not a valid template argument for type %qT",
6141 if (TREE_CODE (expr
) != PTRMEM_CST
)
6142 inform (loc
, "it must be a pointer-to-member of the form %<&X::Y%>");
6144 inform (loc
, "because it is a member of %qT", PTRMEM_CST_CLASS (expr
));
6149 /* Returns TRUE iff the address of OP is value-dependent.
6151 14.6.2.4 [temp.dep.temp]:
6152 A non-integral non-type template-argument is dependent if its type is
6153 dependent or it has either of the following forms
6156 and contains a nested-name-specifier which specifies a class-name that
6157 names a dependent type.
6159 We generalize this to just say that the address of a member of a
6160 dependent class is value-dependent; the above doesn't cover the
6161 address of a static data member named with an unqualified-id. */
6164 has_value_dependent_address (tree op
)
6166 /* We could use get_inner_reference here, but there's no need;
6167 this is only relevant for template non-type arguments, which
6168 can only be expressed as &id-expression. */
6171 tree ctx
= CP_DECL_CONTEXT (op
);
6172 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
6179 /* The next set of functions are used for providing helpful explanatory
6180 diagnostics for failed overload resolution. Their messages should be
6181 indented by two spaces for consistency with the messages in
6185 unify_success (bool /*explain_p*/)
6190 /* Other failure functions should call this one, to provide a single function
6191 for setting a breakpoint on. */
6194 unify_invalid (bool /*explain_p*/)
6200 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
6203 inform (input_location
,
6204 " couldn't deduce template parameter %qD", parm
);
6205 return unify_invalid (explain_p
);
6209 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
6212 inform (input_location
,
6213 " types %qT and %qT have incompatible cv-qualifiers",
6215 return unify_invalid (explain_p
);
6219 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
6222 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
6223 return unify_invalid (explain_p
);
6227 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
6230 inform (input_location
,
6231 " template parameter %qD is not a parameter pack, but "
6234 return unify_invalid (explain_p
);
6238 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
6241 inform (input_location
,
6242 " template argument %qE does not match "
6243 "pointer-to-member constant %qE",
6245 return unify_invalid (explain_p
);
6249 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
6252 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
6253 return unify_invalid (explain_p
);
6257 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
6260 inform (input_location
,
6261 " inconsistent parameter pack deduction with %qT and %qT",
6263 return unify_invalid (explain_p
);
6267 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
6272 inform (input_location
,
6273 " deduced conflicting types for parameter %qT (%qT and %qT)",
6274 parm
, first
, second
);
6276 inform (input_location
,
6277 " deduced conflicting values for non-type parameter "
6278 "%qE (%qE and %qE)", parm
, first
, second
);
6280 return unify_invalid (explain_p
);
6284 unify_vla_arg (bool explain_p
, tree arg
)
6287 inform (input_location
,
6288 " variable-sized array type %qT is not "
6289 "a valid template argument",
6291 return unify_invalid (explain_p
);
6295 unify_method_type_error (bool explain_p
, tree arg
)
6298 inform (input_location
,
6299 " member function type %qT is not a valid template argument",
6301 return unify_invalid (explain_p
);
6305 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
6310 inform_n (input_location
, wanted
,
6311 " candidate expects at least %d argument, %d provided",
6312 " candidate expects at least %d arguments, %d provided",
6315 inform_n (input_location
, wanted
,
6316 " candidate expects %d argument, %d provided",
6317 " candidate expects %d arguments, %d provided",
6320 return unify_invalid (explain_p
);
6324 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
6326 return unify_arity (explain_p
, have
, wanted
);
6330 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
6331 bool least_p
= false)
6333 return unify_arity (explain_p
, have
, wanted
, least_p
);
6337 unify_arg_conversion (bool explain_p
, tree to_type
,
6338 tree from_type
, tree arg
)
6341 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
6342 " cannot convert %qE (type %qT) to type %qT",
6343 arg
, from_type
, to_type
);
6344 return unify_invalid (explain_p
);
6348 unify_no_common_base (bool explain_p
, enum template_base_result r
,
6349 tree parm
, tree arg
)
6354 case tbr_ambiguous_baseclass
:
6355 inform (input_location
, " %qT is an ambiguous base class of %qT",
6359 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
6362 return unify_invalid (explain_p
);
6366 unify_inconsistent_template_template_parameters (bool explain_p
)
6369 inform (input_location
,
6370 " template parameters of a template template argument are "
6371 "inconsistent with other deduced template arguments");
6372 return unify_invalid (explain_p
);
6376 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
6379 inform (input_location
,
6380 " can't deduce a template for %qT from non-template type %qT",
6382 return unify_invalid (explain_p
);
6386 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
6389 inform (input_location
,
6390 " template argument %qE does not match %qE", arg
, parm
);
6391 return unify_invalid (explain_p
);
6394 /* Attempt to convert the non-type template parameter EXPR to the
6395 indicated TYPE. If the conversion is successful, return the
6396 converted value. If the conversion is unsuccessful, return
6397 NULL_TREE if we issued an error message, or error_mark_node if we
6398 did not. We issue error messages for out-and-out bad template
6399 parameters, but not simply because the conversion failed, since we
6400 might be just trying to do argument deduction. Both TYPE and EXPR
6401 must be non-dependent.
6403 The conversion follows the special rules described in
6404 [temp.arg.nontype], and it is much more strict than an implicit
6407 This function is called twice for each template argument (see
6408 lookup_template_class for a more accurate description of this
6409 problem). This means that we need to handle expressions which
6410 are not valid in a C++ source, but can be created from the
6411 first call (for instance, casts to perform conversions). These
6412 hacks can go away after we fix the double coercion problem. */
6415 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
6418 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6419 tree orig_expr
= expr
;
6421 /* Detect immediately string literals as invalid non-type argument.
6422 This special-case is not needed for correctness (we would easily
6423 catch this later), but only to provide better diagnostic for this
6424 common user mistake. As suggested by DR 100, we do not mention
6425 linkage issues in the diagnostic as this is not the point. */
6426 /* FIXME we're making this OK. */
6427 if (TREE_CODE (expr
) == STRING_CST
)
6429 if (complain
& tf_error
)
6430 error ("%qE is not a valid template argument for type %qT "
6431 "because string literals can never be used in this context",
6436 /* Add the ADDR_EXPR now for the benefit of
6437 value_dependent_expression_p. */
6438 if (TYPE_PTROBV_P (type
)
6439 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
6441 expr
= decay_conversion (expr
, complain
);
6442 if (expr
== error_mark_node
)
6443 return error_mark_node
;
6446 /* If we are in a template, EXPR may be non-dependent, but still
6447 have a syntactic, rather than semantic, form. For example, EXPR
6448 might be a SCOPE_REF, rather than the VAR_DECL to which the
6449 SCOPE_REF refers. Preserving the qualifying scope is necessary
6450 so that access checking can be performed when the template is
6451 instantiated -- but here we need the resolved form so that we can
6452 convert the argument. */
6453 bool non_dep
= false;
6454 if (TYPE_REF_OBJ_P (type
)
6455 && has_value_dependent_address (expr
))
6456 /* If we want the address and it's value-dependent, don't fold. */;
6457 else if (processing_template_decl
6458 && is_nondependent_constant_expression (expr
))
6460 if (error_operand_p (expr
))
6461 return error_mark_node
;
6462 expr_type
= TREE_TYPE (expr
);
6464 /* If the argument is non-dependent, perform any conversions in
6465 non-dependent context as well. */
6466 processing_template_decl_sentinel
s (non_dep
);
6468 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6470 if (value_dependent_expression_p (expr
))
6471 expr
= canonicalize_expr_argument (expr
, complain
);
6473 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
6474 to a non-type argument of "nullptr". */
6475 if (NULLPTR_TYPE_P (expr_type
) && TYPE_PTR_OR_PTRMEM_P (type
))
6476 expr
= fold_simple (convert (type
, expr
));
6478 /* In C++11, integral or enumeration non-type template arguments can be
6479 arbitrary constant expressions. Pointer and pointer to
6480 member arguments can be general constant expressions that evaluate
6481 to a null value, but otherwise still need to be of a specific form. */
6482 if (cxx_dialect
>= cxx11
)
6484 if (TREE_CODE (expr
) == PTRMEM_CST
)
6485 /* A PTRMEM_CST is already constant, and a valid template
6486 argument for a parameter of pointer to member type, we just want
6487 to leave it in that form rather than lower it to a
6489 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
6490 || cxx_dialect
>= cxx17
)
6492 /* C++17: A template-argument for a non-type template-parameter shall
6493 be a converted constant expression (8.20) of the type of the
6494 template-parameter. */
6495 expr
= build_converted_constant_expr (type
, expr
, complain
);
6496 if (expr
== error_mark_node
)
6497 return error_mark_node
;
6498 expr
= maybe_constant_value (expr
);
6499 expr
= convert_from_reference (expr
);
6501 else if (TYPE_PTR_OR_PTRMEM_P (type
))
6503 tree folded
= maybe_constant_value (expr
);
6504 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
6505 : null_member_pointer_value_p (folded
))
6510 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6511 expr
= mark_lvalue_use (expr
);
6513 expr
= mark_rvalue_use (expr
);
6515 /* HACK: Due to double coercion, we can get a
6516 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
6517 which is the tree that we built on the first call (see
6518 below when coercing to reference to object or to reference to
6519 function). We just strip everything and get to the arg.
6520 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
6522 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
6524 tree probe_type
, probe
= expr
;
6525 if (REFERENCE_REF_P (probe
))
6526 probe
= TREE_OPERAND (probe
, 0);
6527 probe_type
= TREE_TYPE (probe
);
6528 if (TREE_CODE (probe
) == NOP_EXPR
)
6530 /* ??? Maybe we could use convert_from_reference here, but we
6531 would need to relax its constraints because the NOP_EXPR
6532 could actually change the type to something more cv-qualified,
6533 and this is not folded by convert_from_reference. */
6534 tree addr
= TREE_OPERAND (probe
, 0);
6535 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
6536 && TREE_CODE (addr
) == ADDR_EXPR
6537 && TYPE_PTR_P (TREE_TYPE (addr
))
6538 && (same_type_ignoring_top_level_qualifiers_p
6539 (TREE_TYPE (probe_type
),
6540 TREE_TYPE (TREE_TYPE (addr
)))))
6542 expr
= TREE_OPERAND (addr
, 0);
6543 expr_type
= TREE_TYPE (probe_type
);
6548 /* [temp.arg.nontype]/5, bullet 1
6550 For a non-type template-parameter of integral or enumeration type,
6551 integral promotions (_conv.prom_) and integral conversions
6552 (_conv.integral_) are applied. */
6553 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6555 if (cxx_dialect
< cxx11
)
6557 tree t
= build_converted_constant_expr (type
, expr
, complain
);
6558 t
= maybe_constant_value (t
);
6559 if (t
!= error_mark_node
)
6563 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
6564 return error_mark_node
;
6566 /* Notice that there are constant expressions like '4 % 0' which
6567 do not fold into integer constants. */
6568 if (TREE_CODE (expr
) != INTEGER_CST
6569 && !value_dependent_expression_p (expr
))
6571 if (complain
& tf_error
)
6573 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
6574 if (!require_potential_constant_expression (expr
))
6575 expr
= error_mark_node
;
6577 expr
= cxx_constant_value (expr
);
6578 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
6579 inform (loc
, "in template argument for type %qT ", type
);
6580 if (expr
== error_mark_node
)
6582 /* else cxx_constant_value complained but gave us
6583 a real constant, so go ahead. */
6584 if (TREE_CODE (expr
) != INTEGER_CST
)
6586 /* Some assemble time constant expressions like
6587 (intptr_t)&&lab1 - (intptr_t)&&lab2 or
6588 4 + (intptr_t)&&var satisfy reduced_constant_expression_p
6589 as we can emit them into .rodata initializers of
6590 variables, yet they can't fold into an INTEGER_CST at
6591 compile time. Refuse them here. */
6592 gcc_checking_assert (reduced_constant_expression_p (expr
));
6593 error_at (loc
, "template argument %qE for type %qT not "
6594 "a constant integer", expr
, type
);
6602 /* Avoid typedef problems. */
6603 if (TREE_TYPE (expr
) != type
)
6604 expr
= fold_convert (type
, expr
);
6606 /* [temp.arg.nontype]/5, bullet 2
6608 For a non-type template-parameter of type pointer to object,
6609 qualification conversions (_conv.qual_) and the array-to-pointer
6610 conversion (_conv.array_) are applied. */
6611 else if (TYPE_PTROBV_P (type
))
6613 tree decayed
= expr
;
6615 /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
6616 decay_conversion or an explicit cast. If it's a problematic cast,
6617 we'll complain about it below. */
6618 if (TREE_CODE (expr
) == NOP_EXPR
)
6622 if (TREE_CODE (probe
) == ADDR_EXPR
6623 && TYPE_PTR_P (TREE_TYPE (probe
)))
6626 expr_type
= TREE_TYPE (expr
);
6630 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6632 A template-argument for a non-type, non-template template-parameter
6633 shall be one of: [...]
6635 -- the name of a non-type template-parameter;
6636 -- the address of an object or function with external linkage, [...]
6637 expressed as "& id-expression" where the & is optional if the name
6638 refers to a function or array, or if the corresponding
6639 template-parameter is a reference.
6641 Here, we do not care about functions, as they are invalid anyway
6642 for a parameter of type pointer-to-object. */
6644 if (value_dependent_expression_p (expr
))
6645 /* Non-type template parameters are OK. */
6647 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6648 /* Null pointer values are OK in C++11. */;
6649 else if (TREE_CODE (expr
) != ADDR_EXPR
)
6653 if (complain
& tf_error
)
6654 error ("%qD is not a valid template argument "
6655 "because %qD is a variable, not the address of "
6656 "a variable", orig_expr
, expr
);
6659 if (POINTER_TYPE_P (expr_type
))
6661 if (complain
& tf_error
)
6662 error ("%qE is not a valid template argument for %qT "
6663 "because it is not the address of a variable",
6667 /* Other values, like integer constants, might be valid
6668 non-type arguments of some other type. */
6669 return error_mark_node
;
6673 tree decl
= TREE_OPERAND (expr
, 0);
6677 if (complain
& tf_error
)
6678 error ("%qE is not a valid template argument of type %qT "
6679 "because %qE is not a variable", orig_expr
, type
, decl
);
6682 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
6684 if (complain
& tf_error
)
6685 error ("%qE is not a valid template argument of type %qT "
6686 "because %qD does not have external linkage",
6687 orig_expr
, type
, decl
);
6690 else if ((cxx_dialect
>= cxx11
&& cxx_dialect
< cxx17
)
6691 && decl_linkage (decl
) == lk_none
)
6693 if (complain
& tf_error
)
6694 error ("%qE is not a valid template argument of type %qT "
6695 "because %qD has no linkage", orig_expr
, type
, decl
);
6698 /* C++17: For a non-type template-parameter of reference or pointer
6699 type, the value of the constant expression shall not refer to (or
6700 for a pointer type, shall not be the address of):
6701 * a subobject (4.5),
6702 * a temporary object (15.2),
6703 * a string literal (5.13.5),
6704 * the result of a typeid expression (8.2.8), or
6705 * a predefined __func__ variable (11.4.1). */
6706 else if (DECL_ARTIFICIAL (decl
))
6708 if (complain
& tf_error
)
6709 error ("the address of %qD is not a valid template argument",
6713 else if (!same_type_ignoring_top_level_qualifiers_p
6714 (strip_array_types (TREE_TYPE (type
)),
6715 strip_array_types (TREE_TYPE (decl
))))
6717 if (complain
& tf_error
)
6718 error ("the address of the %qT subobject of %qD is not a "
6719 "valid template argument", TREE_TYPE (type
), decl
);
6722 else if (!TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
6724 if (complain
& tf_error
)
6725 error ("the address of %qD is not a valid template argument "
6726 "because it does not have static storage duration",
6734 expr
= perform_qualification_conversions (type
, expr
);
6735 if (expr
== error_mark_node
)
6736 return error_mark_node
;
6738 /* [temp.arg.nontype]/5, bullet 3
6740 For a non-type template-parameter of type reference to object, no
6741 conversions apply. The type referred to by the reference may be more
6742 cv-qualified than the (otherwise identical) type of the
6743 template-argument. The template-parameter is bound directly to the
6744 template-argument, which must be an lvalue. */
6745 else if (TYPE_REF_OBJ_P (type
))
6747 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
6749 return error_mark_node
;
6751 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
6753 if (complain
& tf_error
)
6754 error ("%qE is not a valid template argument for type %qT "
6755 "because of conflicts in cv-qualification", expr
, type
);
6759 if (!lvalue_p (expr
))
6761 if (complain
& tf_error
)
6762 error ("%qE is not a valid template argument for type %qT "
6763 "because it is not an lvalue", expr
, type
);
6767 /* [temp.arg.nontype]/1
6769 A template-argument for a non-type, non-template template-parameter
6770 shall be one of: [...]
6772 -- the address of an object or function with external linkage. */
6773 if (INDIRECT_REF_P (expr
)
6774 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
6776 expr
= TREE_OPERAND (expr
, 0);
6779 if (complain
& tf_error
)
6780 error ("%q#D is not a valid template argument for type %qT "
6781 "because a reference variable does not have a constant "
6782 "address", expr
, type
);
6787 if (TYPE_REF_OBJ_P (TREE_TYPE (expr
))
6788 && value_dependent_expression_p (expr
))
6789 /* OK, dependent reference. We don't want to ask whether a DECL is
6790 itself value-dependent, since what we want here is its address. */;
6795 if (complain
& tf_error
)
6796 error ("%qE is not a valid template argument for type %qT "
6797 "because it is not an object with linkage",
6802 /* DR 1155 allows internal linkage in C++11 and up. */
6803 linkage_kind linkage
= decl_linkage (expr
);
6804 if (linkage
< (cxx_dialect
>= cxx11
? lk_internal
: lk_external
))
6806 if (complain
& tf_error
)
6807 error ("%qE is not a valid template argument for type %qT "
6808 "because object %qD does not have linkage",
6813 expr
= build_address (expr
);
6816 if (!same_type_p (type
, TREE_TYPE (expr
)))
6817 expr
= build_nop (type
, expr
);
6819 /* [temp.arg.nontype]/5, bullet 4
6821 For a non-type template-parameter of type pointer to function, only
6822 the function-to-pointer conversion (_conv.func_) is applied. If the
6823 template-argument represents a set of overloaded functions (or a
6824 pointer to such), the matching function is selected from the set
6826 else if (TYPE_PTRFN_P (type
))
6828 /* If the argument is a template-id, we might not have enough
6829 context information to decay the pointer. */
6830 if (!type_unknown_p (expr_type
))
6832 expr
= decay_conversion (expr
, complain
);
6833 if (expr
== error_mark_node
)
6834 return error_mark_node
;
6837 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6838 /* Null pointer values are OK in C++11. */
6839 return perform_qualification_conversions (type
, expr
);
6841 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6842 if (!expr
|| expr
== error_mark_node
)
6845 /* [temp.arg.nontype]/5, bullet 5
6847 For a non-type template-parameter of type reference to function, no
6848 conversions apply. If the template-argument represents a set of
6849 overloaded functions, the matching function is selected from the set
6851 else if (TYPE_REFFN_P (type
))
6853 if (TREE_CODE (expr
) == ADDR_EXPR
)
6855 if (complain
& tf_error
)
6857 error ("%qE is not a valid template argument for type %qT "
6858 "because it is a pointer", expr
, type
);
6859 inform (input_location
, "try using %qE instead",
6860 TREE_OPERAND (expr
, 0));
6865 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6866 if (!expr
|| expr
== error_mark_node
)
6869 /* [temp.arg.nontype]/5, bullet 6
6871 For a non-type template-parameter of type pointer to member function,
6872 no conversions apply. If the template-argument represents a set of
6873 overloaded member functions, the matching member function is selected
6874 from the set (_over.over_). */
6875 else if (TYPE_PTRMEMFUNC_P (type
))
6877 expr
= instantiate_type (type
, expr
, tf_none
);
6878 if (expr
== error_mark_node
)
6879 return error_mark_node
;
6881 /* [temp.arg.nontype] bullet 1 says the pointer to member
6882 expression must be a pointer-to-member constant. */
6883 if (!value_dependent_expression_p (expr
)
6884 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6887 /* Repeated conversion can't deal with a conversion that turns PTRMEM_CST
6888 into a CONSTRUCTOR, so build up a new PTRMEM_CST instead. */
6889 if (fnptr_conv_p (type
, TREE_TYPE (expr
)))
6890 expr
= make_ptrmem_cst (type
, PTRMEM_CST_MEMBER (expr
));
6892 /* [temp.arg.nontype]/5, bullet 7
6894 For a non-type template-parameter of type pointer to data member,
6895 qualification conversions (_conv.qual_) are applied. */
6896 else if (TYPE_PTRDATAMEM_P (type
))
6898 /* [temp.arg.nontype] bullet 1 says the pointer to member
6899 expression must be a pointer-to-member constant. */
6900 if (!value_dependent_expression_p (expr
)
6901 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6904 expr
= perform_qualification_conversions (type
, expr
);
6905 if (expr
== error_mark_node
)
6908 else if (NULLPTR_TYPE_P (type
))
6910 if (!NULLPTR_TYPE_P (TREE_TYPE (expr
)))
6912 if (complain
& tf_error
)
6913 error ("%qE is not a valid template argument for type %qT "
6914 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6919 /* A template non-type parameter must be one of the above. */
6923 /* Sanity check: did we actually convert the argument to the
6925 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6926 (type
, TREE_TYPE (expr
)));
6927 return convert_from_reference (expr
);
6930 /* Subroutine of coerce_template_template_parms, which returns 1 if
6931 PARM_PARM and ARG_PARM match using the rule for the template
6932 parameters of template template parameters. Both PARM and ARG are
6933 template parameters; the rest of the arguments are the same as for
6934 coerce_template_template_parms.
6937 coerce_template_template_parm (tree parm
,
6939 tsubst_flags_t complain
,
6943 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6944 || parm
== NULL_TREE
|| error_operand_p (parm
))
6947 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6950 switch (TREE_CODE (parm
))
6953 /* We encounter instantiations of templates like
6954 template <template <template <class> class> class TT>
6957 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6958 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6960 if (!coerce_template_template_parms
6961 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6967 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6968 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6969 /* Argument is a parameter pack but parameter is not. */
6974 /* The tsubst call is used to handle cases such as
6976 template <int> class C {};
6977 template <class T, template <T> class TT> class D {};
6980 i.e. the parameter list of TT depends on earlier parameters. */
6981 if (!uses_template_parms (TREE_TYPE (arg
)))
6983 tree t
= tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
);
6984 if (!uses_template_parms (t
)
6985 && !same_type_p (t
, TREE_TYPE (arg
)))
6989 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6990 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6991 /* Argument is a parameter pack but parameter is not. */
7003 /* Coerce template argument list ARGLIST for use with template
7004 template-parameter TEMPL. */
7007 coerce_template_args_for_ttp (tree templ
, tree arglist
,
7008 tsubst_flags_t complain
)
7010 /* Consider an example where a template template parameter declared as
7012 template <class T, class U = std::allocator<T> > class TT
7014 The template parameter level of T and U are one level larger than
7015 of TT. To proper process the default argument of U, say when an
7016 instantiation `TT<int>' is seen, we need to build the full
7017 arguments containing {int} as the innermost level. Outer levels,
7018 available when not appearing as default template argument, can be
7019 obtained from the arguments of the enclosing template.
7021 Suppose that TT is later substituted with std::vector. The above
7022 instantiation is `TT<int, std::allocator<T> >' with TT at
7023 level 1, and T at level 2, while the template arguments at level 1
7024 becomes {std::vector} and the inner level 2 is {int}. */
7026 tree outer
= DECL_CONTEXT (templ
);
7029 if (DECL_TEMPLATE_SPECIALIZATION (outer
))
7030 /* We want arguments for the partial specialization, not arguments for
7031 the primary template. */
7032 outer
= template_parms_to_args (DECL_TEMPLATE_PARMS (outer
));
7034 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7036 else if (current_template_parms
)
7038 /* This is an argument of the current template, so we haven't set
7039 DECL_CONTEXT yet. */
7040 tree relevant_template_parms
;
7042 /* Parameter levels that are greater than the level of the given
7043 template template parm are irrelevant. */
7044 relevant_template_parms
= current_template_parms
;
7045 while (TMPL_PARMS_DEPTH (relevant_template_parms
)
7046 != TEMPLATE_TYPE_LEVEL (TREE_TYPE (templ
)))
7047 relevant_template_parms
= TREE_CHAIN (relevant_template_parms
);
7049 outer
= template_parms_to_args (relevant_template_parms
);
7053 arglist
= add_to_template_args (outer
, arglist
);
7055 tree parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7056 return coerce_template_parms (parmlist
, arglist
, templ
,
7058 /*require_all_args=*/true,
7059 /*use_default_args=*/true);
7062 /* A cache of template template parameters with match-all default
7064 static GTY((deletable
)) hash_map
<tree
,tree
> *defaulted_ttp_cache
;
7066 store_defaulted_ttp (tree v
, tree t
)
7068 if (!defaulted_ttp_cache
)
7069 defaulted_ttp_cache
= hash_map
<tree
,tree
>::create_ggc (13);
7070 defaulted_ttp_cache
->put (v
, t
);
7073 lookup_defaulted_ttp (tree v
)
7075 if (defaulted_ttp_cache
)
7076 if (tree
*p
= defaulted_ttp_cache
->get (v
))
7081 /* T is a bound template template-parameter. Copy its arguments into default
7082 arguments of the template template-parameter's template parameters. */
7085 add_defaults_to_ttp (tree otmpl
)
7087 if (tree c
= lookup_defaulted_ttp (otmpl
))
7090 tree ntmpl
= copy_node (otmpl
);
7092 tree ntype
= copy_node (TREE_TYPE (otmpl
));
7093 TYPE_STUB_DECL (ntype
) = TYPE_NAME (ntype
) = ntmpl
;
7094 TYPE_MAIN_VARIANT (ntype
) = ntype
;
7095 TYPE_POINTER_TO (ntype
) = TYPE_REFERENCE_TO (ntype
) = NULL_TREE
;
7096 TYPE_NAME (ntype
) = ntmpl
;
7097 SET_TYPE_STRUCTURAL_EQUALITY (ntype
);
7099 tree idx
= TEMPLATE_TYPE_PARM_INDEX (ntype
)
7100 = copy_node (TEMPLATE_TYPE_PARM_INDEX (ntype
));
7101 TEMPLATE_PARM_DECL (idx
) = ntmpl
;
7102 TREE_TYPE (ntmpl
) = TREE_TYPE (idx
) = ntype
;
7104 tree oparms
= DECL_TEMPLATE_PARMS (otmpl
);
7105 tree parms
= DECL_TEMPLATE_PARMS (ntmpl
) = copy_node (oparms
);
7106 TREE_CHAIN (parms
) = TREE_CHAIN (oparms
);
7107 tree vec
= TREE_VALUE (parms
) = copy_node (TREE_VALUE (parms
));
7108 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
7110 tree o
= TREE_VEC_ELT (vec
, i
);
7111 if (!template_parameter_pack_p (TREE_VALUE (o
)))
7113 tree n
= TREE_VEC_ELT (vec
, i
) = copy_node (o
);
7114 TREE_PURPOSE (n
) = any_targ_node
;
7118 store_defaulted_ttp (otmpl
, ntmpl
);
7122 /* ARG is a bound potential template template-argument, and PARGS is a list
7123 of arguments for the corresponding template template-parameter. Adjust
7124 PARGS as appropriate for application to ARG's template, and if ARG is a
7125 BOUND_TEMPLATE_TEMPLATE_PARM, possibly adjust it to add default template
7126 arguments to the template template parameter. */
7129 coerce_ttp_args_for_tta (tree
& arg
, tree pargs
, tsubst_flags_t complain
)
7131 ++processing_template_decl
;
7132 tree arg_tmpl
= TYPE_TI_TEMPLATE (arg
);
7133 if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg_tmpl
))
7135 /* When comparing two template template-parameters in partial ordering,
7136 rewrite the one currently being used as an argument to have default
7137 arguments for all parameters. */
7138 arg_tmpl
= add_defaults_to_ttp (arg_tmpl
);
7139 pargs
= coerce_template_args_for_ttp (arg_tmpl
, pargs
, complain
);
7140 if (pargs
!= error_mark_node
)
7141 arg
= bind_template_template_parm (TREE_TYPE (arg_tmpl
),
7142 TYPE_TI_ARGS (arg
));
7147 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (arg_tmpl
));
7148 pargs
= coerce_template_parms (aparms
, pargs
, arg_tmpl
, complain
,
7149 /*require_all*/true,
7150 /*use_default*/true);
7152 --processing_template_decl
;
7156 /* Subroutine of unify for the case when PARM is a
7157 BOUND_TEMPLATE_TEMPLATE_PARM. */
7160 unify_bound_ttp_args (tree tparms
, tree targs
, tree parm
, tree
& arg
,
7163 tree parmvec
= TYPE_TI_ARGS (parm
);
7164 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
7166 /* The template template parm might be variadic and the argument
7167 not, so flatten both argument lists. */
7168 parmvec
= expand_template_argument_pack (parmvec
);
7169 argvec
= expand_template_argument_pack (argvec
);
7173 /* In keeping with P0522R0, adjust P's template arguments
7174 to apply to A's template; then flatten it again. */
7175 tree nparmvec
= parmvec
;
7176 nparmvec
= coerce_ttp_args_for_tta (arg
, parmvec
, tf_none
);
7177 nparmvec
= expand_template_argument_pack (nparmvec
);
7179 if (unify (tparms
, targs
, nparmvec
, argvec
,
7180 UNIFY_ALLOW_NONE
, explain_p
))
7183 /* If the P0522 adjustment eliminated a pack expansion, deduce
7186 && TREE_VEC_LENGTH (nparmvec
) < TREE_VEC_LENGTH (parmvec
)
7187 && unify_pack_expansion (tparms
, targs
, parmvec
, argvec
,
7188 DEDUCE_EXACT
, /*sub*/true, explain_p
))
7193 /* Deduce arguments T, i from TT<T> or TT<i>.
7194 We check each element of PARMVEC and ARGVEC individually
7195 rather than the whole TREE_VEC since they can have
7196 different number of elements, which is allowed under N2555. */
7198 int len
= TREE_VEC_LENGTH (parmvec
);
7200 /* Check if the parameters end in a pack, making them
7202 int parm_variadic_p
= 0;
7204 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
7205 parm_variadic_p
= 1;
7207 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7208 /* If the template argument list of P contains a pack
7209 expansion that is not the last template argument, the
7210 entire template argument list is a non-deduced
7212 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
7213 return unify_success (explain_p
);
7215 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
7216 return unify_too_few_arguments (explain_p
,
7217 TREE_VEC_LENGTH (argvec
), len
);
7219 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7220 if (unify (tparms
, targs
,
7221 TREE_VEC_ELT (parmvec
, i
),
7222 TREE_VEC_ELT (argvec
, i
),
7223 UNIFY_ALLOW_NONE
, explain_p
))
7227 && unify_pack_expansion (tparms
, targs
,
7230 /*subr=*/true, explain_p
))
7237 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
7238 template template parameters. Both PARM_PARMS and ARG_PARMS are
7239 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
7242 Consider the example:
7243 template <class T> class A;
7244 template<template <class U> class TT> class B;
7246 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
7247 the parameters to A, and OUTER_ARGS contains A. */
7250 coerce_template_template_parms (tree parm_parms
,
7252 tsubst_flags_t complain
,
7256 int nparms
, nargs
, i
;
7260 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
7261 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
7263 nparms
= TREE_VEC_LENGTH (parm_parms
);
7264 nargs
= TREE_VEC_LENGTH (arg_parms
);
7268 /* P0522R0: A template template-parameter P is at least as specialized as
7269 a template template-argument A if, given the following rewrite to two
7270 function templates, the function template corresponding to P is at
7271 least as specialized as the function template corresponding to A
7272 according to the partial ordering rules for function templates
7273 ([temp.func.order]). Given an invented class template X with the
7274 template parameter list of A (including default arguments):
7276 * Each of the two function templates has the same template parameters,
7277 respectively, as P or A.
7279 * Each function template has a single function parameter whose type is
7280 a specialization of X with template arguments corresponding to the
7281 template parameters from the respective function template where, for
7282 each template parameter PP in the template parameter list of the
7283 function template, a corresponding template argument AA is formed. If
7284 PP declares a parameter pack, then AA is the pack expansion
7285 PP... ([temp.variadic]); otherwise, AA is the id-expression PP.
7287 If the rewrite produces an invalid type, then P is not at least as
7288 specialized as A. */
7290 /* So coerce P's args to apply to A's parms, and then deduce between A's
7291 args and the converted args. If that succeeds, A is at least as
7292 specialized as P, so they match.*/
7293 tree pargs
= template_parms_level_to_args (parm_parms
);
7294 ++processing_template_decl
;
7295 pargs
= coerce_template_parms (arg_parms
, pargs
, NULL_TREE
, tf_none
,
7296 /*require_all*/true, /*use_default*/true);
7297 --processing_template_decl
;
7298 if (pargs
!= error_mark_node
)
7300 tree targs
= make_tree_vec (nargs
);
7301 tree aargs
= template_parms_level_to_args (arg_parms
);
7302 if (!unify (arg_parms
, targs
, aargs
, pargs
, UNIFY_ALLOW_NONE
,
7308 /* Determine whether we have a parameter pack at the end of the
7309 template template parameter's template parameter list. */
7310 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
7312 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
7314 if (error_operand_p (parm
))
7317 switch (TREE_CODE (parm
))
7321 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
7326 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
7336 && !(variadic_p
&& nargs
>= nparms
- 1))
7339 /* Check all of the template parameters except the parameter pack at
7340 the end (if any). */
7341 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
7343 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
7344 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7347 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7348 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7350 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7358 /* Check each of the template parameters in the template
7359 argument against the template parameter pack at the end of
7360 the template template parameter. */
7361 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
7364 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7366 for (; i
< nargs
; ++i
)
7368 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7371 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7373 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7382 /* Verifies that the deduced template arguments (in TARGS) for the
7383 template template parameters (in TPARMS) represent valid bindings,
7384 by comparing the template parameter list of each template argument
7385 to the template parameter list of its corresponding template
7386 template parameter, in accordance with DR150. This
7387 routine can only be called after all template arguments have been
7388 deduced. It will return TRUE if all of the template template
7389 parameter bindings are okay, FALSE otherwise. */
7391 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
7393 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
7396 /* We're dealing with template parms in this process. */
7397 ++processing_template_decl
;
7399 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
7401 for (i
= 0; i
< ntparms
; ++i
)
7403 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
7404 tree targ
= TREE_VEC_ELT (targs
, i
);
7406 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
7408 tree packed_args
= NULL_TREE
;
7411 if (ARGUMENT_PACK_P (targ
))
7413 /* Look inside the argument pack. */
7414 packed_args
= ARGUMENT_PACK_ARGS (targ
);
7415 len
= TREE_VEC_LENGTH (packed_args
);
7418 for (idx
= 0; idx
< len
; ++idx
)
7420 tree targ_parms
= NULL_TREE
;
7423 /* Extract the next argument from the argument
7425 targ
= TREE_VEC_ELT (packed_args
, idx
);
7427 if (PACK_EXPANSION_P (targ
))
7428 /* Look at the pattern of the pack expansion. */
7429 targ
= PACK_EXPANSION_PATTERN (targ
);
7431 /* Extract the template parameters from the template
7433 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
7434 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
7435 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
7436 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
7438 /* Verify that we can coerce the template template
7439 parameters from the template argument to the template
7440 parameter. This requires an exact match. */
7442 && !coerce_template_template_parms
7443 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
7458 --processing_template_decl
;
7462 /* Since type attributes aren't mangled, we need to strip them from
7463 template type arguments. */
7466 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
7468 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
7470 bool removed_attributes
= false;
7471 tree canon
= strip_typedefs (arg
, &removed_attributes
);
7472 if (removed_attributes
7473 && (complain
& tf_warning
))
7474 warning (OPT_Wignored_attributes
,
7475 "ignoring attributes on template argument %qT", arg
);
7479 /* And from inside dependent non-type arguments like sizeof(Type). */
7482 canonicalize_expr_argument (tree arg
, tsubst_flags_t complain
)
7484 if (!arg
|| arg
== error_mark_node
)
7486 bool removed_attributes
= false;
7487 tree canon
= strip_typedefs_expr (arg
, &removed_attributes
);
7488 if (removed_attributes
7489 && (complain
& tf_warning
))
7490 warning (OPT_Wignored_attributes
,
7491 "ignoring attributes in template argument %qE", arg
);
7495 // A template declaration can be substituted for a constrained
7496 // template template parameter only when the argument is more
7497 // constrained than the parameter.
7499 is_compatible_template_arg (tree parm
, tree arg
)
7501 tree parm_cons
= get_constraints (parm
);
7503 /* For now, allow constrained template template arguments
7504 and unconstrained template template parameters. */
7505 if (parm_cons
== NULL_TREE
)
7508 tree arg_cons
= get_constraints (arg
);
7510 // If the template parameter is constrained, we need to rewrite its
7511 // constraints in terms of the ARG's template parameters. This ensures
7512 // that all of the template parameter types will have the same depth.
7514 // Note that this is only valid when coerce_template_template_parm is
7515 // true for the innermost template parameters of PARM and ARG. In other
7516 // words, because coercion is successful, this conversion will be valid.
7519 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (arg
));
7520 parm_cons
= tsubst_constraint_info (parm_cons
,
7521 INNERMOST_TEMPLATE_ARGS (args
),
7522 tf_none
, NULL_TREE
);
7523 if (parm_cons
== error_mark_node
)
7527 return subsumes (parm_cons
, arg_cons
);
7530 // Convert a placeholder argument into a binding to the original
7531 // parameter. The original parameter is saved as the TREE_TYPE of
7534 convert_wildcard_argument (tree parm
, tree arg
)
7536 TREE_TYPE (arg
) = parm
;
7540 /* We can't fully resolve ARG given as a non-type template argument to TYPE,
7541 because one of them is dependent. But we need to represent the
7542 conversion for the benefit of cp_tree_equal. */
7545 maybe_convert_nontype_argument (tree type
, tree arg
)
7547 /* Auto parms get no conversion. */
7548 if (type_uses_auto (type
))
7550 /* We don't need or want to add this conversion now if we're going to use the
7551 argument for deduction. */
7552 if (value_dependent_expression_p (arg
))
7555 type
= cv_unqualified (type
);
7556 tree argtype
= TREE_TYPE (arg
);
7557 if (same_type_p (type
, argtype
))
7560 arg
= build1 (IMPLICIT_CONV_EXPR
, type
, arg
);
7561 IMPLICIT_CONV_EXPR_NONTYPE_ARG (arg
) = true;
7565 /* Convert the indicated template ARG as necessary to match the
7566 indicated template PARM. Returns the converted ARG, or
7567 error_mark_node if the conversion was unsuccessful. Error and
7568 warning messages are issued under control of COMPLAIN. This
7569 conversion is for the Ith parameter in the parameter list. ARGS is
7570 the full set of template arguments deduced so far. */
7573 convert_template_argument (tree parm
,
7576 tsubst_flags_t complain
,
7582 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
7584 if (parm
== error_mark_node
)
7585 return error_mark_node
;
7587 /* Trivially convert placeholders. */
7588 if (TREE_CODE (arg
) == WILDCARD_DECL
)
7589 return convert_wildcard_argument (parm
, arg
);
7591 if (arg
== any_targ_node
)
7594 if (TREE_CODE (arg
) == TREE_LIST
7595 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
7597 /* The template argument was the name of some
7598 member function. That's usually
7599 invalid, but static members are OK. In any
7600 case, grab the underlying fields/functions
7601 and issue an error later if required. */
7602 orig_arg
= TREE_VALUE (arg
);
7603 TREE_TYPE (arg
) = unknown_type_node
;
7608 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
7609 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
7610 || requires_tmpl_type
);
7612 /* When determining whether an argument pack expansion is a template,
7613 look at the pattern. */
7614 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
7615 arg
= PACK_EXPANSION_PATTERN (arg
);
7617 /* Deal with an injected-class-name used as a template template arg. */
7618 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
7620 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
7621 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7623 if (cxx_dialect
>= cxx11
)
7624 /* OK under DR 1004. */;
7625 else if (complain
& tf_warning_or_error
)
7626 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
7627 " used as template template argument", TYPE_NAME (arg
));
7628 else if (flag_pedantic_errors
)
7636 ((TREE_CODE (arg
) == TEMPLATE_DECL
7637 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
7638 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
7639 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7640 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
7643 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7644 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
7645 arg
= TYPE_STUB_DECL (arg
);
7647 is_type
= TYPE_P (arg
) || is_tmpl_type
;
7649 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
7650 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
7652 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
7654 if (complain
& tf_error
)
7655 error ("invalid use of destructor %qE as a type", orig_arg
);
7656 return error_mark_node
;
7659 permerror (input_location
,
7660 "to refer to a type member of a template parameter, "
7661 "use %<typename %E%>", orig_arg
);
7663 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
7664 TREE_OPERAND (arg
, 1),
7670 if (is_type
!= requires_type
)
7674 if (complain
& tf_error
)
7676 error ("type/value mismatch at argument %d in template "
7677 "parameter list for %qD",
7680 inform (input_location
,
7681 " expected a constant of type %qT, got %qT",
7683 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
7684 else if (requires_tmpl_type
)
7685 inform (input_location
,
7686 " expected a class template, got %qE", orig_arg
);
7688 inform (input_location
,
7689 " expected a type, got %qE", orig_arg
);
7692 return error_mark_node
;
7694 if (is_tmpl_type
^ requires_tmpl_type
)
7696 if (in_decl
&& (complain
& tf_error
))
7698 error ("type/value mismatch at argument %d in template "
7699 "parameter list for %qD",
7702 inform (input_location
,
7703 " expected a type, got %qT", DECL_NAME (arg
));
7705 inform (input_location
,
7706 " expected a class template, got %qT", orig_arg
);
7708 return error_mark_node
;
7711 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
7712 /* We already did the appropriate conversion when packing args. */
7716 if (requires_tmpl_type
)
7718 if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
7719 /* The number of argument required is not known yet.
7720 Just accept it for now. */
7724 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
7727 /* Strip alias templates that are equivalent to another
7729 arg
= get_underlying_template (arg
);
7730 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
7732 if (coerce_template_template_parms (parmparm
, argparm
,
7738 /* TEMPLATE_TEMPLATE_PARM node is preferred over
7740 if (val
!= error_mark_node
)
7742 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
7743 val
= TREE_TYPE (val
);
7744 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
7745 val
= make_pack_expansion (val
, complain
);
7750 if (in_decl
&& (complain
& tf_error
))
7752 error ("type/value mismatch at argument %d in "
7753 "template parameter list for %qD",
7755 inform (input_location
,
7756 " expected a template of type %qD, got %qT",
7760 val
= error_mark_node
;
7763 // Check that the constraints are compatible before allowing the
7765 if (val
!= error_mark_node
)
7766 if (!is_compatible_template_arg (parm
, arg
))
7768 if (in_decl
&& (complain
& tf_error
))
7770 error ("constraint mismatch at argument %d in "
7771 "template parameter list for %qD",
7773 inform (input_location
, " expected %qD but got %qD",
7776 val
= error_mark_node
;
7782 /* We only form one instance of each template specialization.
7783 Therefore, if we use a non-canonical variant (i.e., a
7784 typedef), any future messages referring to the type will use
7785 the typedef, which is confusing if those future uses do not
7786 themselves also use the typedef. */
7788 val
= canonicalize_type_argument (val
, complain
);
7792 tree t
= TREE_TYPE (parm
);
7794 if (tree a
= type_uses_auto (t
))
7796 t
= do_auto_deduction (t
, arg
, a
, complain
, adc_unify
, args
);
7797 if (t
== error_mark_node
)
7798 return error_mark_node
;
7801 t
= tsubst (t
, args
, complain
, in_decl
);
7803 if (invalid_nontype_parm_type_p (t
, complain
))
7804 return error_mark_node
;
7806 if (!type_dependent_expression_p (orig_arg
)
7807 && !uses_template_parms (t
))
7808 /* We used to call digest_init here. However, digest_init
7809 will report errors, which we don't want when complain
7810 is zero. More importantly, digest_init will try too
7811 hard to convert things: for example, `0' should not be
7812 converted to pointer type at this point according to
7813 the standard. Accepting this is not merely an
7814 extension, since deciding whether or not these
7815 conversions can occur is part of determining which
7816 function template to call, or whether a given explicit
7817 argument specification is valid. */
7818 val
= convert_nontype_argument (t
, orig_arg
, complain
);
7821 val
= canonicalize_expr_argument (orig_arg
, complain
);
7822 val
= maybe_convert_nontype_argument (t
, val
);
7826 if (val
== NULL_TREE
)
7827 val
= error_mark_node
;
7828 else if (val
== error_mark_node
&& (complain
& tf_error
))
7829 error ("could not convert template argument %qE from %qT to %qT",
7830 orig_arg
, TREE_TYPE (orig_arg
), t
);
7832 if (INDIRECT_REF_P (val
))
7834 /* Reject template arguments that are references to built-in
7835 functions with no library fallbacks. */
7836 const_tree inner
= TREE_OPERAND (val
, 0);
7837 const_tree innertype
= TREE_TYPE (inner
);
7839 && TREE_CODE (innertype
) == REFERENCE_TYPE
7840 && TREE_CODE (TREE_TYPE (innertype
)) == FUNCTION_TYPE
7841 && 0 < TREE_OPERAND_LENGTH (inner
)
7842 && reject_gcc_builtin (TREE_OPERAND (inner
, 0)))
7843 return error_mark_node
;
7846 if (TREE_CODE (val
) == SCOPE_REF
)
7848 /* Strip typedefs from the SCOPE_REF. */
7849 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
7850 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
7852 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
7853 QUALIFIED_NAME_IS_TEMPLATE (val
));
7860 /* Coerces the remaining template arguments in INNER_ARGS (from
7861 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
7862 Returns the coerced argument pack. PARM_IDX is the position of this
7863 parameter in the template parameter list. ARGS is the original
7864 template argument list. */
7866 coerce_template_parameter_pack (tree parms
,
7874 tsubst_flags_t complain
)
7876 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
7877 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
7880 tree packed_parms
= NULL_TREE
;
7882 if (arg_idx
> nargs
)
7885 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
7887 /* When the template parameter is a non-type template parameter pack
7888 or template template parameter pack whose type or template
7889 parameters use parameter packs, we know exactly how many arguments
7890 we are looking for. Build a vector of the instantiated decls for
7891 these template parameters in PACKED_PARMS. */
7892 /* We can't use make_pack_expansion here because it would interpret a
7893 _DECL as a use rather than a declaration. */
7894 tree decl
= TREE_VALUE (parm
);
7895 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
7896 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
7897 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
7898 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
7900 TREE_VEC_LENGTH (args
)--;
7901 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
7902 TREE_VEC_LENGTH (args
)++;
7904 if (packed_parms
== error_mark_node
)
7905 return error_mark_node
;
7907 /* If we're doing a partial instantiation of a member template,
7908 verify that all of the types used for the non-type
7909 template parameter pack are, in fact, valid for non-type
7910 template parameters. */
7912 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
7914 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
7915 for (j
= 0; j
< len
; ++j
)
7917 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
7918 if (invalid_nontype_parm_type_p (t
, complain
))
7919 return error_mark_node
;
7921 /* We don't know how many args we have yet, just
7922 use the unconverted ones for now. */
7926 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
7928 /* Check if we have a placeholder pack, which indicates we're
7929 in the context of a introduction list. In that case we want
7930 to match this pack to the single placeholder. */
7931 else if (arg_idx
< nargs
7932 && TREE_CODE (TREE_VEC_ELT (inner_args
, arg_idx
)) == WILDCARD_DECL
7933 && WILDCARD_PACK_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
7935 nargs
= arg_idx
+ 1;
7936 packed_args
= make_tree_vec (1);
7939 packed_args
= make_tree_vec (nargs
- arg_idx
);
7941 /* Convert the remaining arguments, which will be a part of the
7942 parameter pack "parm". */
7943 int first_pack_arg
= arg_idx
;
7944 for (; arg_idx
< nargs
; ++arg_idx
)
7946 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
7947 tree actual_parm
= TREE_VALUE (parm
);
7948 int pack_idx
= arg_idx
- first_pack_arg
;
7952 /* Once we've packed as many args as we have types, stop. */
7953 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
7955 else if (PACK_EXPANSION_P (arg
))
7956 /* We don't know how many args we have yet, just
7957 use the unconverted ones for now. */
7960 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
7963 if (arg
== error_mark_node
)
7965 if (complain
& tf_error
)
7966 error ("template argument %d is invalid", arg_idx
+ 1);
7969 arg
= convert_template_argument (actual_parm
,
7970 arg
, new_args
, complain
, parm_idx
,
7972 if (arg
== error_mark_node
)
7974 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
7977 if (arg_idx
- first_pack_arg
< TREE_VEC_LENGTH (packed_args
)
7978 && TREE_VEC_LENGTH (packed_args
) > 0)
7980 if (complain
& tf_error
)
7981 error ("wrong number of template arguments (%d, should be %d)",
7982 arg_idx
- first_pack_arg
, TREE_VEC_LENGTH (packed_args
));
7983 return error_mark_node
;
7986 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
7987 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
7988 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
7991 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
7992 TREE_CONSTANT (argument_pack
) = 1;
7995 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
7997 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
7998 TREE_VEC_LENGTH (packed_args
));
7999 return argument_pack
;
8002 /* Returns the number of pack expansions in the template argument vector
8006 pack_expansion_args_count (tree args
)
8011 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
8013 tree elt
= TREE_VEC_ELT (args
, i
);
8014 if (elt
&& PACK_EXPANSION_P (elt
))
8020 /* Convert all template arguments to their appropriate types, and
8021 return a vector containing the innermost resulting template
8022 arguments. If any error occurs, return error_mark_node. Error and
8023 warning messages are issued under control of COMPLAIN.
8025 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
8026 for arguments not specified in ARGS. Otherwise, if
8027 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
8028 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
8029 USE_DEFAULT_ARGS is false, then all arguments must be specified in
8033 coerce_template_parms (tree parms
,
8036 tsubst_flags_t complain
,
8037 bool require_all_args
,
8038 bool use_default_args
)
8040 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
8041 tree orig_inner_args
;
8044 tree new_inner_args
;
8045 int saved_unevaluated_operand
;
8046 int saved_inhibit_evaluation_warnings
;
8048 /* When used as a boolean value, indicates whether this is a
8049 variadic template parameter list. Since it's an int, we can also
8050 subtract it from nparms to get the number of non-variadic
8053 int variadic_args_p
= 0;
8054 int post_variadic_parms
= 0;
8056 /* Likewise for parameters with default arguments. */
8059 if (args
== error_mark_node
)
8060 return error_mark_node
;
8062 nparms
= TREE_VEC_LENGTH (parms
);
8064 /* Determine if there are any parameter packs or default arguments. */
8065 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
8067 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
8069 ++post_variadic_parms
;
8070 if (template_parameter_pack_p (TREE_VALUE (parm
)))
8072 if (TREE_PURPOSE (parm
))
8076 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
8077 /* If there are no parameters that follow a parameter pack, we need to
8078 expand any argument packs so that we can deduce a parameter pack from
8079 some non-packed args followed by an argument pack, as in variadic85.C.
8080 If there are such parameters, we need to leave argument packs intact
8081 so the arguments are assigned properly. This can happen when dealing
8082 with a nested class inside a partial specialization of a class
8083 template, as in variadic92.C, or when deducing a template parameter pack
8084 from a sub-declarator, as in variadic114.C. */
8085 if (!post_variadic_parms
)
8086 inner_args
= expand_template_argument_pack (inner_args
);
8088 /* Count any pack expansion args. */
8089 variadic_args_p
= pack_expansion_args_count (inner_args
);
8091 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
8092 if ((nargs
- variadic_args_p
> nparms
&& !variadic_p
)
8093 || (nargs
< nparms
- variadic_p
8096 && (!use_default_args
8097 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
8098 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
8100 if (complain
& tf_error
)
8102 if (variadic_p
|| default_p
)
8104 nparms
-= variadic_p
+ default_p
;
8105 error ("wrong number of template arguments "
8106 "(%d, should be at least %d)", nargs
, nparms
);
8109 error ("wrong number of template arguments "
8110 "(%d, should be %d)", nargs
, nparms
);
8113 inform (DECL_SOURCE_LOCATION (in_decl
),
8114 "provided for %qD", in_decl
);
8117 return error_mark_node
;
8119 /* We can't pass a pack expansion to a non-pack parameter of an alias
8120 template (DR 1430). */
8122 && (DECL_ALIAS_TEMPLATE_P (in_decl
)
8123 || concept_template_p (in_decl
))
8125 && nargs
- variadic_args_p
< nparms
- variadic_p
)
8127 if (complain
& tf_error
)
8129 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
8131 tree arg
= TREE_VEC_ELT (inner_args
, i
);
8132 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
8134 if (PACK_EXPANSION_P (arg
)
8135 && !template_parameter_pack_p (parm
))
8137 if (DECL_ALIAS_TEMPLATE_P (in_decl
))
8138 error_at (location_of (arg
),
8139 "pack expansion argument for non-pack parameter "
8140 "%qD of alias template %qD", parm
, in_decl
);
8142 error_at (location_of (arg
),
8143 "pack expansion argument for non-pack parameter "
8144 "%qD of concept %qD", parm
, in_decl
);
8145 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
8152 return error_mark_node
;
8155 /* We need to evaluate the template arguments, even though this
8156 template-id may be nested within a "sizeof". */
8157 saved_unevaluated_operand
= cp_unevaluated_operand
;
8158 cp_unevaluated_operand
= 0;
8159 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
8160 c_inhibit_evaluation_warnings
= 0;
8161 new_inner_args
= make_tree_vec (nparms
);
8162 new_args
= add_outermost_template_args (args
, new_inner_args
);
8163 int pack_adjust
= 0;
8164 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
8169 /* Get the Ith template parameter. */
8170 parm
= TREE_VEC_ELT (parms
, parm_idx
);
8172 if (parm
== error_mark_node
)
8174 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
8178 /* Calculate the next argument. */
8179 if (arg_idx
< nargs
)
8180 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
8184 if (template_parameter_pack_p (TREE_VALUE (parm
))
8185 && !(arg
&& ARGUMENT_PACK_P (arg
)))
8187 /* Some arguments will be placed in the
8188 template parameter pack PARM. */
8189 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
8190 inner_args
, arg_idx
,
8194 if (arg
== NULL_TREE
)
8196 /* We don't know how many args we have yet, just use the
8197 unconverted (and still packed) ones for now. */
8198 new_inner_args
= orig_inner_args
;
8203 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
8205 /* Store this argument. */
8206 if (arg
== error_mark_node
)
8209 /* We are done with all of the arguments. */
8214 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
8215 arg_idx
+= pack_adjust
;
8222 if (PACK_EXPANSION_P (arg
))
8224 /* "If every valid specialization of a variadic template
8225 requires an empty template parameter pack, the template is
8226 ill-formed, no diagnostic required." So check that the
8227 pattern works with this parameter. */
8228 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
8229 tree conv
= convert_template_argument (TREE_VALUE (parm
),
8233 if (conv
== error_mark_node
)
8235 if (complain
& tf_error
)
8236 inform (input_location
, "so any instantiation with a "
8237 "non-empty parameter pack would be ill-formed");
8240 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
8241 /* Recover from missing typename. */
8242 TREE_VEC_ELT (inner_args
, arg_idx
)
8243 = make_pack_expansion (conv
, complain
);
8245 /* We don't know how many args we have yet, just
8246 use the unconverted ones for now. */
8247 new_inner_args
= inner_args
;
8252 else if (require_all_args
)
8254 /* There must be a default arg in this case. */
8255 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
8257 /* The position of the first default template argument,
8258 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
8260 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8261 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8262 arg_idx
- pack_adjust
);
8267 if (arg
== error_mark_node
)
8269 if (complain
& tf_error
)
8270 error ("template argument %d is invalid", arg_idx
+ 1);
8273 /* This only occurs if there was an error in the template
8274 parameter list itself (which we would already have
8275 reported) that we are trying to recover from, e.g., a class
8276 template with a parameter list such as
8277 template<typename..., typename>. */
8280 arg
= convert_template_argument (TREE_VALUE (parm
),
8281 arg
, new_args
, complain
,
8284 if (arg
== error_mark_node
)
8286 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
8288 cp_unevaluated_operand
= saved_unevaluated_operand
;
8289 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
8291 if (variadic_p
&& arg_idx
< nargs
)
8293 if (complain
& tf_error
)
8295 error ("wrong number of template arguments "
8296 "(%d, should be %d)", nargs
, arg_idx
);
8298 error ("provided for %q+D", in_decl
);
8300 return error_mark_node
;
8304 return error_mark_node
;
8306 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8307 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8308 TREE_VEC_LENGTH (new_inner_args
));
8310 return new_inner_args
;
8313 /* Convert all template arguments to their appropriate types, and
8314 return a vector containing the innermost resulting template
8315 arguments. If any error occurs, return error_mark_node. Error and
8316 warning messages are not issued.
8318 Note that no function argument deduction is performed, and default
8319 arguments are used to fill in unspecified arguments. */
8321 coerce_template_parms (tree parms
, tree args
, tree in_decl
)
8323 return coerce_template_parms (parms
, args
, in_decl
, tf_none
, true, true);
8326 /* Convert all template arguments to their appropriate type, and
8327 instantiate default arguments as needed. This returns a vector
8328 containing the innermost resulting template arguments, or
8329 error_mark_node if unsuccessful. */
8331 coerce_template_parms (tree parms
, tree args
, tree in_decl
,
8332 tsubst_flags_t complain
)
8334 return coerce_template_parms (parms
, args
, in_decl
, complain
, true, true);
8337 /* Like coerce_template_parms. If PARMS represents all template
8338 parameters levels, this function returns a vector of vectors
8339 representing all the resulting argument levels. Note that in this
8340 case, only the innermost arguments are coerced because the
8341 outermost ones are supposed to have been coerced already.
8343 Otherwise, if PARMS represents only (the innermost) vector of
8344 parameters, this function returns a vector containing just the
8345 innermost resulting arguments. */
8348 coerce_innermost_template_parms (tree parms
,
8351 tsubst_flags_t complain
,
8352 bool require_all_args
,
8353 bool use_default_args
)
8355 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
8356 int args_depth
= TMPL_ARGS_DEPTH (args
);
8359 if (parms_depth
> 1)
8361 coerced_args
= make_tree_vec (parms_depth
);
8365 for (level
= parms
, cur_depth
= parms_depth
;
8366 parms_depth
> 0 && level
!= NULL_TREE
;
8367 level
= TREE_CHAIN (level
), --cur_depth
)
8370 if (cur_depth
== args_depth
)
8371 l
= coerce_template_parms (TREE_VALUE (level
),
8372 args
, in_decl
, complain
,
8376 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
8378 if (l
== error_mark_node
)
8379 return error_mark_node
;
8381 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
8385 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
8386 args
, in_decl
, complain
,
8389 return coerced_args
;
8392 /* Returns 1 if template args OT and NT are equivalent. */
8395 template_args_equal (tree ot
, tree nt
, bool partial_order
/* = false */)
8399 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
8401 if (nt
== any_targ_node
|| ot
== any_targ_node
)
8404 if (TREE_CODE (nt
) == TREE_VEC
)
8405 /* For member templates */
8406 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
8407 else if (PACK_EXPANSION_P (ot
))
8408 return (PACK_EXPANSION_P (nt
)
8409 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
8410 PACK_EXPANSION_PATTERN (nt
))
8411 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
8412 PACK_EXPANSION_EXTRA_ARGS (nt
)));
8413 else if (ARGUMENT_PACK_P (ot
))
8418 if (!ARGUMENT_PACK_P (nt
))
8421 opack
= ARGUMENT_PACK_ARGS (ot
);
8422 npack
= ARGUMENT_PACK_ARGS (nt
);
8423 len
= TREE_VEC_LENGTH (opack
);
8424 if (TREE_VEC_LENGTH (npack
) != len
)
8426 for (i
= 0; i
< len
; ++i
)
8427 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
8428 TREE_VEC_ELT (npack
, i
)))
8432 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
8434 else if (TYPE_P (nt
))
8438 /* Don't treat an alias template specialization with dependent
8439 arguments as equivalent to its underlying type when used as a
8440 template argument; we need them to be distinct so that we
8441 substitute into the specialization arguments at instantiation
8442 time. And aliases can't be equivalent without being ==, so
8443 we don't need to look any deeper.
8445 During partial ordering, however, we need to treat them normally so
8446 that we can order uses of the same alias with different
8447 cv-qualification (79960). */
8449 && (TYPE_ALIAS_P (nt
) || TYPE_ALIAS_P (ot
)))
8452 return same_type_p (ot
, nt
);
8454 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
8458 /* Try to treat a template non-type argument that has been converted
8459 to the parameter type as equivalent to one that hasn't yet. */
8460 for (enum tree_code code1
= TREE_CODE (ot
);
8461 CONVERT_EXPR_CODE_P (code1
)
8462 || code1
== NON_LVALUE_EXPR
;
8463 code1
= TREE_CODE (ot
))
8464 ot
= TREE_OPERAND (ot
, 0);
8465 for (enum tree_code code2
= TREE_CODE (nt
);
8466 CONVERT_EXPR_CODE_P (code2
)
8467 || code2
== NON_LVALUE_EXPR
;
8468 code2
= TREE_CODE (nt
))
8469 nt
= TREE_OPERAND (nt
, 0);
8471 return cp_tree_equal (ot
, nt
);
8475 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
8476 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
8477 NEWARG_PTR with the offending arguments if they are non-NULL. */
8480 comp_template_args (tree oldargs
, tree newargs
,
8481 tree
*oldarg_ptr
, tree
*newarg_ptr
,
8486 if (oldargs
== newargs
)
8489 if (!oldargs
|| !newargs
)
8492 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
8495 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
8497 tree nt
= TREE_VEC_ELT (newargs
, i
);
8498 tree ot
= TREE_VEC_ELT (oldargs
, i
);
8500 if (! template_args_equal (ot
, nt
, partial_order
))
8502 if (oldarg_ptr
!= NULL
)
8504 if (newarg_ptr
!= NULL
)
8513 comp_template_args_porder (tree oargs
, tree nargs
)
8515 return comp_template_args (oargs
, nargs
, NULL
, NULL
, true);
8519 add_pending_template (tree d
)
8521 tree ti
= (TYPE_P (d
)
8522 ? CLASSTYPE_TEMPLATE_INFO (d
)
8523 : DECL_TEMPLATE_INFO (d
));
8524 struct pending_template
*pt
;
8527 if (TI_PENDING_TEMPLATE_FLAG (ti
))
8530 /* We are called both from instantiate_decl, where we've already had a
8531 tinst_level pushed, and instantiate_template, where we haven't.
8533 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
8536 push_tinst_level (d
);
8538 pt
= ggc_alloc
<pending_template
> ();
8540 pt
->tinst
= current_tinst_level
;
8541 if (last_pending_template
)
8542 last_pending_template
->next
= pt
;
8544 pending_templates
= pt
;
8546 last_pending_template
= pt
;
8548 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
8555 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
8556 ARGLIST. Valid choices for FNS are given in the cp-tree.def
8557 documentation for TEMPLATE_ID_EXPR. */
8560 lookup_template_function (tree fns
, tree arglist
)
8564 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
8565 return error_mark_node
;
8567 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
8569 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
8571 error ("%q#D is not a function template", fns
);
8572 return error_mark_node
;
8575 if (BASELINK_P (fns
))
8577 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
8579 BASELINK_FUNCTIONS (fns
),
8584 type
= TREE_TYPE (fns
);
8585 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
8586 type
= unknown_type_node
;
8588 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
8591 /* Within the scope of a template class S<T>, the name S gets bound
8592 (in build_self_reference) to a TYPE_DECL for the class, not a
8593 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
8594 or one of its enclosing classes, and that type is a template,
8595 return the associated TEMPLATE_DECL. Otherwise, the original
8598 Also handle the case when DECL is a TREE_LIST of ambiguous
8599 injected-class-names from different bases. */
8602 maybe_get_template_decl_from_type_decl (tree decl
)
8604 if (decl
== NULL_TREE
)
8607 /* DR 176: A lookup that finds an injected-class-name (10.2
8608 [class.member.lookup]) can result in an ambiguity in certain cases
8609 (for example, if it is found in more than one base class). If all of
8610 the injected-class-names that are found refer to specializations of
8611 the same class template, and if the name is followed by a
8612 template-argument-list, the reference refers to the class template
8613 itself and not a specialization thereof, and is not ambiguous. */
8614 if (TREE_CODE (decl
) == TREE_LIST
)
8616 tree t
, tmpl
= NULL_TREE
;
8617 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
8619 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
8622 else if (tmpl
!= elt
)
8625 if (tmpl
&& t
== NULL_TREE
)
8631 return (decl
!= NULL_TREE
8632 && DECL_SELF_REFERENCE_P (decl
)
8633 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
8634 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
8637 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
8638 parameters, find the desired type.
8640 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
8642 IN_DECL, if non-NULL, is the template declaration we are trying to
8645 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
8646 the class we are looking up.
8648 Issue error and warning messages under control of COMPLAIN.
8650 If the template class is really a local class in a template
8651 function, then the FUNCTION_CONTEXT is the function in which it is
8654 ??? Note that this function is currently called *twice* for each
8655 template-id: the first time from the parser, while creating the
8656 incomplete type (finish_template_type), and the second type during the
8657 real instantiation (instantiate_template_class). This is surely something
8658 that we want to avoid. It also causes some problems with argument
8659 coercion (see convert_nontype_argument for more information on this). */
8662 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
8663 int entering_scope
, tsubst_flags_t complain
)
8665 tree templ
= NULL_TREE
, parmlist
;
8672 if (identifier_p (d1
))
8674 tree value
= innermost_non_namespace_value (d1
);
8675 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
8680 push_decl_namespace (context
);
8681 templ
= lookup_name (d1
);
8682 templ
= maybe_get_template_decl_from_type_decl (templ
);
8684 pop_decl_namespace ();
8687 context
= DECL_CONTEXT (templ
);
8689 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
8691 tree type
= TREE_TYPE (d1
);
8693 /* If we are declaring a constructor, say A<T>::A<T>, we will get
8694 an implicit typename for the second A. Deal with it. */
8695 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
8696 type
= TREE_TYPE (type
);
8698 if (CLASSTYPE_TEMPLATE_INFO (type
))
8700 templ
= CLASSTYPE_TI_TEMPLATE (type
);
8701 d1
= DECL_NAME (templ
);
8704 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
8705 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
8707 templ
= TYPE_TI_TEMPLATE (d1
);
8708 d1
= DECL_NAME (templ
);
8710 else if (DECL_TYPE_TEMPLATE_P (d1
))
8713 d1
= DECL_NAME (templ
);
8714 context
= DECL_CONTEXT (templ
);
8716 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
8719 d1
= DECL_NAME (templ
);
8722 /* Issue an error message if we didn't find a template. */
8725 if (complain
& tf_error
)
8726 error ("%qT is not a template", d1
);
8727 return error_mark_node
;
8730 if (TREE_CODE (templ
) != TEMPLATE_DECL
8731 /* Make sure it's a user visible template, if it was named by
8733 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
8734 && !PRIMARY_TEMPLATE_P (templ
)))
8736 if (complain
& tf_error
)
8738 error ("non-template type %qT used as a template", d1
);
8740 error ("for template declaration %q+D", in_decl
);
8742 return error_mark_node
;
8745 complain
&= ~tf_user
;
8747 /* An alias that just changes the name of a template is equivalent to the
8748 other template, so if any of the arguments are pack expansions, strip
8749 the alias to avoid problems with a pack expansion passed to a non-pack
8750 alias template parameter (DR 1430). */
8751 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
8752 templ
= get_underlying_template (templ
);
8754 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
8757 tree arglist2
= coerce_template_args_for_ttp (templ
, arglist
, complain
);
8758 if (arglist2
== error_mark_node
8759 || (!uses_template_parms (arglist2
)
8760 && check_instantiated_args (templ
, arglist2
, complain
)))
8761 return error_mark_node
;
8763 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
8768 tree template_type
= TREE_TYPE (templ
);
8771 tree found
= NULL_TREE
;
8774 int is_dependent_type
;
8775 int use_partial_inst_tmpl
= false;
8777 if (template_type
== error_mark_node
)
8778 /* An error occurred while building the template TEMPL, and a
8779 diagnostic has most certainly been emitted for that
8780 already. Let's propagate that error. */
8781 return error_mark_node
;
8783 gen_tmpl
= most_general_template (templ
);
8784 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
8785 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
8786 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
8788 if (arg_depth
== 1 && parm_depth
> 1)
8790 /* We've been given an incomplete set of template arguments.
8793 template <class T> struct S1 {
8794 template <class U> struct S2 {};
8795 template <class U> struct S2<U*> {};
8798 we will be called with an ARGLIST of `U*', but the
8799 TEMPLATE will be `template <class T> template
8800 <class U> struct S1<T>::S2'. We must fill in the missing
8802 tree ti
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (templ
));
8803 arglist
= add_outermost_template_args (TI_ARGS (ti
), arglist
);
8804 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
8807 /* Now we should have enough arguments. */
8808 gcc_assert (parm_depth
== arg_depth
);
8810 /* From here on, we're only interested in the most general
8813 /* Calculate the BOUND_ARGS. These will be the args that are
8814 actually tsubst'd into the definition to create the
8816 arglist
= coerce_innermost_template_parms (parmlist
, arglist
, gen_tmpl
,
8818 /*require_all_args=*/true,
8819 /*use_default_args=*/true);
8821 if (arglist
== error_mark_node
)
8822 /* We were unable to bind the arguments. */
8823 return error_mark_node
;
8825 /* In the scope of a template class, explicit references to the
8826 template class refer to the type of the template, not any
8827 instantiation of it. For example, in:
8829 template <class T> class C { void f(C<T>); }
8831 the `C<T>' is just the same as `C'. Outside of the
8832 class, however, such a reference is an instantiation. */
8834 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
8835 || currently_open_class (template_type
))
8837 tree tinfo
= TYPE_TEMPLATE_INFO (template_type
);
8839 if (tinfo
&& comp_template_args (TI_ARGS (tinfo
), arglist
))
8840 return template_type
;
8843 /* If we already have this specialization, return it. */
8844 elt
.tmpl
= gen_tmpl
;
8846 elt
.spec
= NULL_TREE
;
8847 hash
= spec_hasher::hash (&elt
);
8848 entry
= type_specializations
->find_with_hash (&elt
, hash
);
8853 /* If the the template's constraints are not satisfied,
8854 then we cannot form a valid type.
8856 Note that the check is deferred until after the hash
8857 lookup. This prevents redundant checks on previously
8858 instantiated specializations. */
8859 if (flag_concepts
&& !constraints_satisfied_p (gen_tmpl
, arglist
))
8861 if (complain
& tf_error
)
8863 error ("template constraint failure");
8864 diagnose_constraints (input_location
, gen_tmpl
, arglist
);
8866 return error_mark_node
;
8869 is_dependent_type
= uses_template_parms (arglist
);
8871 /* If the deduced arguments are invalid, then the binding
8873 if (!is_dependent_type
8874 && check_instantiated_args (gen_tmpl
,
8875 INNERMOST_TEMPLATE_ARGS (arglist
),
8877 return error_mark_node
;
8879 if (!is_dependent_type
8880 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
8881 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
8882 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
8884 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
8885 DECL_NAME (gen_tmpl
),
8886 /*tag_scope=*/ts_global
);
8890 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
8892 if (context
== error_mark_node
)
8893 return error_mark_node
;
8896 context
= global_namespace
;
8898 /* Create the type. */
8899 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8901 /* The user referred to a specialization of an alias
8902 template represented by GEN_TMPL.
8904 [temp.alias]/2 says:
8906 When a template-id refers to the specialization of an
8907 alias template, it is equivalent to the associated
8908 type obtained by substitution of its
8909 template-arguments for the template-parameters in the
8910 type-id of the alias template. */
8912 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
8913 /* Note that the call above (by indirectly calling
8914 register_specialization in tsubst_decl) registers the
8915 TYPE_DECL representing the specialization of the alias
8916 template. So next time someone substitutes ARGLIST for
8917 the template parms into the alias template (GEN_TMPL),
8918 she'll get that TYPE_DECL back. */
8920 if (t
== error_mark_node
)
8923 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
8925 if (!is_dependent_type
)
8927 set_current_access_from_decl (TYPE_NAME (template_type
));
8928 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
8929 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
8930 arglist
, complain
, in_decl
),
8931 tsubst_attributes (TYPE_ATTRIBUTES (template_type
),
8932 arglist
, complain
, in_decl
),
8933 SCOPED_ENUM_P (template_type
), NULL
);
8935 if (t
== error_mark_node
)
8940 /* We don't want to call start_enum for this type, since
8941 the values for the enumeration constants may involve
8942 template parameters. And, no one should be interested
8943 in the enumeration constants for such a type. */
8944 t
= cxx_make_type (ENUMERAL_TYPE
);
8945 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
8947 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
8948 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
8949 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
8951 else if (CLASS_TYPE_P (template_type
))
8953 t
= make_class_type (TREE_CODE (template_type
));
8954 CLASSTYPE_DECLARED_CLASS (t
)
8955 = CLASSTYPE_DECLARED_CLASS (template_type
);
8956 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
8958 /* A local class. Make sure the decl gets registered properly. */
8959 if (context
== current_function_decl
)
8960 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
8962 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
8963 /* This instantiation is another name for the primary
8964 template type. Set the TYPE_CANONICAL field
8966 TYPE_CANONICAL (t
) = template_type
;
8967 else if (any_template_arguments_need_structural_equality_p (arglist
))
8968 /* Some of the template arguments require structural
8969 equality testing, so this template class requires
8970 structural equality testing. */
8971 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8976 /* If we called start_enum or pushtag above, this information
8977 will already be set up. */
8980 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
8982 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
8983 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
8984 DECL_SOURCE_LOCATION (type_decl
)
8985 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
8988 type_decl
= TYPE_NAME (t
);
8990 if (CLASS_TYPE_P (template_type
))
8992 TREE_PRIVATE (type_decl
)
8993 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
8994 TREE_PROTECTED (type_decl
)
8995 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
8996 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
8998 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
8999 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
9003 if (OVERLOAD_TYPE_P (t
)
9004 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9006 static const char *tags
[] = {"abi_tag", "may_alias"};
9008 for (unsigned ix
= 0; ix
!= 2; ix
++)
9011 = lookup_attribute (tags
[ix
], TYPE_ATTRIBUTES (template_type
));
9015 = tree_cons (TREE_PURPOSE (attributes
),
9016 TREE_VALUE (attributes
),
9017 TYPE_ATTRIBUTES (t
));
9021 /* Let's consider the explicit specialization of a member
9022 of a class template specialization that is implicitly instantiated,
9027 template<class U> struct M {}; //#0
9032 struct S<int>::M<char> //#1
9036 [temp.expl.spec]/4 says this is valid.
9038 In this case, when we write:
9041 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
9044 When we encounter #1, we want to store the partial instantiation
9045 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
9047 For all cases other than this "explicit specialization of member of a
9048 class template", we just want to store the most general template into
9049 the CLASSTYPE_TI_TEMPLATE of M.
9051 This case of "explicit specialization of member of a class template"
9053 1/ the enclosing class is an instantiation of, and therefore not
9054 the same as, the context of the most general template, and
9055 2/ we aren't looking at the partial instantiation itself, i.e.
9056 the innermost arguments are not the same as the innermost parms of
9057 the most general template.
9059 So it's only when 1/ and 2/ happens that we want to use the partial
9060 instantiation of the member template in lieu of its most general
9063 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
9064 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
9065 /* the enclosing class must be an instantiation... */
9066 && CLASS_TYPE_P (context
)
9067 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
9069 TREE_VEC_LENGTH (arglist
)--;
9070 ++processing_template_decl
;
9071 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (gen_tmpl
));
9072 tree partial_inst_args
=
9073 tsubst (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
)),
9074 arglist
, complain
, NULL_TREE
);
9075 --processing_template_decl
;
9076 TREE_VEC_LENGTH (arglist
)++;
9077 if (partial_inst_args
== error_mark_node
)
9078 return error_mark_node
;
9079 use_partial_inst_tmpl
=
9080 /*...and we must not be looking at the partial instantiation
9082 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
9086 if (!use_partial_inst_tmpl
)
9087 /* This case is easy; there are no member templates involved. */
9091 /* This is a full instantiation of a member template. Find
9092 the partial instantiation of which this is an instance. */
9094 /* Temporarily reduce by one the number of levels in the ARGLIST
9095 so as to avoid comparing the last set of arguments. */
9096 TREE_VEC_LENGTH (arglist
)--;
9097 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
9098 TREE_VEC_LENGTH (arglist
)++;
9099 /* FOUND is either a proper class type, or an alias
9100 template specialization. In the later case, it's a
9101 TYPE_DECL, resulting from the substituting of arguments
9102 for parameters in the TYPE_DECL of the alias template
9103 done earlier. So be careful while getting the template
9105 found
= (TREE_CODE (found
) == TEMPLATE_DECL
9107 : (TREE_CODE (found
) == TYPE_DECL
9108 ? DECL_TI_TEMPLATE (found
)
9109 : CLASSTYPE_TI_TEMPLATE (found
)));
9112 // Build template info for the new specialization.
9113 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
9116 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
9117 entry
= ggc_alloc
<spec_entry
> ();
9121 /* Note this use of the partial instantiation so we can check it
9122 later in maybe_process_partial_specialization. */
9123 DECL_TEMPLATE_INSTANTIATIONS (found
)
9124 = tree_cons (arglist
, t
,
9125 DECL_TEMPLATE_INSTANTIATIONS (found
));
9127 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
9128 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9129 /* Now that the type has been registered on the instantiations
9130 list, we set up the enumerators. Because the enumeration
9131 constants may involve the enumeration type itself, we make
9132 sure to register the type first, and then create the
9133 constants. That way, doing tsubst_expr for the enumeration
9134 constants won't result in recursive calls here; we'll find
9135 the instantiation and exit above. */
9136 tsubst_enum (template_type
, t
, arglist
);
9138 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
9139 /* If the type makes use of template parameters, the
9140 code that generates debugging information will crash. */
9141 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
9143 /* Possibly limit visibility based on template args. */
9144 TREE_PUBLIC (type_decl
) = 1;
9145 determine_visibility (type_decl
);
9147 inherit_targ_abi_tags (t
);
9153 /* Wrapper for lookup_template_class_1. */
9156 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
9157 int entering_scope
, tsubst_flags_t complain
)
9160 timevar_push (TV_TEMPLATE_INST
);
9161 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
9162 entering_scope
, complain
);
9163 timevar_pop (TV_TEMPLATE_INST
);
9167 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
9170 lookup_template_variable (tree templ
, tree arglist
)
9172 /* The type of the expression is NULL_TREE since the template-id could refer
9173 to an explicit or partial specialization. */
9174 tree type
= NULL_TREE
;
9175 if (flag_concepts
&& variable_concept_p (templ
))
9176 /* Except that concepts are always bool. */
9177 type
= boolean_type_node
;
9178 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
9181 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
9184 finish_template_variable (tree var
, tsubst_flags_t complain
)
9186 tree templ
= TREE_OPERAND (var
, 0);
9187 tree arglist
= TREE_OPERAND (var
, 1);
9189 /* We never want to return a VAR_DECL for a variable concept, since they
9190 aren't instantiated. In a template, leave the TEMPLATE_ID_EXPR alone. */
9191 bool concept_p
= flag_concepts
&& variable_concept_p (templ
);
9192 if (concept_p
&& processing_template_decl
)
9195 tree tmpl_args
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ
));
9196 arglist
= add_outermost_template_args (tmpl_args
, arglist
);
9198 templ
= most_general_template (templ
);
9199 tree parms
= DECL_TEMPLATE_PARMS (templ
);
9200 arglist
= coerce_innermost_template_parms (parms
, arglist
, templ
, complain
,
9202 /*use_default*/true);
9204 if (flag_concepts
&& !constraints_satisfied_p (templ
, arglist
))
9206 if (complain
& tf_error
)
9208 error ("use of invalid variable template %qE", var
);
9209 diagnose_constraints (location_of (var
), templ
, arglist
);
9211 return error_mark_node
;
9214 /* If a template-id refers to a specialization of a variable
9215 concept, then the expression is true if and only if the
9216 concept's constraints are satisfied by the given template
9219 NOTE: This is an extension of Concepts Lite TS that
9220 allows constraints to be used in expressions. */
9223 tree decl
= DECL_TEMPLATE_RESULT (templ
);
9224 return evaluate_variable_concept (decl
, arglist
);
9227 return instantiate_template (templ
, arglist
, complain
);
9230 /* Construct a TEMPLATE_ID_EXPR for the given variable template TEMPL having
9231 TARGS template args, and instantiate it if it's not dependent. */
9234 lookup_and_finish_template_variable (tree templ
, tree targs
,
9235 tsubst_flags_t complain
)
9237 templ
= lookup_template_variable (templ
, targs
);
9238 if (!any_dependent_template_arguments_p (targs
))
9240 templ
= finish_template_variable (templ
, complain
);
9244 return convert_from_reference (templ
);
9253 /* True when we should also visit template parameters that occur in
9254 non-deduced contexts. */
9255 bool include_nondeduced_p
;
9256 hash_set
<tree
> *visited
;
9259 /* Called from for_each_template_parm via walk_tree. */
9262 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
9265 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
9266 tree_fn_t fn
= pfd
->fn
;
9267 void *data
= pfd
->data
;
9268 tree result
= NULL_TREE
;
9270 #define WALK_SUBTREE(NODE) \
9273 result = for_each_template_parm (NODE, fn, data, pfd->visited, \
9274 pfd->include_nondeduced_p, \
9276 if (result) goto out; \
9280 if (pfd
->any_fn
&& (*pfd
->any_fn
)(t
, data
))
9284 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
))
9285 WALK_SUBTREE (TYPE_CONTEXT (t
));
9287 switch (TREE_CODE (t
))
9290 if (TYPE_PTRMEMFUNC_P (t
))
9296 if (!TYPE_TEMPLATE_INFO (t
))
9299 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9303 WALK_SUBTREE (TYPE_MIN_VALUE (t
));
9304 WALK_SUBTREE (TYPE_MAX_VALUE (t
));
9308 /* Since we're not going to walk subtrees, we have to do this
9310 WALK_SUBTREE (TYPE_METHOD_BASETYPE (t
));
9314 /* Check the return type. */
9315 WALK_SUBTREE (TREE_TYPE (t
));
9317 /* Check the parameter types. Since default arguments are not
9318 instantiated until they are needed, the TYPE_ARG_TYPES may
9319 contain expressions that involve template parameters. But,
9320 no-one should be looking at them yet. And, once they're
9321 instantiated, they don't contain template parameters, so
9322 there's no point in looking at them then, either. */
9326 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
9327 WALK_SUBTREE (TREE_VALUE (parm
));
9329 /* Since we've already handled the TYPE_ARG_TYPES, we don't
9330 want walk_tree walking into them itself. */
9334 if (flag_noexcept_type
)
9336 tree spec
= TYPE_RAISES_EXCEPTIONS (t
);
9338 WALK_SUBTREE (TREE_PURPOSE (spec
));
9343 case UNDERLYING_TYPE
:
9344 if (pfd
->include_nondeduced_p
9345 && for_each_template_parm (TYPE_VALUES_RAW (t
), fn
, data
,
9347 pfd
->include_nondeduced_p
,
9349 return error_mark_node
;
9354 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
9355 WALK_SUBTREE (DECL_TI_ARGS (t
));
9360 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
))
9361 WALK_SUBTREE (DECL_INITIAL (t
));
9362 if (DECL_CONTEXT (t
)
9363 && pfd
->include_nondeduced_p
)
9364 WALK_SUBTREE (DECL_CONTEXT (t
));
9367 case BOUND_TEMPLATE_TEMPLATE_PARM
:
9368 /* Record template parameters such as `T' inside `TT<T>'. */
9369 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9372 case TEMPLATE_TEMPLATE_PARM
:
9373 case TEMPLATE_TYPE_PARM
:
9374 case TEMPLATE_PARM_INDEX
:
9375 if (fn
&& (*fn
)(t
, data
))
9382 /* A template template parameter is encountered. */
9383 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9384 WALK_SUBTREE (TREE_TYPE (t
));
9386 /* Already substituted template template parameter */
9391 /* A template-id in a TYPENAME_TYPE might be a deduced context after
9392 partial instantiation. */
9393 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t
));
9397 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
9398 && pfd
->include_nondeduced_p
)
9399 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
9404 /* If there's no type, then this thing must be some expression
9405 involving template parameters. */
9406 if (!fn
&& !TREE_TYPE (t
))
9407 return error_mark_node
;
9412 case IMPLICIT_CONV_EXPR
:
9413 case REINTERPRET_CAST_EXPR
:
9414 case CONST_CAST_EXPR
:
9415 case STATIC_CAST_EXPR
:
9416 case DYNAMIC_CAST_EXPR
:
9420 case PSEUDO_DTOR_EXPR
:
9422 return error_mark_node
;
9431 /* We didn't find any template parameters we liked. */
9436 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
9437 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
9438 call FN with the parameter and the DATA.
9439 If FN returns nonzero, the iteration is terminated, and
9440 for_each_template_parm returns 1. Otherwise, the iteration
9441 continues. If FN never returns a nonzero value, the value
9442 returned by for_each_template_parm is 0. If FN is NULL, it is
9443 considered to be the function which always returns 1.
9445 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
9446 parameters that occur in non-deduced contexts. When false, only
9447 visits those template parameters that can be deduced. */
9450 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
9451 hash_set
<tree
> *visited
,
9452 bool include_nondeduced_p
,
9455 struct pair_fn_data pfd
;
9460 pfd
.any_fn
= any_fn
;
9462 pfd
.include_nondeduced_p
= include_nondeduced_p
;
9464 /* Walk the tree. (Conceptually, we would like to walk without
9465 duplicates, but for_each_template_parm_r recursively calls
9466 for_each_template_parm, so we would need to reorganize a fair
9467 bit to use walk_tree_without_duplicates, so we keep our own
9470 pfd
.visited
= visited
;
9472 pfd
.visited
= new hash_set
<tree
>;
9473 result
= cp_walk_tree (&t
,
9474 for_each_template_parm_r
,
9488 /* Returns true if T depends on any template parameter. */
9491 uses_template_parms (tree t
)
9497 int saved_processing_template_decl
;
9499 saved_processing_template_decl
= processing_template_decl
;
9500 if (!saved_processing_template_decl
)
9501 processing_template_decl
= 1;
9503 dependent_p
= dependent_type_p (t
);
9504 else if (TREE_CODE (t
) == TREE_VEC
)
9505 dependent_p
= any_dependent_template_arguments_p (t
);
9506 else if (TREE_CODE (t
) == TREE_LIST
)
9507 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
9508 || uses_template_parms (TREE_CHAIN (t
)));
9509 else if (TREE_CODE (t
) == TYPE_DECL
)
9510 dependent_p
= dependent_type_p (TREE_TYPE (t
));
9513 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
9514 || TREE_CODE (t
) == OVERLOAD
9517 || TREE_CODE (t
) == TRAIT_EXPR
9518 || TREE_CODE (t
) == CONSTRUCTOR
9519 || CONSTANT_CLASS_P (t
))
9520 dependent_p
= (type_dependent_expression_p (t
)
9521 || value_dependent_expression_p (t
));
9524 gcc_assert (t
== error_mark_node
);
9525 dependent_p
= false;
9528 processing_template_decl
= saved_processing_template_decl
;
9533 /* Returns true iff current_function_decl is an incompletely instantiated
9534 template. Useful instead of processing_template_decl because the latter
9535 is set to 0 during instantiate_non_dependent_expr. */
9538 in_template_function (void)
9540 tree fn
= current_function_decl
;
9542 ++processing_template_decl
;
9543 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
9544 && DECL_TEMPLATE_INFO (fn
)
9545 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
9546 --processing_template_decl
;
9550 /* Returns true if T depends on any template parameter with level LEVEL. */
9553 uses_template_parms_level (tree t
, int level
)
9555 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
9556 /*include_nondeduced_p=*/true);
9559 /* Returns true if the signature of DECL depends on any template parameter from
9560 its enclosing class. */
9563 uses_outer_template_parms (tree decl
)
9565 int depth
= template_class_depth (CP_DECL_CONTEXT (decl
));
9568 if (for_each_template_parm (TREE_TYPE (decl
), template_parm_outer_level
,
9569 &depth
, NULL
, /*include_nondeduced_p=*/true))
9571 if (PRIMARY_TEMPLATE_P (decl
)
9572 && for_each_template_parm (INNERMOST_TEMPLATE_PARMS
9573 (DECL_TEMPLATE_PARMS (decl
)),
9574 template_parm_outer_level
,
9575 &depth
, NULL
, /*include_nondeduced_p=*/true))
9577 tree ci
= get_constraints (decl
);
9579 ci
= CI_ASSOCIATED_CONSTRAINTS (ci
);
9580 if (ci
&& for_each_template_parm (ci
, template_parm_outer_level
,
9581 &depth
, NULL
, /*nondeduced*/true))
9586 /* Returns TRUE iff INST is an instantiation we don't need to do in an
9587 ill-formed translation unit, i.e. a variable or function that isn't
9588 usable in a constant expression. */
9591 neglectable_inst_p (tree d
)
9594 && !undeduced_auto_decl (d
)
9595 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
9596 : decl_maybe_constant_var_p (d
)));
9599 /* Returns TRUE iff we should refuse to instantiate DECL because it's
9600 neglectable and instantiated from within an erroneous instantiation. */
9603 limit_bad_template_recursion (tree decl
)
9605 struct tinst_level
*lev
= current_tinst_level
;
9606 int errs
= errorcount
+ sorrycount
;
9607 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
9610 for (; lev
; lev
= lev
->next
)
9611 if (neglectable_inst_p (lev
->decl
))
9614 return (lev
&& errs
> lev
->errors
);
9617 static int tinst_depth
;
9618 extern int max_tinst_depth
;
9621 static GTY(()) struct tinst_level
*last_error_tinst_level
;
9623 /* We're starting to instantiate D; record the template instantiation context
9624 for diagnostics and to restore it later. */
9627 push_tinst_level (tree d
)
9629 return push_tinst_level_loc (d
, input_location
);
9632 /* We're starting to instantiate D; record the template instantiation context
9633 at LOC for diagnostics and to restore it later. */
9636 push_tinst_level_loc (tree d
, location_t loc
)
9638 struct tinst_level
*new_level
;
9640 if (tinst_depth
>= max_tinst_depth
)
9642 /* Tell error.c not to try to instantiate any templates. */
9644 fatal_error (input_location
,
9645 "template instantiation depth exceeds maximum of %d"
9646 " (use -ftemplate-depth= to increase the maximum)",
9651 /* If the current instantiation caused problems, don't let it instantiate
9652 anything else. Do allow deduction substitution and decls usable in
9653 constant expressions. */
9654 if (limit_bad_template_recursion (d
))
9657 /* When not -quiet, dump template instantiations other than functions, since
9658 announce_function will take care of those. */
9660 && TREE_CODE (d
) != TREE_LIST
9661 && TREE_CODE (d
) != FUNCTION_DECL
)
9662 fprintf (stderr
, " %s", decl_as_string (d
, TFF_DECL_SPECIFIERS
));
9664 new_level
= ggc_alloc
<tinst_level
> ();
9665 new_level
->decl
= d
;
9666 new_level
->locus
= loc
;
9667 new_level
->errors
= errorcount
+sorrycount
;
9668 new_level
->in_system_header_p
= in_system_header_at (input_location
);
9669 new_level
->next
= current_tinst_level
;
9670 current_tinst_level
= new_level
;
9673 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
9674 depth_reached
= tinst_depth
;
9679 /* We're done instantiating this template; return to the instantiation
9683 pop_tinst_level (void)
9685 /* Restore the filename and line number stashed away when we started
9686 this instantiation. */
9687 input_location
= current_tinst_level
->locus
;
9688 current_tinst_level
= current_tinst_level
->next
;
9692 /* We're instantiating a deferred template; restore the template
9693 instantiation context in which the instantiation was requested, which
9694 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
9697 reopen_tinst_level (struct tinst_level
*level
)
9699 struct tinst_level
*t
;
9702 for (t
= level
; t
; t
= t
->next
)
9705 current_tinst_level
= level
;
9707 if (current_tinst_level
)
9708 current_tinst_level
->errors
= errorcount
+sorrycount
;
9712 /* Returns the TINST_LEVEL which gives the original instantiation
9715 struct tinst_level
*
9716 outermost_tinst_level (void)
9718 struct tinst_level
*level
= current_tinst_level
;
9721 level
= level
->next
;
9725 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
9726 vector of template arguments, as for tsubst.
9728 Returns an appropriate tsubst'd friend declaration. */
9731 tsubst_friend_function (tree decl
, tree args
)
9735 if (TREE_CODE (decl
) == FUNCTION_DECL
9736 && DECL_TEMPLATE_INSTANTIATION (decl
)
9737 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
9738 /* This was a friend declared with an explicit template
9739 argument list, e.g.:
9743 to indicate that f was a template instantiation, not a new
9744 function declaration. Now, we have to figure out what
9745 instantiation of what template. */
9747 tree template_id
, arglist
, fns
;
9750 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
9752 /* Friend functions are looked up in the containing namespace scope.
9753 We must enter that scope, to avoid finding member functions of the
9754 current class with same name. */
9755 push_nested_namespace (ns
);
9756 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
9757 tf_warning_or_error
, NULL_TREE
,
9758 /*integral_constant_expression_p=*/false);
9759 pop_nested_namespace (ns
);
9760 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
9761 tf_warning_or_error
, NULL_TREE
);
9762 template_id
= lookup_template_function (fns
, arglist
);
9764 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
9765 tmpl
= determine_specialization (template_id
, new_friend
,
9767 /*need_member_template=*/0,
9768 TREE_VEC_LENGTH (args
),
9770 return instantiate_template (tmpl
, new_args
, tf_error
);
9773 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
9775 /* The NEW_FRIEND will look like an instantiation, to the
9776 compiler, but is not an instantiation from the point of view of
9777 the language. For example, we might have had:
9779 template <class T> struct S {
9780 template <class U> friend void f(T, U);
9783 Then, in S<int>, template <class U> void f(int, U) is not an
9784 instantiation of anything. */
9785 if (new_friend
== error_mark_node
)
9786 return error_mark_node
;
9788 DECL_USE_TEMPLATE (new_friend
) = 0;
9789 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
9791 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
9792 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
9793 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
9796 /* The mangled name for the NEW_FRIEND is incorrect. The function
9797 is not a template instantiation and should not be mangled like
9798 one. Therefore, we forget the mangling here; we'll recompute it
9799 later if we need it. */
9800 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
9802 SET_DECL_RTL (new_friend
, NULL
);
9803 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
9806 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
9809 tree new_friend_template_info
;
9810 tree new_friend_result_template_info
;
9812 int new_friend_is_defn
;
9814 /* We must save some information from NEW_FRIEND before calling
9815 duplicate decls since that function will free NEW_FRIEND if
9817 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
9818 new_friend_is_defn
=
9819 (DECL_INITIAL (DECL_TEMPLATE_RESULT
9820 (template_for_substitution (new_friend
)))
9822 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
9824 /* This declaration is a `primary' template. */
9825 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
9827 new_friend_result_template_info
9828 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
9831 new_friend_result_template_info
= NULL_TREE
;
9833 /* Inside pushdecl_namespace_level, we will push into the
9834 current namespace. However, the friend function should go
9835 into the namespace of the template. */
9836 ns
= decl_namespace_context (new_friend
);
9837 push_nested_namespace (ns
);
9838 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
9839 pop_nested_namespace (ns
);
9841 if (old_decl
== error_mark_node
)
9842 return error_mark_node
;
9844 if (old_decl
!= new_friend
)
9846 /* This new friend declaration matched an existing
9847 declaration. For example, given:
9849 template <class T> void f(T);
9850 template <class U> class C {
9851 template <class T> friend void f(T) {}
9854 the friend declaration actually provides the definition
9855 of `f', once C has been instantiated for some type. So,
9856 old_decl will be the out-of-class template declaration,
9857 while new_friend is the in-class definition.
9859 But, if `f' was called before this point, the
9860 instantiation of `f' will have DECL_TI_ARGS corresponding
9861 to `T' but not to `U', references to which might appear
9862 in the definition of `f'. Previously, the most general
9863 template for an instantiation of `f' was the out-of-class
9864 version; now it is the in-class version. Therefore, we
9865 run through all specialization of `f', adding to their
9866 DECL_TI_ARGS appropriately. In particular, they need a
9867 new set of outer arguments, corresponding to the
9868 arguments for this class instantiation.
9870 The same situation can arise with something like this:
9873 template <class T> class C {
9877 when `C<int>' is instantiated. Now, `f(int)' is defined
9880 if (!new_friend_is_defn
)
9881 /* On the other hand, if the in-class declaration does
9882 *not* provide a definition, then we don't want to alter
9883 existing definitions. We can just leave everything
9888 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
9889 tree new_args
= TI_ARGS (new_friend_template_info
);
9891 /* Overwrite whatever template info was there before, if
9892 any, with the new template information pertaining to
9894 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
9896 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
9898 /* We should have called reregister_specialization in
9900 gcc_assert (retrieve_specialization (new_template
,
9904 /* Instantiate it if the global has already been used. */
9905 if (DECL_ODR_USED (old_decl
))
9906 instantiate_decl (old_decl
, /*defer_ok=*/true,
9907 /*expl_inst_class_mem_p=*/false);
9913 /* Indicate that the old function template is a partial
9915 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
9916 = new_friend_result_template_info
;
9918 gcc_assert (new_template
9919 == most_general_template (new_template
));
9920 gcc_assert (new_template
!= old_decl
);
9922 /* Reassign any specializations already in the hash table
9923 to the new more general template, and add the
9924 additional template args. */
9925 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
9929 tree spec
= TREE_VALUE (t
);
9932 elt
.tmpl
= old_decl
;
9933 elt
.args
= DECL_TI_ARGS (spec
);
9934 elt
.spec
= NULL_TREE
;
9936 decl_specializations
->remove_elt (&elt
);
9939 = add_outermost_template_args (new_args
,
9940 DECL_TI_ARGS (spec
));
9942 register_specialization
9943 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
9946 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
9950 /* The information from NEW_FRIEND has been merged into OLD_DECL
9951 by duplicate_decls. */
9952 new_friend
= old_decl
;
9957 tree context
= DECL_CONTEXT (new_friend
);
9961 template <class T> class C {
9962 template <class U> friend void C1<U>::f (); // case 1
9963 friend void C2<T>::f (); // case 2
9965 we only need to make sure CONTEXT is a complete type for
9966 case 2. To distinguish between the two cases, we note that
9967 CONTEXT of case 1 remains dependent type after tsubst while
9968 this isn't true for case 2. */
9969 ++processing_template_decl
;
9970 dependent_p
= dependent_type_p (context
);
9971 --processing_template_decl
;
9974 && !complete_type_or_else (context
, NULL_TREE
))
9975 return error_mark_node
;
9977 if (COMPLETE_TYPE_P (context
))
9979 tree fn
= new_friend
;
9980 /* do_friend adds the TEMPLATE_DECL for any member friend
9981 template even if it isn't a member template, i.e.
9982 template <class T> friend A<T>::f();
9983 Look through it in that case. */
9984 if (TREE_CODE (fn
) == TEMPLATE_DECL
9985 && !PRIMARY_TEMPLATE_P (fn
))
9986 fn
= DECL_TEMPLATE_RESULT (fn
);
9987 /* Check to see that the declaration is really present, and,
9988 possibly obtain an improved declaration. */
9989 fn
= check_classfn (context
, fn
, NULL_TREE
);
9999 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
10000 template arguments, as for tsubst.
10002 Returns an appropriate tsubst'd friend type or error_mark_node on
10006 tsubst_friend_class (tree friend_tmpl
, tree args
)
10012 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
10014 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
10015 return TREE_TYPE (t
);
10018 context
= CP_DECL_CONTEXT (friend_tmpl
);
10020 if (context
!= global_namespace
)
10022 if (TREE_CODE (context
) == NAMESPACE_DECL
)
10023 push_nested_namespace (context
);
10025 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
10028 /* Look for a class template declaration. We look for hidden names
10029 because two friend declarations of the same template are the
10030 same. For example, in:
10033 template <typename> friend class F;
10035 template <typename> struct B {
10036 template <typename> friend class F;
10039 both F templates are the same. */
10040 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
10041 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
10043 /* But, if we don't find one, it might be because we're in a
10044 situation like this:
10052 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
10053 for `S<int>', not the TEMPLATE_DECL. */
10054 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
10056 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
10057 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
10060 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
10062 /* The friend template has already been declared. Just
10063 check to see that the declarations match, and install any new
10064 default parameters. We must tsubst the default parameters,
10065 of course. We only need the innermost template parameters
10066 because that is all that redeclare_class_template will look
10068 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
10069 > TMPL_ARGS_DEPTH (args
))
10072 location_t saved_input_location
;
10073 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
10074 args
, tf_warning_or_error
);
10076 saved_input_location
= input_location
;
10077 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
10078 tree cons
= get_constraints (tmpl
);
10079 redeclare_class_template (TREE_TYPE (tmpl
), parms
, cons
);
10080 input_location
= saved_input_location
;
10084 friend_type
= TREE_TYPE (tmpl
);
10088 /* The friend template has not already been declared. In this
10089 case, the instantiation of the template class will cause the
10090 injection of this template into the global scope. */
10091 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
10092 if (tmpl
== error_mark_node
)
10093 return error_mark_node
;
10095 /* The new TMPL is not an instantiation of anything, so we
10096 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
10097 the new type because that is supposed to be the corresponding
10098 template decl, i.e., TMPL. */
10099 DECL_USE_TEMPLATE (tmpl
) = 0;
10100 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
10101 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
10102 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
10103 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
10105 /* Inject this template into the global scope. */
10106 friend_type
= TREE_TYPE (pushdecl_top_level (tmpl
, true));
10109 if (context
!= global_namespace
)
10111 if (TREE_CODE (context
) == NAMESPACE_DECL
)
10112 pop_nested_namespace (context
);
10114 pop_nested_class ();
10117 return friend_type
;
10120 /* Returns zero if TYPE cannot be completed later due to circularity.
10121 Otherwise returns one. */
10124 can_complete_type_without_circularity (tree type
)
10126 if (type
== NULL_TREE
|| type
== error_mark_node
)
10128 else if (COMPLETE_TYPE_P (type
))
10130 else if (TREE_CODE (type
) == ARRAY_TYPE
)
10131 return can_complete_type_without_circularity (TREE_TYPE (type
));
10132 else if (CLASS_TYPE_P (type
)
10133 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
10139 static tree
tsubst_omp_clauses (tree
, enum c_omp_region_type
, tree
,
10140 tsubst_flags_t
, tree
);
10142 /* Instantiate a single dependent attribute T (a TREE_LIST), and return either
10143 T or a new TREE_LIST, possibly a chain in the case of a pack expansion. */
10146 tsubst_attribute (tree t
, tree
*decl_p
, tree args
,
10147 tsubst_flags_t complain
, tree in_decl
)
10149 gcc_assert (ATTR_IS_DEPENDENT (t
));
10151 tree val
= TREE_VALUE (t
);
10152 if (val
== NULL_TREE
)
10153 /* Nothing to do. */;
10154 else if ((flag_openmp
|| flag_openmp_simd
)
10155 && is_attribute_p ("omp declare simd",
10156 get_attribute_name (t
)))
10158 tree clauses
= TREE_VALUE (val
);
10159 clauses
= tsubst_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
, args
,
10160 complain
, in_decl
);
10161 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
10162 clauses
= finish_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
);
10163 tree parms
= DECL_ARGUMENTS (*decl_p
);
10165 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
10167 val
= build_tree_list (NULL_TREE
, clauses
);
10171 /* If the first attribute argument is an identifier, don't
10172 pass it through tsubst. Attributes like mode, format,
10173 cleanup and several target specific attributes expect it
10175 else if (attribute_takes_identifier_p (get_attribute_name (t
)))
10178 = tsubst_expr (TREE_CHAIN (val
), args
, complain
, in_decl
,
10179 /*integral_constant_expression_p=*/false);
10180 if (chain
!= TREE_CHAIN (val
))
10181 val
= tree_cons (NULL_TREE
, TREE_VALUE (val
), chain
);
10183 else if (PACK_EXPANSION_P (val
))
10185 /* An attribute pack expansion. */
10186 tree purp
= TREE_PURPOSE (t
);
10187 tree pack
= tsubst_pack_expansion (val
, args
, complain
, in_decl
);
10188 if (pack
== error_mark_node
)
10189 return error_mark_node
;
10190 int len
= TREE_VEC_LENGTH (pack
);
10191 tree list
= NULL_TREE
;
10193 for (int i
= 0; i
< len
; ++i
)
10195 tree elt
= TREE_VEC_ELT (pack
, i
);
10196 *q
= build_tree_list (purp
, elt
);
10197 q
= &TREE_CHAIN (*q
);
10202 val
= tsubst_expr (val
, args
, complain
, in_decl
,
10203 /*integral_constant_expression_p=*/false);
10205 if (val
!= TREE_VALUE (t
))
10206 return build_tree_list (TREE_PURPOSE (t
), val
);
10210 /* Instantiate any dependent attributes in ATTRIBUTES, returning either it
10211 unchanged or a new TREE_LIST chain. */
10214 tsubst_attributes (tree attributes
, tree args
,
10215 tsubst_flags_t complain
, tree in_decl
)
10217 tree last_dep
= NULL_TREE
;
10219 for (tree t
= attributes
; t
; t
= TREE_CHAIN (t
))
10220 if (ATTR_IS_DEPENDENT (t
))
10223 attributes
= copy_list (attributes
);
10228 for (tree
*p
= &attributes
; *p
; )
10231 if (ATTR_IS_DEPENDENT (t
))
10233 tree subst
= tsubst_attribute (t
, NULL
, args
, complain
, in_decl
);
10238 p
= &TREE_CHAIN (*p
);
10240 *p
= TREE_CHAIN (t
);
10244 p
= &TREE_CHAIN (*p
);
10250 /* Apply any attributes which had to be deferred until instantiation
10251 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
10252 ARGS, COMPLAIN, IN_DECL are as tsubst. */
10255 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
10256 tree args
, tsubst_flags_t complain
, tree in_decl
)
10258 tree last_dep
= NULL_TREE
;
10262 if (attributes
== NULL_TREE
)
10265 if (DECL_P (*decl_p
))
10267 if (TREE_TYPE (*decl_p
) == error_mark_node
)
10269 p
= &DECL_ATTRIBUTES (*decl_p
);
10270 /* DECL_ATTRIBUTES comes from copy_node in tsubst_decl, and is identical
10271 to our attributes parameter. */
10272 gcc_assert (*p
== attributes
);
10276 p
= &TYPE_ATTRIBUTES (*decl_p
);
10277 /* TYPE_ATTRIBUTES was set up (with abi_tag and may_alias) in
10278 lookup_template_class_1, and should be preserved. */
10279 gcc_assert (*p
!= attributes
);
10281 p
= &TREE_CHAIN (*p
);
10284 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
10285 if (ATTR_IS_DEPENDENT (t
))
10288 attributes
= copy_list (attributes
);
10295 tree late_attrs
= NULL_TREE
;
10296 tree
*q
= &late_attrs
;
10301 if (ATTR_IS_DEPENDENT (t
))
10303 *p
= TREE_CHAIN (t
);
10304 TREE_CHAIN (t
) = NULL_TREE
;
10305 *q
= tsubst_attribute (t
, decl_p
, args
, complain
, in_decl
);
10307 q
= &TREE_CHAIN (*q
);
10311 p
= &TREE_CHAIN (t
);
10314 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
10318 /* Perform (or defer) access check for typedefs that were referenced
10319 from within the template TMPL code.
10320 This is a subroutine of instantiate_decl and instantiate_class_template.
10321 TMPL is the template to consider and TARGS is the list of arguments of
10325 perform_typedefs_access_check (tree tmpl
, tree targs
)
10327 location_t saved_location
;
10329 qualified_typedef_usage_t
*iter
;
10332 || (!CLASS_TYPE_P (tmpl
)
10333 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
10336 saved_location
= input_location
;
10337 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
10339 tree type_decl
= iter
->typedef_decl
;
10340 tree type_scope
= iter
->context
;
10342 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
10345 if (uses_template_parms (type_decl
))
10346 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
10347 if (uses_template_parms (type_scope
))
10348 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
10350 /* Make access check error messages point to the location
10351 of the use of the typedef. */
10352 input_location
= iter
->locus
;
10353 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
10354 type_decl
, type_decl
,
10355 tf_warning_or_error
);
10357 input_location
= saved_location
;
10361 instantiate_class_template_1 (tree type
)
10363 tree templ
, args
, pattern
, t
, member
;
10367 unsigned int saved_maximum_field_alignment
;
10370 if (type
== error_mark_node
)
10371 return error_mark_node
;
10373 if (COMPLETE_OR_OPEN_TYPE_P (type
)
10374 || uses_template_parms (type
))
10377 /* Figure out which template is being instantiated. */
10378 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
10379 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
10381 /* Determine what specialization of the original template to
10383 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
10384 if (t
== error_mark_node
)
10386 TYPE_BEING_DEFINED (type
) = 1;
10387 return error_mark_node
;
10391 /* This TYPE is actually an instantiation of a partial
10392 specialization. We replace the innermost set of ARGS with
10393 the arguments appropriate for substitution. For example,
10396 template <class T> struct S {};
10397 template <class T> struct S<T*> {};
10399 and supposing that we are instantiating S<int*>, ARGS will
10400 presently be {int*} -- but we need {int}. */
10401 pattern
= TREE_TYPE (t
);
10402 args
= TREE_PURPOSE (t
);
10406 pattern
= TREE_TYPE (templ
);
10407 args
= CLASSTYPE_TI_ARGS (type
);
10410 /* If the template we're instantiating is incomplete, then clearly
10411 there's nothing we can do. */
10412 if (!COMPLETE_TYPE_P (pattern
))
10415 /* If we've recursively instantiated too many templates, stop. */
10416 if (! push_tinst_level (type
))
10419 /* Now we're really doing the instantiation. Mark the type as in
10420 the process of being defined. */
10421 TYPE_BEING_DEFINED (type
) = 1;
10423 /* We may be in the middle of deferred access check. Disable
10425 push_deferring_access_checks (dk_no_deferred
);
10427 int saved_unevaluated_operand
= cp_unevaluated_operand
;
10428 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10430 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
10431 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
10432 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
10433 fn_context
= error_mark_node
;
10435 push_to_top_level ();
10438 cp_unevaluated_operand
= 0;
10439 c_inhibit_evaluation_warnings
= 0;
10441 /* Use #pragma pack from the template context. */
10442 saved_maximum_field_alignment
= maximum_field_alignment
;
10443 maximum_field_alignment
= TYPE_PRECISION (pattern
);
10445 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
10447 /* Set the input location to the most specialized template definition.
10448 This is needed if tsubsting causes an error. */
10449 typedecl
= TYPE_MAIN_DECL (pattern
);
10450 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
10451 DECL_SOURCE_LOCATION (typedecl
);
10453 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
10454 SET_TYPE_ALIGN (type
, TYPE_ALIGN (pattern
));
10455 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
10456 CLASSTYPE_NON_AGGREGATE (type
) = CLASSTYPE_NON_AGGREGATE (pattern
);
10457 if (ANON_AGGR_TYPE_P (pattern
))
10458 SET_ANON_AGGR_TYPE_P (type
);
10459 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
10461 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
10462 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
10463 /* Adjust visibility for template arguments. */
10464 determine_visibility (TYPE_MAIN_DECL (type
));
10466 if (CLASS_TYPE_P (type
))
10467 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
10469 pbinfo
= TYPE_BINFO (pattern
);
10471 /* We should never instantiate a nested class before its enclosing
10472 class; we need to look up the nested class by name before we can
10473 instantiate it, and that lookup should instantiate the enclosing
10475 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
10476 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
10478 base_list
= NULL_TREE
;
10479 if (BINFO_N_BASE_BINFOS (pbinfo
))
10485 /* We must enter the scope containing the type, as that is where
10486 the accessibility of types named in dependent bases are
10488 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
10490 /* Substitute into each of the bases to determine the actual
10492 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
10495 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
10496 tree expanded_bases
= NULL_TREE
;
10499 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
10502 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
10503 args
, tf_error
, NULL_TREE
);
10504 if (expanded_bases
== error_mark_node
)
10507 len
= TREE_VEC_LENGTH (expanded_bases
);
10510 for (idx
= 0; idx
< len
; idx
++)
10512 if (expanded_bases
)
10513 /* Extract the already-expanded base class. */
10514 base
= TREE_VEC_ELT (expanded_bases
, idx
);
10516 /* Substitute to figure out the base class. */
10517 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
10520 if (base
== error_mark_node
)
10523 base_list
= tree_cons (access
, base
, base_list
);
10524 if (BINFO_VIRTUAL_P (pbase_binfo
))
10525 TREE_TYPE (base_list
) = integer_type_node
;
10529 /* The list is now in reverse order; correct that. */
10530 base_list
= nreverse (base_list
);
10533 pop_scope (pushed_scope
);
10535 /* Now call xref_basetypes to set up all the base-class
10537 xref_basetypes (type
, base_list
);
10539 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
10540 (int) ATTR_FLAG_TYPE_IN_PLACE
,
10541 args
, tf_error
, NULL_TREE
);
10542 fixup_attribute_variants (type
);
10544 /* Now that our base classes are set up, enter the scope of the
10545 class, so that name lookups into base classes, etc. will work
10546 correctly. This is precisely analogous to what we do in
10547 begin_class_definition when defining an ordinary non-template
10548 class, except we also need to push the enclosing classes. */
10549 push_nested_class (type
);
10551 /* Now members are processed in the order of declaration. */
10552 for (member
= CLASSTYPE_DECL_LIST (pattern
);
10553 member
; member
= TREE_CHAIN (member
))
10555 tree t
= TREE_VALUE (member
);
10557 if (TREE_PURPOSE (member
))
10561 /* Build new CLASSTYPE_NESTED_UTDS. */
10564 bool class_template_p
;
10566 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
10567 && TYPE_LANG_SPECIFIC (t
)
10568 && CLASSTYPE_IS_TEMPLATE (t
));
10569 /* If the member is a class template, then -- even after
10570 substitution -- there may be dependent types in the
10571 template argument list for the class. We increment
10572 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
10573 that function will assume that no types are dependent
10574 when outside of a template. */
10575 if (class_template_p
)
10576 ++processing_template_decl
;
10577 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
10578 if (class_template_p
)
10579 --processing_template_decl
;
10580 if (newtag
== error_mark_node
)
10583 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
10585 tree name
= TYPE_IDENTIFIER (t
);
10587 if (class_template_p
)
10588 /* Unfortunately, lookup_template_class sets
10589 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
10590 instantiation (i.e., for the type of a member
10591 template class nested within a template class.)
10592 This behavior is required for
10593 maybe_process_partial_specialization to work
10594 correctly, but is not accurate in this case;
10595 the TAG is not an instantiation of anything.
10596 (The corresponding TEMPLATE_DECL is an
10597 instantiation, but the TYPE is not.) */
10598 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
10600 /* Now, we call pushtag to put this NEWTAG into the scope of
10601 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
10602 pushtag calling push_template_decl. We don't have to do
10603 this for enums because it will already have been done in
10606 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
10607 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
10610 else if (DECL_DECLARES_FUNCTION_P (t
))
10614 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10615 ++processing_template_decl
;
10616 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
10617 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10618 --processing_template_decl
;
10619 set_current_access_from_decl (r
);
10620 finish_member_declaration (r
);
10621 /* Instantiate members marked with attribute used. */
10622 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
10624 if (TREE_CODE (r
) == FUNCTION_DECL
10625 && DECL_OMP_DECLARE_REDUCTION_P (r
))
10626 cp_check_omp_declare_reduction (r
);
10628 else if (DECL_CLASS_TEMPLATE_P (t
)
10629 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
10630 /* A closure type for a lambda in a default argument for a
10631 member template. Ignore it; it will be instantiated with
10632 the default argument. */;
10635 /* Build new TYPE_FIELDS. */
10636 if (TREE_CODE (t
) == STATIC_ASSERT
)
10640 ++c_inhibit_evaluation_warnings
;
10642 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
10643 tf_warning_or_error
, NULL_TREE
,
10644 /*integral_constant_expression_p=*/true);
10645 --c_inhibit_evaluation_warnings
;
10647 finish_static_assert (condition
,
10648 STATIC_ASSERT_MESSAGE (t
),
10649 STATIC_ASSERT_SOURCE_LOCATION (t
),
10650 /*member_p=*/true);
10652 else if (TREE_CODE (t
) != CONST_DECL
)
10655 tree vec
= NULL_TREE
;
10658 /* The file and line for this declaration, to
10659 assist in error message reporting. Since we
10660 called push_tinst_level above, we don't need to
10662 input_location
= DECL_SOURCE_LOCATION (t
);
10664 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10665 ++processing_template_decl
;
10666 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
10667 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10668 --processing_template_decl
;
10670 if (TREE_CODE (r
) == TREE_VEC
)
10672 /* A capture pack became multiple fields. */
10674 len
= TREE_VEC_LENGTH (vec
);
10677 for (int i
= 0; i
< len
; ++i
)
10680 r
= TREE_VEC_ELT (vec
, i
);
10685 [t]he initialization (and any associated
10686 side-effects) of a static data member does
10687 not occur unless the static data member is
10688 itself used in a way that requires the
10689 definition of the static data member to
10692 Therefore, we do not substitute into the
10693 initialized for the static data member here. */
10694 finish_static_data_member_decl
10696 /*init=*/NULL_TREE
,
10697 /*init_const_expr_p=*/false,
10698 /*asmspec_tree=*/NULL_TREE
,
10700 /* Instantiate members marked with attribute used. */
10701 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
10704 else if (TREE_CODE (r
) == FIELD_DECL
)
10706 /* Determine whether R has a valid type and can be
10707 completed later. If R is invalid, then its type
10708 is replaced by error_mark_node. */
10709 tree rtype
= TREE_TYPE (r
);
10710 if (can_complete_type_without_circularity (rtype
))
10711 complete_type (rtype
);
10713 if (!complete_or_array_type_p (rtype
))
10715 /* If R's type couldn't be completed and
10716 it isn't a flexible array member (whose
10717 type is incomplete by definition) give
10719 cxx_incomplete_type_error (r
, rtype
);
10720 TREE_TYPE (r
) = error_mark_node
;
10724 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
10725 such a thing will already have been added to the field
10726 list by tsubst_enum in finish_member_declaration in the
10727 CLASSTYPE_NESTED_UTDS case above. */
10728 if (!(TREE_CODE (r
) == TYPE_DECL
10729 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
10730 && DECL_ARTIFICIAL (r
)))
10732 set_current_access_from_decl (r
);
10733 finish_member_declaration (r
);
10741 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
10742 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10744 /* Build new CLASSTYPE_FRIEND_CLASSES. */
10746 tree friend_type
= t
;
10747 bool adjust_processing_template_decl
= false;
10749 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
10751 /* template <class T> friend class C; */
10752 friend_type
= tsubst_friend_class (friend_type
, args
);
10753 adjust_processing_template_decl
= true;
10755 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
10757 /* template <class T> friend class C::D; */
10758 friend_type
= tsubst (friend_type
, args
,
10759 tf_warning_or_error
, NULL_TREE
);
10760 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
10761 friend_type
= TREE_TYPE (friend_type
);
10762 adjust_processing_template_decl
= true;
10764 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
10765 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
10767 /* This could be either
10771 when dependent_type_p is false or
10773 template <class U> friend class T::C;
10776 /* Bump processing_template_decl in case this is something like
10777 template <class T> friend struct A<T>::B. */
10778 ++processing_template_decl
;
10779 friend_type
= tsubst (friend_type
, args
,
10780 tf_warning_or_error
, NULL_TREE
);
10781 if (dependent_type_p (friend_type
))
10782 adjust_processing_template_decl
= true;
10783 --processing_template_decl
;
10785 else if (TREE_CODE (friend_type
) != BOUND_TEMPLATE_TEMPLATE_PARM
10786 && !CLASSTYPE_USE_TEMPLATE (friend_type
)
10787 && TYPE_HIDDEN_P (friend_type
))
10791 where C hasn't been declared yet. Let's lookup name
10792 from namespace scope directly, bypassing any name that
10793 come from dependent base class. */
10794 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
10796 /* The call to xref_tag_from_type does injection for friend
10798 push_nested_namespace (ns
);
10800 xref_tag_from_type (friend_type
, NULL_TREE
,
10801 /*tag_scope=*/ts_current
);
10802 pop_nested_namespace (ns
);
10804 else if (uses_template_parms (friend_type
))
10805 /* friend class C<T>; */
10806 friend_type
= tsubst (friend_type
, args
,
10807 tf_warning_or_error
, NULL_TREE
);
10812 where C is already declared or
10814 friend class C<int>;
10816 We don't have to do anything in these cases. */
10818 if (adjust_processing_template_decl
)
10819 /* Trick make_friend_class into realizing that the friend
10820 we're adding is a template, not an ordinary class. It's
10821 important that we use make_friend_class since it will
10822 perform some error-checking and output cross-reference
10824 ++processing_template_decl
;
10826 if (friend_type
!= error_mark_node
)
10827 make_friend_class (type
, friend_type
, /*complain=*/false);
10829 if (adjust_processing_template_decl
)
10830 --processing_template_decl
;
10834 /* Build new DECL_FRIENDLIST. */
10837 /* The file and line for this declaration, to
10838 assist in error message reporting. Since we
10839 called push_tinst_level above, we don't need to
10841 input_location
= DECL_SOURCE_LOCATION (t
);
10843 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10845 ++processing_template_decl
;
10846 push_deferring_access_checks (dk_no_check
);
10849 r
= tsubst_friend_function (t
, args
);
10850 add_friend (type
, r
, /*complain=*/false);
10851 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10853 pop_deferring_access_checks ();
10854 --processing_template_decl
;
10862 /* Restore these before substituting into the lambda capture
10864 cp_unevaluated_operand
= saved_unevaluated_operand
;
10865 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10868 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
10870 tree decl
= lambda_function (type
);
10873 if (cxx_dialect
>= cxx17
)
10874 CLASSTYPE_LITERAL_P (type
) = true;
10876 if (!DECL_TEMPLATE_INFO (decl
)
10877 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
10879 /* Set function_depth to avoid garbage collection. */
10881 instantiate_decl (decl
, /*defer_ok=*/false, false);
10885 /* We need to instantiate the capture list from the template
10886 after we've instantiated the closure members, but before we
10887 consider adding the conversion op. Also keep any captures
10888 that may have been added during instantiation of the op(). */
10889 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
10891 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
10892 args
, tf_warning_or_error
, NULL_TREE
,
10895 LAMBDA_EXPR_CAPTURE_LIST (expr
)
10896 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
10898 maybe_add_lambda_conv_op (type
);
10901 gcc_assert (errorcount
);
10904 /* Set the file and line number information to whatever is given for
10905 the class itself. This puts error messages involving generated
10906 implicit functions at a predictable point, and the same point
10907 that would be used for non-template classes. */
10908 input_location
= DECL_SOURCE_LOCATION (typedecl
);
10910 unreverse_member_declarations (type
);
10911 finish_struct_1 (type
);
10912 TYPE_BEING_DEFINED (type
) = 0;
10914 /* We don't instantiate default arguments for member functions. 14.7.1:
10916 The implicit instantiation of a class template specialization causes
10917 the implicit instantiation of the declarations, but not of the
10918 definitions or default arguments, of the class member functions,
10919 member classes, static data members and member templates.... */
10921 /* Some typedefs referenced from within the template code need to be access
10922 checked at template instantiation time, i.e now. These types were
10923 added to the template at parsing time. Let's get those and perform
10924 the access checks then. */
10925 perform_typedefs_access_check (pattern
, args
);
10926 perform_deferred_access_checks (tf_warning_or_error
);
10927 pop_nested_class ();
10928 maximum_field_alignment
= saved_maximum_field_alignment
;
10930 pop_from_top_level ();
10931 pop_deferring_access_checks ();
10932 pop_tinst_level ();
10934 /* The vtable for a template class can be emitted in any translation
10935 unit in which the class is instantiated. When there is no key
10936 method, however, finish_struct_1 will already have added TYPE to
10937 the keyed_classes. */
10938 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
10939 vec_safe_push (keyed_classes
, type
);
10944 /* Wrapper for instantiate_class_template_1. */
10947 instantiate_class_template (tree type
)
10950 timevar_push (TV_TEMPLATE_INST
);
10951 ret
= instantiate_class_template_1 (type
);
10952 timevar_pop (TV_TEMPLATE_INST
);
10957 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10963 else if (TYPE_P (t
))
10964 r
= tsubst (t
, args
, complain
, in_decl
);
10967 if (!(complain
& tf_warning
))
10968 ++c_inhibit_evaluation_warnings
;
10969 r
= tsubst_expr (t
, args
, complain
, in_decl
,
10970 /*integral_constant_expression_p=*/true);
10971 if (!(complain
& tf_warning
))
10972 --c_inhibit_evaluation_warnings
;
10977 /* Given a function parameter pack TMPL_PARM and some function parameters
10978 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
10979 and set *SPEC_P to point at the next point in the list. */
10982 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
10984 /* Collect all of the extra "packed" parameters into an
10987 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
10988 tree spec_parm
= *spec_p
;
10991 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
10993 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
10996 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
10997 parmvec
= make_tree_vec (len
);
10998 spec_parm
= *spec_p
;
10999 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
11000 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
11002 /* Build the argument packs. */
11003 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
11004 *spec_p
= spec_parm
;
11009 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
11010 NONTYPE_ARGUMENT_PACK. */
11013 make_fnparm_pack (tree spec_parm
)
11015 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
11018 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
11019 pack expansion with no extra args, 2 if it has extra args, or 0
11020 if it is not a pack expansion. */
11023 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
11025 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
11026 if (i
>= TREE_VEC_LENGTH (vec
))
11028 tree elt
= TREE_VEC_ELT (vec
, i
);
11030 /* A decl pack is itself an expansion. */
11031 elt
= TREE_TYPE (elt
);
11032 if (!PACK_EXPANSION_P (elt
))
11034 if (PACK_EXPANSION_EXTRA_ARGS (elt
))
11040 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
11043 make_argument_pack_select (tree arg_pack
, unsigned index
)
11045 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
11047 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
11048 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
11053 /* This is a subroutine of tsubst_pack_expansion.
11055 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
11056 mechanism to store the (non complete list of) arguments of the
11057 substitution and return a non substituted pack expansion, in order
11058 to wait for when we have enough arguments to really perform the
11062 use_pack_expansion_extra_args_p (tree parm_packs
,
11064 bool has_empty_arg
)
11066 /* If one pack has an expansion and another pack has a normal
11067 argument or if one pack has an empty argument and an another
11068 one hasn't then tsubst_pack_expansion cannot perform the
11069 substitution and need to fall back on the
11070 PACK_EXPANSION_EXTRA mechanism. */
11071 if (parm_packs
== NULL_TREE
)
11073 else if (has_empty_arg
)
11076 bool has_expansion_arg
= false;
11077 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
11079 bool has_non_expansion_arg
= false;
11080 for (tree parm_pack
= parm_packs
;
11082 parm_pack
= TREE_CHAIN (parm_pack
))
11084 tree arg
= TREE_VALUE (parm_pack
);
11086 int exp
= argument_pack_element_is_expansion_p (arg
, i
);
11088 /* We can't substitute a pack expansion with extra args into
11092 has_expansion_arg
= true;
11094 has_non_expansion_arg
= true;
11097 if (has_expansion_arg
&& has_non_expansion_arg
)
11103 /* [temp.variadic]/6 says that:
11105 The instantiation of a pack expansion [...]
11106 produces a list E1,E2, ..., En, where N is the number of elements
11107 in the pack expansion parameters.
11109 This subroutine of tsubst_pack_expansion produces one of these Ei.
11111 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
11112 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
11113 PATTERN, and each TREE_VALUE is its corresponding argument pack.
11114 INDEX is the index 'i' of the element Ei to produce. ARGS,
11115 COMPLAIN, and IN_DECL are the same parameters as for the
11116 tsubst_pack_expansion function.
11118 The function returns the resulting Ei upon successful completion,
11119 or error_mark_node.
11121 Note that this function possibly modifies the ARGS parameter, so
11122 it's the responsibility of the caller to restore it. */
11125 gen_elem_of_pack_expansion_instantiation (tree pattern
,
11128 tree args
/* This parm gets
11130 tsubst_flags_t complain
,
11134 bool ith_elem_is_expansion
= false;
11136 /* For each parameter pack, change the substitution of the parameter
11137 pack to the ith argument in its argument pack, then expand the
11139 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
11141 tree parm
= TREE_PURPOSE (pack
);
11142 tree arg_pack
= TREE_VALUE (pack
);
11143 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
11145 ith_elem_is_expansion
|=
11146 argument_pack_element_is_expansion_p (arg_pack
, index
);
11148 /* Select the Ith argument from the pack. */
11149 if (TREE_CODE (parm
) == PARM_DECL
11150 || TREE_CODE (parm
) == FIELD_DECL
)
11154 aps
= make_argument_pack_select (arg_pack
, index
);
11155 if (!mark_used (parm
, complain
) && !(complain
& tf_error
))
11156 return error_mark_node
;
11157 register_local_specialization (aps
, parm
);
11160 aps
= retrieve_local_specialization (parm
);
11165 template_parm_level_and_index (parm
, &level
, &idx
);
11169 aps
= make_argument_pack_select (arg_pack
, index
);
11170 /* Update the corresponding argument. */
11171 TMPL_ARG (args
, level
, idx
) = aps
;
11174 /* Re-use the ARGUMENT_PACK_SELECT. */
11175 aps
= TMPL_ARG (args
, level
, idx
);
11177 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
11180 /* Substitute into the PATTERN with the (possibly altered)
11182 if (pattern
== in_decl
)
11183 /* Expanding a fixed parameter pack from
11184 coerce_template_parameter_pack. */
11185 t
= tsubst_decl (pattern
, args
, complain
);
11186 else if (pattern
== error_mark_node
)
11187 t
= error_mark_node
;
11188 else if (constraint_p (pattern
))
11190 if (processing_template_decl
)
11191 t
= tsubst_constraint (pattern
, args
, complain
, in_decl
);
11193 t
= (constraints_satisfied_p (pattern
, args
)
11194 ? boolean_true_node
: boolean_false_node
);
11196 else if (!TYPE_P (pattern
))
11197 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
11198 /*integral_constant_expression_p=*/false);
11200 t
= tsubst (pattern
, args
, complain
, in_decl
);
11202 /* If the Ith argument pack element is a pack expansion, then
11203 the Ith element resulting from the substituting is going to
11204 be a pack expansion as well. */
11205 if (ith_elem_is_expansion
)
11206 t
= make_pack_expansion (t
, complain
);
11211 /* When the unexpanded parameter pack in a fold expression expands to an empty
11212 sequence, the value of the expression is as follows; the program is
11213 ill-formed if the operator is not listed in this table.
11220 expand_empty_fold (tree t
, tsubst_flags_t complain
)
11222 tree_code code
= (tree_code
)TREE_INT_CST_LOW (TREE_OPERAND (t
, 0));
11223 if (!FOLD_EXPR_MODIFY_P (t
))
11226 case TRUTH_ANDIF_EXPR
:
11227 return boolean_true_node
;
11228 case TRUTH_ORIF_EXPR
:
11229 return boolean_false_node
;
11230 case COMPOUND_EXPR
:
11236 if (complain
& tf_error
)
11237 error_at (location_of (t
),
11238 "fold of empty expansion over %O", code
);
11239 return error_mark_node
;
11242 /* Given a fold-expression T and a current LEFT and RIGHT operand,
11243 form an expression that combines the two terms using the
11247 fold_expression (tree t
, tree left
, tree right
, tsubst_flags_t complain
)
11249 tree op
= FOLD_EXPR_OP (t
);
11250 tree_code code
= (tree_code
)TREE_INT_CST_LOW (op
);
11252 // Handle compound assignment operators.
11253 if (FOLD_EXPR_MODIFY_P (t
))
11254 return build_x_modify_expr (input_location
, left
, code
, right
, complain
);
11258 case COMPOUND_EXPR
:
11259 return build_x_compound_expr (input_location
, left
, right
, complain
);
11261 return build_m_component_ref (left
, right
, complain
);
11263 return build_x_binary_op (input_location
, code
,
11264 left
, TREE_CODE (left
),
11265 right
, TREE_CODE (right
),
11271 /* Substitute ARGS into the pack of a fold expression T. */
11274 tsubst_fold_expr_pack (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11276 return tsubst_pack_expansion (FOLD_EXPR_PACK (t
), args
, complain
, in_decl
);
11279 /* Substitute ARGS into the pack of a fold expression T. */
11282 tsubst_fold_expr_init (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11284 return tsubst_expr (FOLD_EXPR_INIT (t
), args
, complain
, in_decl
, false);
11287 /* Expand a PACK of arguments into a grouped as left fold.
11288 Given a pack containing elements A0, A1, ..., An and an
11289 operator @, this builds the expression:
11291 ((A0 @ A1) @ A2) ... @ An
11293 Note that PACK must not be empty.
11295 The operator is defined by the original fold expression T. */
11298 expand_left_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11300 tree left
= TREE_VEC_ELT (pack
, 0);
11301 for (int i
= 1; i
< TREE_VEC_LENGTH (pack
); ++i
)
11303 tree right
= TREE_VEC_ELT (pack
, i
);
11304 left
= fold_expression (t
, left
, right
, complain
);
11309 /* Substitute into a unary left fold expression. */
11312 tsubst_unary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11315 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11316 if (pack
== error_mark_node
)
11317 return error_mark_node
;
11318 if (PACK_EXPANSION_P (pack
))
11320 tree r
= copy_node (t
);
11321 FOLD_EXPR_PACK (r
) = pack
;
11324 if (TREE_VEC_LENGTH (pack
) == 0)
11325 return expand_empty_fold (t
, complain
);
11327 return expand_left_fold (t
, pack
, complain
);
11330 /* Substitute into a binary left fold expression.
11332 Do ths by building a single (non-empty) vector of argumnts and
11333 building the expression from those elements. */
11336 tsubst_binary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11339 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11340 if (pack
== error_mark_node
)
11341 return error_mark_node
;
11342 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
11343 if (init
== error_mark_node
)
11344 return error_mark_node
;
11346 if (PACK_EXPANSION_P (pack
))
11348 tree r
= copy_node (t
);
11349 FOLD_EXPR_PACK (r
) = pack
;
11350 FOLD_EXPR_INIT (r
) = init
;
11354 tree vec
= make_tree_vec (TREE_VEC_LENGTH (pack
) + 1);
11355 TREE_VEC_ELT (vec
, 0) = init
;
11356 for (int i
= 0; i
< TREE_VEC_LENGTH (pack
); ++i
)
11357 TREE_VEC_ELT (vec
, i
+ 1) = TREE_VEC_ELT (pack
, i
);
11359 return expand_left_fold (t
, vec
, complain
);
11362 /* Expand a PACK of arguments into a grouped as right fold.
11363 Given a pack containing elementns A0, A1, ..., and an
11364 operator @, this builds the expression:
11366 A0@ ... (An-2 @ (An-1 @ An))
11368 Note that PACK must not be empty.
11370 The operator is defined by the original fold expression T. */
11373 expand_right_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11375 // Build the expression.
11376 int n
= TREE_VEC_LENGTH (pack
);
11377 tree right
= TREE_VEC_ELT (pack
, n
- 1);
11378 for (--n
; n
!= 0; --n
)
11380 tree left
= TREE_VEC_ELT (pack
, n
- 1);
11381 right
= fold_expression (t
, left
, right
, complain
);
11386 /* Substitute into a unary right fold expression. */
11389 tsubst_unary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
11392 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11393 if (pack
== error_mark_node
)
11394 return error_mark_node
;
11395 if (PACK_EXPANSION_P (pack
))
11397 tree r
= copy_node (t
);
11398 FOLD_EXPR_PACK (r
) = pack
;
11401 if (TREE_VEC_LENGTH (pack
) == 0)
11402 return expand_empty_fold (t
, complain
);
11404 return expand_right_fold (t
, pack
, complain
);
11407 /* Substitute into a binary right fold expression.
11409 Do ths by building a single (non-empty) vector of arguments and
11410 building the expression from those elements. */
11413 tsubst_binary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
11416 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11417 if (pack
== error_mark_node
)
11418 return error_mark_node
;
11419 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
11420 if (init
== error_mark_node
)
11421 return error_mark_node
;
11423 if (PACK_EXPANSION_P (pack
))
11425 tree r
= copy_node (t
);
11426 FOLD_EXPR_PACK (r
) = pack
;
11427 FOLD_EXPR_INIT (r
) = init
;
11431 int n
= TREE_VEC_LENGTH (pack
);
11432 tree vec
= make_tree_vec (n
+ 1);
11433 for (int i
= 0; i
< n
; ++i
)
11434 TREE_VEC_ELT (vec
, i
) = TREE_VEC_ELT (pack
, i
);
11435 TREE_VEC_ELT (vec
, n
) = init
;
11437 return expand_right_fold (t
, vec
, complain
);
11441 /* Substitute ARGS into T, which is an pack expansion
11442 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
11443 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
11444 (if only a partial substitution could be performed) or
11445 ERROR_MARK_NODE if there was an error. */
11447 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
11451 tree pack
, packs
= NULL_TREE
;
11452 bool unsubstituted_packs
= false;
11455 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
11456 bool need_local_specializations
= false;
11459 gcc_assert (PACK_EXPANSION_P (t
));
11460 pattern
= PACK_EXPANSION_PATTERN (t
);
11462 /* Add in any args remembered from an earlier partial instantiation. */
11463 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
11465 levels
= TMPL_ARGS_DEPTH (args
);
11467 /* Determine the argument packs that will instantiate the parameter
11468 packs used in the expansion expression. While we're at it,
11469 compute the number of arguments to be expanded and make sure it
11471 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
11472 pack
= TREE_CHAIN (pack
))
11474 tree parm_pack
= TREE_VALUE (pack
);
11475 tree arg_pack
= NULL_TREE
;
11476 tree orig_arg
= NULL_TREE
;
11479 if (TREE_CODE (parm_pack
) == BASES
)
11481 gcc_assert (parm_pack
== pattern
);
11482 if (BASES_DIRECT (parm_pack
))
11483 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
11484 args
, complain
, in_decl
, false));
11486 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
11487 args
, complain
, in_decl
, false));
11489 else if (builtin_pack_call_p (parm_pack
))
11491 /* ??? Support use in other patterns. */
11492 gcc_assert (parm_pack
== pattern
);
11493 return expand_builtin_pack_call (parm_pack
, args
,
11494 complain
, in_decl
);
11496 else if (TREE_CODE (parm_pack
) == PARM_DECL
)
11498 /* We know we have correct local_specializations if this
11499 expansion is at function scope, or if we're dealing with a
11500 local parameter in a requires expression; for the latter,
11501 tsubst_requires_expr set it up appropriately. */
11502 if (PACK_EXPANSION_LOCAL_P (t
) || CONSTRAINT_VAR_P (parm_pack
))
11503 arg_pack
= retrieve_local_specialization (parm_pack
);
11505 /* We can't rely on local_specializations for a parameter
11506 name used later in a function declaration (such as in a
11507 late-specified return type). Even if it exists, it might
11508 have the wrong value for a recursive call. */
11509 need_local_specializations
= true;
11513 /* This parameter pack was used in an unevaluated context. Just
11514 make a dummy decl, since it's only used for its type. */
11515 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
11516 if (arg_pack
&& DECL_PACK_P (arg_pack
))
11517 /* Partial instantiation of the parm_pack, we can't build
11518 up an argument pack yet. */
11519 arg_pack
= NULL_TREE
;
11521 arg_pack
= make_fnparm_pack (arg_pack
);
11524 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
11525 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
11529 template_parm_level_and_index (parm_pack
, &level
, &idx
);
11531 if (level
<= levels
)
11532 arg_pack
= TMPL_ARG (args
, level
, idx
);
11535 orig_arg
= arg_pack
;
11536 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
11537 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
11539 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
11540 /* This can only happen if we forget to expand an argument
11541 pack somewhere else. Just return an error, silently. */
11543 result
= make_tree_vec (1);
11544 TREE_VEC_ELT (result
, 0) = error_mark_node
;
11551 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
11553 /* Don't bother trying to do a partial substitution with
11554 incomplete packs; we'll try again after deduction. */
11555 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
11560 else if (len
!= my_len
)
11562 if (!(complain
& tf_error
))
11563 /* Fail quietly. */;
11564 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
11565 error ("mismatched argument pack lengths while expanding %qT",
11568 error ("mismatched argument pack lengths while expanding %qE",
11570 return error_mark_node
;
11573 /* Keep track of the parameter packs and their corresponding
11575 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
11576 TREE_TYPE (packs
) = orig_arg
;
11580 /* We can't substitute for this parameter pack. We use a flag as
11581 well as the missing_level counter because function parameter
11582 packs don't have a level. */
11583 gcc_assert (processing_template_decl
);
11584 unsubstituted_packs
= true;
11588 /* If the expansion is just T..., return the matching argument pack, unless
11589 we need to call convert_from_reference on all the elements. This is an
11590 important optimization; see c++/68422. */
11591 if (!unsubstituted_packs
11592 && TREE_PURPOSE (packs
) == pattern
)
11594 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
11595 /* Types need no adjustment, nor does sizeof..., and if we still have
11596 some pack expansion args we won't do anything yet. */
11597 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
11598 || PACK_EXPANSION_SIZEOF_P (t
)
11599 || pack_expansion_args_count (args
))
11601 /* Also optimize expression pack expansions if we can tell that the
11602 elements won't have reference type. */
11603 tree type
= TREE_TYPE (pattern
);
11604 if (type
&& TREE_CODE (type
) != REFERENCE_TYPE
11605 && !PACK_EXPANSION_P (type
)
11606 && !WILDCARD_TYPE_P (type
))
11608 /* Otherwise use the normal path so we get convert_from_reference. */
11611 /* We cannot expand this expansion expression, because we don't have
11612 all of the argument packs we need. */
11613 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
11615 /* We got some full packs, but we can't substitute them in until we
11616 have values for all the packs. So remember these until then. */
11618 t
= make_pack_expansion (pattern
, complain
);
11619 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
11622 else if (unsubstituted_packs
)
11624 /* There were no real arguments, we're just replacing a parameter
11625 pack with another version of itself. Substitute into the
11626 pattern and return a PACK_EXPANSION_*. The caller will need to
11628 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
11629 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
11630 /*integral_constant_expression_p=*/false);
11632 t
= tsubst (pattern
, args
, complain
, in_decl
);
11633 t
= make_pack_expansion (t
, complain
);
11637 gcc_assert (len
>= 0);
11639 if (need_local_specializations
)
11641 /* We're in a late-specified return type, so create our own local
11642 specializations map; the current map is either NULL or (in the
11643 case of recursive unification) might have bindings that we don't
11644 want to use or alter. */
11645 saved_local_specializations
= local_specializations
;
11646 local_specializations
= new hash_map
<tree
, tree
>;
11649 /* For each argument in each argument pack, substitute into the
11651 result
= make_tree_vec (len
);
11652 tree elem_args
= copy_template_args (args
);
11653 for (i
= 0; i
< len
; ++i
)
11655 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
11657 elem_args
, complain
,
11659 TREE_VEC_ELT (result
, i
) = t
;
11660 if (t
== error_mark_node
)
11662 result
= error_mark_node
;
11667 /* Update ARGS to restore the substitution from parameter packs to
11668 their argument packs. */
11669 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
11671 tree parm
= TREE_PURPOSE (pack
);
11673 if (TREE_CODE (parm
) == PARM_DECL
11674 || TREE_CODE (parm
) == FIELD_DECL
)
11675 register_local_specialization (TREE_TYPE (pack
), parm
);
11680 if (TREE_VALUE (pack
) == NULL_TREE
)
11683 template_parm_level_and_index (parm
, &level
, &idx
);
11685 /* Update the corresponding argument. */
11686 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
11687 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
11690 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
11694 if (need_local_specializations
)
11696 delete local_specializations
;
11697 local_specializations
= saved_local_specializations
;
11700 /* If the dependent pack arguments were such that we end up with only a
11701 single pack expansion again, there's no need to keep it in a TREE_VEC. */
11702 if (len
== 1 && TREE_CODE (result
) == TREE_VEC
11703 && PACK_EXPANSION_P (TREE_VEC_ELT (result
, 0)))
11704 return TREE_VEC_ELT (result
, 0);
11709 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
11710 TMPL. We do this using DECL_PARM_INDEX, which should work even with
11711 parameter packs; all parms generated from a function parameter pack will
11712 have the same DECL_PARM_INDEX. */
11715 get_pattern_parm (tree parm
, tree tmpl
)
11717 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
11720 if (DECL_ARTIFICIAL (parm
))
11722 for (patparm
= DECL_ARGUMENTS (pattern
);
11723 patparm
; patparm
= DECL_CHAIN (patparm
))
11724 if (DECL_ARTIFICIAL (patparm
)
11725 && DECL_NAME (parm
) == DECL_NAME (patparm
))
11730 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
11731 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
11732 gcc_assert (DECL_PARM_INDEX (patparm
)
11733 == DECL_PARM_INDEX (parm
));
11739 /* Make an argument pack out of the TREE_VEC VEC. */
11742 make_argument_pack (tree vec
)
11745 tree elt
= TREE_VEC_ELT (vec
, 0);
11747 pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
11750 pack
= make_node (NONTYPE_ARGUMENT_PACK
);
11751 TREE_CONSTANT (pack
) = 1;
11753 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
11757 /* Return an exact copy of template args T that can be modified
11761 copy_template_args (tree t
)
11763 if (t
== error_mark_node
)
11766 int len
= TREE_VEC_LENGTH (t
);
11767 tree new_vec
= make_tree_vec (len
);
11769 for (int i
= 0; i
< len
; ++i
)
11771 tree elt
= TREE_VEC_ELT (t
, i
);
11772 if (elt
&& TREE_CODE (elt
) == TREE_VEC
)
11773 elt
= copy_template_args (elt
);
11774 TREE_VEC_ELT (new_vec
, i
) = elt
;
11777 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_vec
)
11778 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
11783 /* Substitute ARGS into the vector or list of template arguments T. */
11786 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11789 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
11792 if (t
== error_mark_node
)
11793 return error_mark_node
;
11795 len
= TREE_VEC_LENGTH (t
);
11796 elts
= XALLOCAVEC (tree
, len
);
11798 for (i
= 0; i
< len
; i
++)
11800 tree orig_arg
= TREE_VEC_ELT (t
, i
);
11803 if (TREE_CODE (orig_arg
) == TREE_VEC
)
11804 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
11805 else if (PACK_EXPANSION_P (orig_arg
))
11807 /* Substitute into an expansion expression. */
11808 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
11810 if (TREE_CODE (new_arg
) == TREE_VEC
)
11811 /* Add to the expanded length adjustment the number of
11812 expanded arguments. We subtract one from this
11813 measurement, because the argument pack expression
11814 itself is already counted as 1 in
11815 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
11816 the argument pack is empty. */
11817 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
11819 else if (ARGUMENT_PACK_P (orig_arg
))
11821 /* Substitute into each of the arguments. */
11822 new_arg
= TYPE_P (orig_arg
)
11823 ? cxx_make_type (TREE_CODE (orig_arg
))
11824 : make_node (TREE_CODE (orig_arg
));
11826 tree pack_args
= tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
11827 args
, complain
, in_decl
);
11828 if (pack_args
== error_mark_node
)
11829 new_arg
= error_mark_node
;
11831 SET_ARGUMENT_PACK_ARGS (new_arg
, pack_args
);
11833 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
)
11834 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
11837 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
11839 if (new_arg
== error_mark_node
)
11840 return error_mark_node
;
11843 if (new_arg
!= orig_arg
)
11850 /* Make space for the expanded arguments coming from template
11852 t
= make_tree_vec (len
+ expanded_len_adjust
);
11853 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
11854 arguments for a member template.
11855 In that case each TREE_VEC in ORIG_T represents a level of template
11856 arguments, and ORIG_T won't carry any non defaulted argument count.
11857 It will rather be the nested TREE_VECs that will carry one.
11858 In other words, ORIG_T carries a non defaulted argument count only
11859 if it doesn't contain any nested TREE_VEC. */
11860 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
11862 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
11863 count
+= expanded_len_adjust
;
11864 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
11866 for (i
= 0, out
= 0; i
< len
; i
++)
11868 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
11869 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
11870 && TREE_CODE (elts
[i
]) == TREE_VEC
)
11874 /* Now expand the template argument pack "in place". */
11875 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
11876 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
11880 TREE_VEC_ELT (t
, out
) = elts
[i
];
11888 /* Substitute ARGS into one level PARMS of template parameters. */
11891 tsubst_template_parms_level (tree parms
, tree args
, tsubst_flags_t complain
)
11893 if (parms
== error_mark_node
)
11894 return error_mark_node
;
11896 tree new_vec
= make_tree_vec (TREE_VEC_LENGTH (parms
));
11898 for (int i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
11900 tree tuple
= TREE_VEC_ELT (parms
, i
);
11902 if (tuple
== error_mark_node
)
11905 TREE_VEC_ELT (new_vec
, i
) =
11906 tsubst_template_parm (tuple
, args
, complain
);
11912 /* Return the result of substituting ARGS into the template parameters
11913 given by PARMS. If there are m levels of ARGS and m + n levels of
11914 PARMS, then the result will contain n levels of PARMS. For
11915 example, if PARMS is `template <class T> template <class U>
11916 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
11917 result will be `template <int*, double, class V>'. */
11920 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
11922 tree r
= NULL_TREE
;
11925 /* When substituting into a template, we must set
11926 PROCESSING_TEMPLATE_DECL as the template parameters may be
11927 dependent if they are based on one-another, and the dependency
11928 predicates are short-circuit outside of templates. */
11929 ++processing_template_decl
;
11931 for (new_parms
= &r
;
11932 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
11933 new_parms
= &(TREE_CHAIN (*new_parms
)),
11934 parms
= TREE_CHAIN (parms
))
11936 tree new_vec
= tsubst_template_parms_level (TREE_VALUE (parms
),
11939 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
11940 - TMPL_ARGS_DEPTH (args
)),
11941 new_vec
, NULL_TREE
);
11944 --processing_template_decl
;
11949 /* Return the result of substituting ARGS into one template parameter
11950 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
11951 parameter and which TREE_PURPOSE is the default argument of the
11952 template parameter. */
11955 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
11957 tree default_value
, parm_decl
;
11959 if (args
== NULL_TREE
11961 || t
== error_mark_node
)
11964 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
11966 default_value
= TREE_PURPOSE (t
);
11967 parm_decl
= TREE_VALUE (t
);
11969 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
11970 if (TREE_CODE (parm_decl
) == PARM_DECL
11971 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
11972 parm_decl
= error_mark_node
;
11973 default_value
= tsubst_template_arg (default_value
, args
,
11974 complain
, NULL_TREE
);
11976 return build_tree_list (default_value
, parm_decl
);
11979 /* Substitute the ARGS into the indicated aggregate (or enumeration)
11980 type T. If T is not an aggregate or enumeration type, it is
11981 handled as if by tsubst. IN_DECL is as for tsubst. If
11982 ENTERING_SCOPE is nonzero, T is the context for a template which
11983 we are presently tsubst'ing. Return the substituted value. */
11986 tsubst_aggr_type (tree t
,
11988 tsubst_flags_t complain
,
11990 int entering_scope
)
11992 if (t
== NULL_TREE
)
11995 switch (TREE_CODE (t
))
11998 if (TYPE_PTRMEMFUNC_P (t
))
11999 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
12001 /* Fall through. */
12002 case ENUMERAL_TYPE
:
12004 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
12009 int saved_unevaluated_operand
;
12010 int saved_inhibit_evaluation_warnings
;
12012 /* In "sizeof(X<I>)" we need to evaluate "I". */
12013 saved_unevaluated_operand
= cp_unevaluated_operand
;
12014 cp_unevaluated_operand
= 0;
12015 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
12016 c_inhibit_evaluation_warnings
= 0;
12018 /* First, determine the context for the type we are looking
12020 context
= TYPE_CONTEXT (t
);
12021 if (context
&& TYPE_P (context
))
12023 context
= tsubst_aggr_type (context
, args
, complain
,
12024 in_decl
, /*entering_scope=*/1);
12025 /* If context is a nested class inside a class template,
12026 it may still need to be instantiated (c++/33959). */
12027 context
= complete_type (context
);
12030 /* Then, figure out what arguments are appropriate for the
12031 type we are trying to find. For example, given:
12033 template <class T> struct S;
12034 template <class T, class U> void f(T, U) { S<U> su; }
12036 and supposing that we are instantiating f<int, double>,
12037 then our ARGS will be {int, double}, but, when looking up
12038 S we only want {double}. */
12039 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
12040 complain
, in_decl
);
12041 if (argvec
== error_mark_node
)
12042 r
= error_mark_node
;
12045 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
12046 entering_scope
, complain
);
12047 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12050 cp_unevaluated_operand
= saved_unevaluated_operand
;
12051 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
12056 /* This is not a template type, so there's nothing to do. */
12060 return tsubst (t
, args
, complain
, in_decl
);
12064 static GTY((cache
)) tree_cache_map
*defarg_inst
;
12066 /* Substitute into the default argument ARG (a default argument for
12067 FN), which has the indicated TYPE. */
12070 tsubst_default_argument (tree fn
, int parmnum
, tree type
, tree arg
,
12071 tsubst_flags_t complain
)
12073 tree saved_class_ptr
= NULL_TREE
;
12074 tree saved_class_ref
= NULL_TREE
;
12075 int errs
= errorcount
+ sorrycount
;
12077 /* This can happen in invalid code. */
12078 if (TREE_CODE (arg
) == DEFAULT_ARG
)
12081 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
12082 parm
= chain_index (parmnum
, parm
);
12083 tree parmtype
= TREE_TYPE (parm
);
12084 if (DECL_BY_REFERENCE (parm
))
12085 parmtype
= TREE_TYPE (parmtype
);
12086 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, parmtype
));
12089 if (defarg_inst
&& (slot
= defarg_inst
->get (parm
)))
12092 /* This default argument came from a template. Instantiate the
12093 default argument here, not in tsubst. In the case of
12102 we must be careful to do name lookup in the scope of S<T>,
12103 rather than in the current class. */
12104 push_access_scope (fn
);
12105 /* The "this" pointer is not valid in a default argument. */
12108 saved_class_ptr
= current_class_ptr
;
12109 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
12110 saved_class_ref
= current_class_ref
;
12111 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
12114 start_lambda_scope (parm
);
12116 push_deferring_access_checks(dk_no_deferred
);
12117 /* The default argument expression may cause implicitly defined
12118 member functions to be synthesized, which will result in garbage
12119 collection. We must treat this situation as if we were within
12120 the body of function so as to avoid collecting live data on the
12123 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
12124 complain
, NULL_TREE
,
12125 /*integral_constant_expression_p=*/false);
12127 pop_deferring_access_checks();
12129 finish_lambda_scope ();
12131 /* Restore the "this" pointer. */
12134 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
12135 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
12138 if (errorcount
+sorrycount
> errs
12139 && (complain
& tf_warning_or_error
))
12140 inform (input_location
,
12141 " when instantiating default argument for call to %qD", fn
);
12143 /* Make sure the default argument is reasonable. */
12144 arg
= check_default_argument (type
, arg
, complain
);
12146 pop_access_scope (fn
);
12148 if (arg
!= error_mark_node
&& !cp_unevaluated_operand
)
12151 defarg_inst
= tree_cache_map::create_ggc (37);
12152 defarg_inst
->put (parm
, arg
);
12158 /* Substitute into all the default arguments for FN. */
12161 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
12166 tmpl_args
= DECL_TI_ARGS (fn
);
12168 /* If this function is not yet instantiated, we certainly don't need
12169 its default arguments. */
12170 if (uses_template_parms (tmpl_args
))
12172 /* Don't do this again for clones. */
12173 if (DECL_CLONED_FUNCTION_P (fn
))
12177 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
12179 arg
= TREE_CHAIN (arg
), ++i
)
12180 if (TREE_PURPOSE (arg
))
12181 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
, i
,
12183 TREE_PURPOSE (arg
),
12187 /* Subroutine of tsubst_decl for the case when T is a FUNCTION_DECL. */
12190 tsubst_function_decl (tree t
, tree args
, tsubst_flags_t complain
,
12191 tree lambda_fntype
)
12193 tree gen_tmpl
, argvec
;
12194 hashval_t hash
= 0;
12197 /* Nobody should be tsubst'ing into non-template functions. */
12198 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
12200 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
12202 /* If T is not dependent, just return it. */
12203 if (!uses_template_parms (DECL_TI_ARGS (t
)))
12206 /* Calculate the most general template of which R is a
12207 specialization, and the complete set of arguments used to
12209 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
12210 argvec
= tsubst_template_args (DECL_TI_ARGS
12211 (DECL_TEMPLATE_RESULT
12212 (DECL_TI_TEMPLATE (t
))),
12213 args
, complain
, in_decl
);
12214 if (argvec
== error_mark_node
)
12215 return error_mark_node
;
12217 /* Check to see if we already have this specialization. */
12218 if (!lambda_fntype
)
12220 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
12221 if (tree spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
))
12225 /* We can see more levels of arguments than parameters if
12226 there was a specialization of a member template, like
12229 template <class T> struct S { template <class U> void f(); }
12230 template <> template <class U> void S<int>::f(U);
12232 Here, we'll be substituting into the specialization,
12233 because that's where we can find the code we actually
12234 want to generate, but we'll have enough arguments for
12235 the most general template.
12237 We also deal with the peculiar case:
12239 template <class T> struct S {
12240 template <class U> friend void f();
12242 template <class U> void f() {}
12244 template void f<double>();
12246 Here, the ARGS for the instantiation of will be {int,
12247 double}. But, we only need as many ARGS as there are
12248 levels of template parameters in CODE_PATTERN. We are
12249 careful not to get fooled into reducing the ARGS in
12252 template <class T> struct S { template <class U> void f(U); }
12253 template <class T> template <> void S<T>::f(int) {}
12255 which we can spot because the pattern will be a
12256 specialization in this case. */
12257 int args_depth
= TMPL_ARGS_DEPTH (args
);
12259 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
12261 if (args_depth
> parms_depth
&& !DECL_TEMPLATE_SPECIALIZATION (t
))
12262 args
= get_innermost_template_args (args
, parms_depth
);
12266 /* This special case arises when we have something like this:
12268 template <class T> struct S {
12269 friend void f<int>(int, double);
12272 Here, the DECL_TI_TEMPLATE for the friend declaration
12273 will be an IDENTIFIER_NODE. We are being called from
12274 tsubst_friend_function, and we want only to create a
12275 new decl (R) with appropriate types so that we can call
12276 determine_specialization. */
12277 gen_tmpl
= NULL_TREE
;
12278 argvec
= NULL_TREE
;
12281 tree closure
= (lambda_fntype
? TYPE_METHOD_BASETYPE (lambda_fntype
)
12283 tree ctx
= closure
? closure
: DECL_CONTEXT (t
);
12284 bool member
= ctx
&& TYPE_P (ctx
);
12286 if (member
&& !closure
)
12287 ctx
= tsubst_aggr_type (ctx
, args
,
12288 complain
, t
, /*entering_scope=*/1);
12290 tree type
= (lambda_fntype
? lambda_fntype
12291 : tsubst (TREE_TYPE (t
), args
,
12292 complain
| tf_fndecl_type
, in_decl
));
12293 if (type
== error_mark_node
)
12294 return error_mark_node
;
12296 /* If we hit excessive deduction depth, the type is bogus even if
12297 it isn't error_mark_node, so don't build a decl. */
12298 if (excessive_deduction_depth
)
12299 return error_mark_node
;
12301 /* We do NOT check for matching decls pushed separately at this
12302 point, as they may not represent instantiations of this
12303 template, and in any case are considered separate under the
12305 tree r
= copy_decl (t
);
12306 DECL_USE_TEMPLATE (r
) = 0;
12307 TREE_TYPE (r
) = type
;
12308 /* Clear out the mangled name and RTL for the instantiation. */
12309 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
12310 SET_DECL_RTL (r
, NULL
);
12311 /* Leave DECL_INITIAL set on deleted instantiations. */
12312 if (!DECL_DELETED_FN (r
))
12313 DECL_INITIAL (r
) = NULL_TREE
;
12314 DECL_CONTEXT (r
) = ctx
;
12316 /* OpenMP UDRs have the only argument a reference to the declared
12317 type. We want to diagnose if the declared type is a reference,
12318 which is invalid, but as references to references are usually
12319 quietly merged, diagnose it here. */
12320 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
12323 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
12324 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
12325 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
12326 error_at (DECL_SOURCE_LOCATION (t
),
12327 "reference type %qT in "
12328 "%<#pragma omp declare reduction%>", argtype
);
12329 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
12330 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
12334 if (member
&& DECL_CONV_FN_P (r
))
12335 /* Type-conversion operator. Reconstruct the name, in
12336 case it's the name of one of the template's parameters. */
12337 DECL_NAME (r
) = make_conv_op_name (TREE_TYPE (type
));
12339 tree parms
= DECL_ARGUMENTS (t
);
12341 parms
= DECL_CHAIN (parms
);
12342 parms
= tsubst (parms
, args
, complain
, t
);
12343 for (tree parm
= parms
; parm
; parm
= DECL_CHAIN (parm
))
12344 DECL_CONTEXT (parm
) = r
;
12347 tree tparm
= build_this_parm (r
, closure
, type_memfn_quals (type
));
12348 DECL_CHAIN (tparm
) = parms
;
12351 DECL_ARGUMENTS (r
) = parms
;
12352 DECL_RESULT (r
) = NULL_TREE
;
12354 TREE_STATIC (r
) = 0;
12355 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
12356 DECL_EXTERNAL (r
) = 1;
12357 /* If this is an instantiation of a function with internal
12358 linkage, we already know what object file linkage will be
12359 assigned to the instantiation. */
12360 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
12361 DECL_DEFER_OUTPUT (r
) = 0;
12362 DECL_CHAIN (r
) = NULL_TREE
;
12363 DECL_PENDING_INLINE_INFO (r
) = 0;
12364 DECL_PENDING_INLINE_P (r
) = 0;
12365 DECL_SAVED_TREE (r
) = NULL_TREE
;
12366 DECL_STRUCT_FUNCTION (r
) = NULL
;
12368 /* We'll re-clone as appropriate in instantiate_template. */
12369 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
12371 /* If we aren't complaining now, return on error before we register
12372 the specialization so that we'll complain eventually. */
12373 if ((complain
& tf_error
) == 0
12374 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
12375 && !grok_op_properties (r
, /*complain=*/false))
12376 return error_mark_node
;
12378 /* When instantiating a constrained member, substitute
12379 into the constraints to create a new constraint. */
12380 if (tree ci
= get_constraints (t
))
12383 ci
= tsubst_constraint_info (ci
, argvec
, complain
, NULL_TREE
);
12384 set_constraints (r
, ci
);
12387 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
12388 this in the special friend case mentioned above where
12389 GEN_TMPL is NULL. */
12390 if (gen_tmpl
&& !closure
)
12392 DECL_TEMPLATE_INFO (r
)
12393 = build_template_info (gen_tmpl
, argvec
);
12394 SET_DECL_IMPLICIT_INSTANTIATION (r
);
12397 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
12399 /* We instantiated this while substituting into
12400 the type earlier (template/friend54.C). */
12403 /* We're not supposed to instantiate default arguments
12404 until they are called, for a template. But, for a
12407 template <class T> void f ()
12408 { extern void g(int i = T()); }
12410 we should do the substitution when the template is
12411 instantiated. We handle the member function case in
12412 instantiate_class_template since the default arguments
12413 might refer to other members of the class. */
12415 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
12416 && !uses_template_parms (argvec
))
12417 tsubst_default_arguments (r
, complain
);
12420 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
12422 /* Copy the list of befriending classes. */
12423 for (tree
*friends
= &DECL_BEFRIENDING_CLASSES (r
);
12425 friends
= &TREE_CHAIN (*friends
))
12427 *friends
= copy_node (*friends
);
12428 TREE_VALUE (*friends
)
12429 = tsubst (TREE_VALUE (*friends
), args
, complain
, in_decl
);
12432 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
12434 maybe_retrofit_in_chrg (r
);
12435 if (DECL_CONSTRUCTOR_P (r
) && !grok_ctor_properties (ctx
, r
))
12436 return error_mark_node
;
12437 /* If this is an instantiation of a member template, clone it.
12438 If it isn't, that'll be handled by
12439 clone_constructors_and_destructors. */
12440 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
12441 clone_function_decl (r
, /*update_methods=*/false);
12443 else if ((complain
& tf_error
) != 0
12444 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
12445 && !grok_op_properties (r
, /*complain=*/true))
12446 return error_mark_node
;
12448 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
12449 SET_DECL_FRIEND_CONTEXT (r
,
12450 tsubst (DECL_FRIEND_CONTEXT (t
),
12451 args
, complain
, in_decl
));
12453 /* Possibly limit visibility based on template args. */
12454 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
12455 if (DECL_VISIBILITY_SPECIFIED (t
))
12457 DECL_VISIBILITY_SPECIFIED (r
) = 0;
12458 DECL_ATTRIBUTES (r
)
12459 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
12461 determine_visibility (r
);
12462 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
12463 && !processing_template_decl
)
12464 defaulted_late_check (r
);
12466 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
12467 args
, complain
, in_decl
);
12471 /* Subroutine of tsubst_decl for the case when T is a TEMPLATE_DECL. */
12474 tsubst_template_decl (tree t
, tree args
, tsubst_flags_t complain
,
12475 tree lambda_fntype
)
12477 /* We can get here when processing a member function template,
12478 member class template, or template template parameter. */
12479 tree decl
= DECL_TEMPLATE_RESULT (t
);
12485 hashval_t hash
= 0;
12487 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
12489 /* Template template parameter is treated here. */
12490 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12491 if (new_type
== error_mark_node
)
12492 r
= error_mark_node
;
12493 /* If we get a real template back, return it. This can happen in
12494 the context of most_specialized_partial_spec. */
12495 else if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
12498 /* The new TEMPLATE_DECL was built in
12499 reduce_template_parm_level. */
12500 r
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (new_type
);
12504 if (!lambda_fntype
)
12506 /* We might already have an instance of this template.
12507 The ARGS are for the surrounding class type, so the
12508 full args contain the tsubst'd args for the context,
12509 plus the innermost args from the template decl. */
12510 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
12511 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
12512 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
12513 /* Because this is a template, the arguments will still be
12514 dependent, even after substitution. If
12515 PROCESSING_TEMPLATE_DECL is not set, the dependency
12516 predicates will short-circuit. */
12517 ++processing_template_decl
;
12518 full_args
= tsubst_template_args (tmpl_args
, args
,
12519 complain
, in_decl
);
12520 --processing_template_decl
;
12521 if (full_args
== error_mark_node
)
12522 return error_mark_node
;
12524 /* If this is a default template template argument,
12525 tsubst might not have changed anything. */
12526 if (full_args
== tmpl_args
)
12529 hash
= hash_tmpl_and_args (t
, full_args
);
12530 spec
= retrieve_specialization (t
, full_args
, hash
);
12531 if (spec
!= NULL_TREE
)
12535 /* Make a new template decl. It will be similar to the
12536 original, but will record the current template arguments.
12537 We also create a new function declaration, which is just
12538 like the old one, but points to this new template, rather
12539 than the old one. */
12541 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
12542 DECL_CHAIN (r
) = NULL_TREE
;
12544 // Build new template info linking to the original template decl.
12545 if (!lambda_fntype
)
12547 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
12548 SET_DECL_IMPLICIT_INSTANTIATION (r
);
12551 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
12553 /* The template parameters for this new template are all the
12554 template parameters for the old template, except the
12555 outermost level of parameters. */
12556 DECL_TEMPLATE_PARMS (r
)
12557 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
12560 if (TREE_CODE (decl
) == TYPE_DECL
12561 && !TYPE_DECL_ALIAS_P (decl
))
12564 ++processing_template_decl
;
12565 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12566 --processing_template_decl
;
12567 if (new_type
== error_mark_node
)
12568 return error_mark_node
;
12570 TREE_TYPE (r
) = new_type
;
12571 /* For a partial specialization, we need to keep pointing to
12572 the primary template. */
12573 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
12574 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
12575 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
12576 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
12577 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
12582 ++processing_template_decl
;
12583 if (TREE_CODE (decl
) == FUNCTION_DECL
)
12584 new_decl
= tsubst_function_decl (decl
, args
, complain
, lambda_fntype
);
12586 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
12587 --processing_template_decl
;
12588 if (new_decl
== error_mark_node
)
12589 return error_mark_node
;
12591 DECL_TEMPLATE_RESULT (r
) = new_decl
;
12592 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
12593 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
12596 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (r
));
12597 DECL_TEMPLATE_INFO (new_decl
) = build_template_info (r
, args
);
12601 DECL_TI_TEMPLATE (new_decl
) = r
;
12602 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
12606 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
12607 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
12609 if (PRIMARY_TEMPLATE_P (t
))
12610 DECL_PRIMARY_TEMPLATE (r
) = r
;
12612 if (TREE_CODE (decl
) != TYPE_DECL
&& !VAR_P (decl
)
12614 /* Record this non-type partial instantiation. */
12615 register_specialization (r
, t
,
12616 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
12622 /* True if FN is the op() for a lambda in an uninstantiated template. */
12625 lambda_fn_in_template_p (tree fn
)
12627 if (!fn
|| !LAMBDA_FUNCTION_P (fn
))
12629 tree closure
= DECL_CONTEXT (fn
);
12630 return CLASSTYPE_TEMPLATE_INFO (closure
) != NULL_TREE
;
12633 /* True if FN is the op() for a lambda regenerated from a lambda in an
12634 uninstantiated template. */
12637 regenerated_lambda_fn_p (tree fn
)
12639 return (LAMBDA_FUNCTION_P (fn
)
12640 && !DECL_TEMPLATE_INSTANTIATION (fn
));
12643 /* We're instantiating a variable from template function TCTX. Return the
12644 corresponding current enclosing scope. This gets complicated because lambda
12645 functions in templates are regenerated rather than instantiated, but generic
12646 lambda functions are subsequently instantiated. */
12649 enclosing_instantiation_of (tree tctx
)
12651 tree fn
= current_function_decl
;
12652 int lambda_count
= 0;
12654 for (; tctx
&& lambda_fn_in_template_p (tctx
);
12655 tctx
= decl_function_context (tctx
))
12657 for (; fn
; fn
= decl_function_context (fn
))
12660 int flambda_count
= 0;
12661 for (; fn
&& regenerated_lambda_fn_p (fn
);
12662 fn
= decl_function_context (fn
))
12664 if (DECL_TEMPLATE_INFO (fn
)
12665 ? most_general_template (fn
) != most_general_template (tctx
)
12671 while (flambda_count
-- > lambda_count
)
12672 fn
= decl_function_context (fn
);
12676 gcc_unreachable ();
12679 /* Substitute the ARGS into the T, which is a _DECL. Return the
12680 result of the substitution. Issue error and warning messages under
12681 control of COMPLAIN. */
12684 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
12686 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
12687 location_t saved_loc
;
12688 tree r
= NULL_TREE
;
12690 hashval_t hash
= 0;
12692 /* Set the filename and linenumber to improve error-reporting. */
12693 saved_loc
= input_location
;
12694 input_location
= DECL_SOURCE_LOCATION (t
);
12696 switch (TREE_CODE (t
))
12698 case TEMPLATE_DECL
:
12699 r
= tsubst_template_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
12702 case FUNCTION_DECL
:
12703 r
= tsubst_function_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
12708 tree type
= NULL_TREE
;
12710 tree expanded_types
= NULL_TREE
;
12711 tree prev_r
= NULL_TREE
;
12712 tree first_r
= NULL_TREE
;
12714 if (DECL_PACK_P (t
))
12716 /* If there is a local specialization that isn't a
12717 parameter pack, it means that we're doing a "simple"
12718 substitution from inside tsubst_pack_expansion. Just
12719 return the local specialization (which will be a single
12721 tree spec
= retrieve_local_specialization (t
);
12723 && TREE_CODE (spec
) == PARM_DECL
12724 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
12727 /* Expand the TYPE_PACK_EXPANSION that provides the types for
12728 the parameters in this function parameter pack. */
12729 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
12730 complain
, in_decl
);
12731 if (TREE_CODE (expanded_types
) == TREE_VEC
)
12733 len
= TREE_VEC_LENGTH (expanded_types
);
12735 /* Zero-length parameter packs are boring. Just substitute
12738 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
12743 /* All we did was update the type. Make a note of that. */
12744 type
= expanded_types
;
12745 expanded_types
= NULL_TREE
;
12749 /* Loop through all of the parameters we'll build. When T is
12750 a function parameter pack, LEN is the number of expanded
12751 types in EXPANDED_TYPES; otherwise, LEN is 1. */
12753 for (i
= 0; i
< len
; ++i
)
12757 if (DECL_TEMPLATE_PARM_P (t
))
12758 SET_DECL_TEMPLATE_PARM_P (r
);
12760 if (expanded_types
)
12761 /* We're on the Ith parameter of the function parameter
12764 /* Get the Ith type. */
12765 type
= TREE_VEC_ELT (expanded_types
, i
);
12767 /* Rename the parameter to include the index. */
12769 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
12772 /* We're dealing with a normal parameter. */
12773 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12775 type
= type_decays_to (type
);
12776 TREE_TYPE (r
) = type
;
12777 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
12779 if (DECL_INITIAL (r
))
12781 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
12782 DECL_INITIAL (r
) = TREE_TYPE (r
);
12784 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
12785 complain
, in_decl
);
12788 DECL_CONTEXT (r
) = NULL_TREE
;
12790 if (!DECL_TEMPLATE_PARM_P (r
))
12791 DECL_ARG_TYPE (r
) = type_passed_as (type
);
12793 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
12794 args
, complain
, in_decl
);
12796 /* Keep track of the first new parameter we
12797 generate. That's what will be returned to the
12802 /* Build a proper chain of parameters when substituting
12803 into a function parameter pack. */
12805 DECL_CHAIN (prev_r
) = r
;
12808 /* If cp_unevaluated_operand is set, we're just looking for a
12809 single dummy parameter, so don't keep going. */
12810 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
12811 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
12812 complain
, DECL_CHAIN (t
));
12814 /* FIRST_R contains the start of the chain we've built. */
12821 tree type
= NULL_TREE
;
12822 tree vec
= NULL_TREE
;
12823 tree expanded_types
= NULL_TREE
;
12826 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12828 /* This field is a lambda capture pack. Return a TREE_VEC of
12829 the expanded fields to instantiate_class_template_1 and
12830 store them in the specializations hash table as a
12831 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
12832 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
12833 complain
, in_decl
);
12834 if (TREE_CODE (expanded_types
) == TREE_VEC
)
12836 len
= TREE_VEC_LENGTH (expanded_types
);
12837 vec
= make_tree_vec (len
);
12841 /* All we did was update the type. Make a note of that. */
12842 type
= expanded_types
;
12843 expanded_types
= NULL_TREE
;
12847 for (int i
= 0; i
< len
; ++i
)
12850 if (expanded_types
)
12852 type
= TREE_VEC_ELT (expanded_types
, i
);
12854 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
12857 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12859 if (type
== error_mark_node
)
12860 RETURN (error_mark_node
);
12861 TREE_TYPE (r
) = type
;
12862 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
12864 if (DECL_C_BIT_FIELD (r
))
12865 /* For bit-fields, DECL_BIT_FIELD_REPRESENTATIVE gives the
12867 DECL_BIT_FIELD_REPRESENTATIVE (r
)
12868 = tsubst_expr (DECL_BIT_FIELD_REPRESENTATIVE (t
), args
,
12870 /*integral_constant_expression_p=*/true);
12871 if (DECL_INITIAL (t
))
12873 /* Set up DECL_TEMPLATE_INFO so that we can get at the
12874 NSDMI in perform_member_init. Still set DECL_INITIAL
12875 so that we know there is one. */
12876 DECL_INITIAL (r
) = void_node
;
12877 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
12878 retrofit_lang_decl (r
);
12879 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
12881 /* We don't have to set DECL_CONTEXT here; it is set by
12882 finish_member_declaration. */
12883 DECL_CHAIN (r
) = NULL_TREE
;
12885 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
12886 args
, complain
, in_decl
);
12889 TREE_VEC_ELT (vec
, i
) = r
;
12895 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
12896 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
12897 register_specialization (pack
, t
, args
, false, 0);
12903 /* We reach here only for member using decls. We also need to check
12904 uses_template_parms because DECL_DEPENDENT_P is not set for a
12905 using-declaration that designates a member of the current
12906 instantiation (c++/53549). */
12907 if (DECL_DEPENDENT_P (t
)
12908 || uses_template_parms (USING_DECL_SCOPE (t
)))
12910 tree scope
= USING_DECL_SCOPE (t
);
12911 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
12912 if (PACK_EXPANSION_P (scope
))
12914 tree vec
= tsubst_pack_expansion (scope
, args
, complain
, in_decl
);
12915 int len
= TREE_VEC_LENGTH (vec
);
12916 r
= make_tree_vec (len
);
12917 for (int i
= 0; i
< len
; ++i
)
12919 tree escope
= TREE_VEC_ELT (vec
, i
);
12920 tree elt
= do_class_using_decl (escope
, name
);
12923 r
= error_mark_node
;
12928 TREE_PROTECTED (elt
) = TREE_PROTECTED (t
);
12929 TREE_PRIVATE (elt
) = TREE_PRIVATE (t
);
12931 TREE_VEC_ELT (r
, i
) = elt
;
12936 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
12937 complain
, in_decl
);
12938 r
= do_class_using_decl (inst_scope
, name
);
12940 r
= error_mark_node
;
12943 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
12944 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
12951 DECL_CHAIN (r
) = NULL_TREE
;
12958 tree argvec
= NULL_TREE
;
12959 tree gen_tmpl
= NULL_TREE
;
12961 tree tmpl
= NULL_TREE
;
12963 tree type
= NULL_TREE
;
12966 if (TREE_TYPE (t
) == error_mark_node
)
12967 RETURN (error_mark_node
);
12969 if (TREE_CODE (t
) == TYPE_DECL
12970 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
12972 /* If this is the canonical decl, we don't have to
12973 mess with instantiations, and often we can't (for
12974 typename, template type parms and such). Note that
12975 TYPE_NAME is not correct for the above test if
12976 we've copied the type for a typedef. */
12977 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12978 if (type
== error_mark_node
)
12979 RETURN (error_mark_node
);
12980 r
= TYPE_NAME (type
);
12984 /* Check to see if we already have the specialization we
12987 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
12989 /* T is a static data member or namespace-scope entity.
12990 We have to substitute into namespace-scope variables
12991 (not just variable templates) because of cases like:
12993 template <class T> void f() { extern T t; }
12995 where the entity referenced is not known until
12996 instantiation time. */
12998 ctx
= DECL_CONTEXT (t
);
12999 if (DECL_CLASS_SCOPE_P (t
))
13001 ctx
= tsubst_aggr_type (ctx
, args
,
13003 in_decl
, /*entering_scope=*/1);
13004 /* If CTX is unchanged, then T is in fact the
13005 specialization we want. That situation occurs when
13006 referencing a static data member within in its own
13007 class. We can use pointer equality, rather than
13008 same_type_p, because DECL_CONTEXT is always
13010 if (ctx
== DECL_CONTEXT (t
)
13011 /* ... unless T is a member template; in which
13012 case our caller can be willing to create a
13013 specialization of that template represented
13015 && !(DECL_TI_TEMPLATE (t
)
13016 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
13022 tmpl
= DECL_TI_TEMPLATE (t
);
13023 gen_tmpl
= most_general_template (tmpl
);
13024 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
13025 if (argvec
!= error_mark_node
)
13026 argvec
= (coerce_innermost_template_parms
13027 (DECL_TEMPLATE_PARMS (gen_tmpl
),
13028 argvec
, t
, complain
,
13029 /*all*/true, /*defarg*/true));
13030 if (argvec
== error_mark_node
)
13031 RETURN (error_mark_node
);
13032 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
13033 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
13038 /* A local variable. */
13040 /* Subsequent calls to pushdecl will fill this in. */
13042 /* Unless this is a reference to a static variable from an
13043 enclosing function, in which case we need to fill it in now. */
13044 if (TREE_STATIC (t
))
13046 tree fn
= enclosing_instantiation_of (DECL_CONTEXT (t
));
13047 if (fn
!= current_function_decl
)
13050 spec
= retrieve_local_specialization (t
);
13052 /* If we already have the specialization we need, there is
13053 nothing more to do. */
13060 /* Create a new node for the specialization we need. */
13062 if (type
== NULL_TREE
)
13064 if (is_typedef_decl (t
))
13065 type
= DECL_ORIGINAL_TYPE (t
);
13067 type
= TREE_TYPE (t
);
13069 && VAR_HAD_UNKNOWN_BOUND (t
)
13070 && type
!= error_mark_node
)
13071 type
= strip_array_domain (type
);
13072 tree sub_args
= args
;
13073 if (tree auto_node
= type_uses_auto (type
))
13075 /* Mask off any template args past the variable's context so we
13076 don't replace the auto with an unrelated argument. */
13077 int nouter
= TEMPLATE_TYPE_LEVEL (auto_node
) - 1;
13078 int extra
= TMPL_ARGS_DEPTH (args
) - nouter
;
13080 /* This should never happen with the new lambda instantiation
13081 model, but keep the handling just in case. */
13082 gcc_assert (!CHECKING_P
),
13083 sub_args
= strip_innermost_template_args (args
, extra
);
13085 type
= tsubst (type
, sub_args
, complain
, in_decl
);
13089 /* Even if the original location is out of scope, the
13090 newly substituted one is not. */
13091 DECL_DEAD_FOR_LOCAL (r
) = 0;
13092 DECL_INITIALIZED_P (r
) = 0;
13093 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
13094 if (type
== error_mark_node
)
13095 RETURN (error_mark_node
);
13096 if (TREE_CODE (type
) == FUNCTION_TYPE
)
13098 /* It may seem that this case cannot occur, since:
13103 declares a function, not a variable. However:
13106 template <typename T> void g() { T t; }
13107 template void g<f>();
13109 is an attempt to declare a variable with function
13111 error ("variable %qD has function type",
13112 /* R is not yet sufficiently initialized, so we
13113 just use its name. */
13115 RETURN (error_mark_node
);
13117 type
= complete_type (type
);
13118 /* Wait until cp_finish_decl to set this again, to handle
13119 circular dependency (template/instantiate6.C). */
13120 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
13121 type
= check_var_type (DECL_NAME (r
), type
);
13123 if (DECL_HAS_VALUE_EXPR_P (t
))
13125 tree ve
= DECL_VALUE_EXPR (t
);
13126 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
13127 /*constant_expression_p=*/false);
13128 if (REFERENCE_REF_P (ve
))
13130 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
13131 ve
= TREE_OPERAND (ve
, 0);
13133 SET_DECL_VALUE_EXPR (r
, ve
);
13135 if (CP_DECL_THREAD_LOCAL_P (r
)
13136 && !processing_template_decl
)
13137 set_decl_tls_model (r
, decl_default_tls_model (r
));
13139 else if (DECL_SELF_REFERENCE_P (t
))
13140 SET_DECL_SELF_REFERENCE_P (r
);
13141 TREE_TYPE (r
) = type
;
13142 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13143 DECL_CONTEXT (r
) = ctx
;
13144 /* Clear out the mangled name and RTL for the instantiation. */
13145 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
13146 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
13147 SET_DECL_RTL (r
, NULL
);
13148 /* The initializer must not be expanded until it is required;
13149 see [temp.inst]. */
13150 DECL_INITIAL (r
) = NULL_TREE
;
13151 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
13154 if (DECL_LANG_SPECIFIC (r
))
13155 SET_DECL_DEPENDENT_INIT_P (r
, false);
13157 SET_DECL_MODE (r
, VOIDmode
);
13159 /* Possibly limit visibility based on template args. */
13160 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
13161 if (DECL_VISIBILITY_SPECIFIED (t
))
13163 DECL_VISIBILITY_SPECIFIED (r
) = 0;
13164 DECL_ATTRIBUTES (r
)
13165 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
13167 determine_visibility (r
);
13172 /* A static data member declaration is always marked
13173 external when it is declared in-class, even if an
13174 initializer is present. We mimic the non-template
13175 processing here. */
13176 DECL_EXTERNAL (r
) = 1;
13177 if (DECL_NAMESPACE_SCOPE_P (t
))
13178 DECL_NOT_REALLY_EXTERN (r
) = 1;
13180 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
13181 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13182 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
13186 if (DECL_LANG_SPECIFIC (r
))
13187 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13188 if (!cp_unevaluated_operand
)
13189 register_local_specialization (r
, t
);
13192 DECL_CHAIN (r
) = NULL_TREE
;
13194 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
13196 args
, complain
, in_decl
);
13198 /* Preserve a typedef that names a type. */
13199 if (is_typedef_decl (r
) && type
!= error_mark_node
)
13201 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
13202 set_underlying_type (r
);
13203 if (TYPE_DECL_ALIAS_P (r
))
13204 /* An alias template specialization can be dependent
13205 even if its underlying type is not. */
13206 TYPE_DEPENDENT_P_VALID (TREE_TYPE (r
)) = false;
13209 layout_decl (r
, 0);
13214 gcc_unreachable ();
13219 /* Restore the file and line information. */
13220 input_location
= saved_loc
;
13225 /* Substitute into the ARG_TYPES of a function type.
13226 If END is a TREE_CHAIN, leave it and any following types
13230 tsubst_arg_types (tree arg_types
,
13233 tsubst_flags_t complain
,
13236 tree remaining_arg_types
;
13237 tree type
= NULL_TREE
;
13239 tree expanded_args
= NULL_TREE
;
13242 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
13245 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
13246 args
, end
, complain
, in_decl
);
13247 if (remaining_arg_types
== error_mark_node
)
13248 return error_mark_node
;
13250 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
13252 /* For a pack expansion, perform substitution on the
13253 entire expression. Later on, we'll handle the arguments
13255 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
13256 args
, complain
, in_decl
);
13258 if (TREE_CODE (expanded_args
) == TREE_VEC
)
13259 /* So that we'll spin through the parameters, one by one. */
13260 i
= TREE_VEC_LENGTH (expanded_args
);
13263 /* We only partially substituted into the parameter
13264 pack. Our type is TYPE_PACK_EXPANSION. */
13265 type
= expanded_args
;
13266 expanded_args
= NULL_TREE
;
13274 type
= TREE_VEC_ELT (expanded_args
, i
);
13276 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
13278 if (type
== error_mark_node
)
13279 return error_mark_node
;
13280 if (VOID_TYPE_P (type
))
13282 if (complain
& tf_error
)
13284 error ("invalid parameter type %qT", type
);
13286 error ("in declaration %q+D", in_decl
);
13288 return error_mark_node
;
13291 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
13292 return error_mark_node
;
13294 /* Do array-to-pointer, function-to-pointer conversion, and ignore
13295 top-level qualifiers as required. */
13296 type
= cv_unqualified (type_decays_to (type
));
13298 /* We do not substitute into default arguments here. The standard
13299 mandates that they be instantiated only when needed, which is
13300 done in build_over_call. */
13301 default_arg
= TREE_PURPOSE (arg_types
);
13303 /* Except that we do substitute default arguments under tsubst_lambda_expr,
13304 since the new op() won't have any associated template arguments for us
13305 to refer to later. */
13306 if (lambda_fn_in_template_p (in_decl
))
13307 default_arg
= tsubst_copy_and_build (default_arg
, args
, complain
, in_decl
,
13308 false/*fn*/, false/*constexpr*/);
13310 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
13312 /* We've instantiated a template before its default arguments
13313 have been parsed. This can happen for a nested template
13314 class, and is not an error unless we require the default
13315 argument in a call of this function. */
13316 remaining_arg_types
=
13317 tree_cons (default_arg
, type
, remaining_arg_types
);
13318 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
13321 remaining_arg_types
=
13322 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
13325 return remaining_arg_types
;
13328 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
13329 *not* handle the exception-specification for FNTYPE, because the
13330 initial substitution of explicitly provided template parameters
13331 during argument deduction forbids substitution into the
13332 exception-specification:
13336 All references in the function type of the function template to the
13337 corresponding template parameters are replaced by the specified tem-
13338 plate argument values. If a substitution in a template parameter or
13339 in the function type of the function template results in an invalid
13340 type, type deduction fails. [Note: The equivalent substitution in
13341 exception specifications is done only when the function is instanti-
13342 ated, at which point a program is ill-formed if the substitution
13343 results in an invalid type.] */
13346 tsubst_function_type (tree t
,
13348 tsubst_flags_t complain
,
13352 tree arg_types
= NULL_TREE
;
13355 /* The TYPE_CONTEXT is not used for function/method types. */
13356 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
13358 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
13360 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
13362 if (late_return_type_p
)
13364 /* Substitute the argument types. */
13365 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
13366 complain
, in_decl
);
13367 if (arg_types
== error_mark_node
)
13368 return error_mark_node
;
13370 tree save_ccp
= current_class_ptr
;
13371 tree save_ccr
= current_class_ref
;
13372 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
13373 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
13374 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
13377 /* DR 1207: 'this' is in scope in the trailing return type. */
13378 inject_this_parameter (this_type
, cp_type_quals (this_type
));
13381 /* Substitute the return type. */
13382 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13386 current_class_ptr
= save_ccp
;
13387 current_class_ref
= save_ccr
;
13391 /* Substitute the return type. */
13392 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13394 if (return_type
== error_mark_node
)
13395 return error_mark_node
;
13396 /* DR 486 clarifies that creation of a function type with an
13397 invalid return type is a deduction failure. */
13398 if (TREE_CODE (return_type
) == ARRAY_TYPE
13399 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
13401 if (complain
& tf_error
)
13403 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
13404 error ("function returning an array");
13406 error ("function returning a function");
13408 return error_mark_node
;
13411 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
13412 return error_mark_node
;
13414 if (!late_return_type_p
)
13416 /* Substitute the argument types. */
13417 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
13418 complain
, in_decl
);
13419 if (arg_types
== error_mark_node
)
13420 return error_mark_node
;
13423 /* Construct a new type node and return it. */
13424 if (TREE_CODE (t
) == FUNCTION_TYPE
)
13426 fntype
= build_function_type (return_type
, arg_types
);
13427 fntype
= apply_memfn_quals (fntype
,
13428 type_memfn_quals (t
),
13429 type_memfn_rqual (t
));
13433 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
13434 /* Don't pick up extra function qualifiers from the basetype. */
13435 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
13436 if (! MAYBE_CLASS_TYPE_P (r
))
13440 Type deduction may fail for any of the following
13443 -- Attempting to create "pointer to member of T" when T
13444 is not a class type. */
13445 if (complain
& tf_error
)
13446 error ("creating pointer to member function of non-class type %qT",
13448 return error_mark_node
;
13451 fntype
= build_method_type_directly (r
, return_type
,
13452 TREE_CHAIN (arg_types
));
13453 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
13455 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
13457 if (late_return_type_p
)
13458 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
13463 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
13464 ARGS into that specification, and return the substituted
13465 specification. If there is no specification, return NULL_TREE. */
13468 tsubst_exception_specification (tree fntype
,
13470 tsubst_flags_t complain
,
13477 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
13478 new_specs
= NULL_TREE
;
13479 if (specs
&& TREE_PURPOSE (specs
))
13481 /* A noexcept-specifier. */
13482 tree expr
= TREE_PURPOSE (specs
);
13483 if (TREE_CODE (expr
) == INTEGER_CST
)
13487 /* Defer instantiation of noexcept-specifiers to avoid
13488 excessive instantiations (c++/49107). */
13489 new_specs
= make_node (DEFERRED_NOEXCEPT
);
13490 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
13492 /* We already partially instantiated this member template,
13493 so combine the new args with the old. */
13494 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
13495 = DEFERRED_NOEXCEPT_PATTERN (expr
);
13496 DEFERRED_NOEXCEPT_ARGS (new_specs
)
13497 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
13501 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
13502 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
13506 new_specs
= tsubst_copy_and_build
13507 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
13508 /*integral_constant_expression_p=*/true);
13509 new_specs
= build_noexcept_spec (new_specs
, complain
);
13513 if (! TREE_VALUE (specs
))
13520 tree expanded_specs
= NULL_TREE
;
13522 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
13524 /* Expand the pack expansion type. */
13525 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
13529 if (expanded_specs
== error_mark_node
)
13530 return error_mark_node
;
13531 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
13532 len
= TREE_VEC_LENGTH (expanded_specs
);
13535 /* We're substituting into a member template, so
13536 we got a TYPE_PACK_EXPANSION back. Add that
13537 expansion and move on. */
13538 gcc_assert (TREE_CODE (expanded_specs
)
13539 == TYPE_PACK_EXPANSION
);
13540 new_specs
= add_exception_specifier (new_specs
,
13543 specs
= TREE_CHAIN (specs
);
13548 for (i
= 0; i
< len
; ++i
)
13550 if (expanded_specs
)
13551 spec
= TREE_VEC_ELT (expanded_specs
, i
);
13553 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
13554 if (spec
== error_mark_node
)
13556 new_specs
= add_exception_specifier (new_specs
, spec
,
13560 specs
= TREE_CHAIN (specs
);
13566 /* Take the tree structure T and replace template parameters used
13567 therein with the argument vector ARGS. IN_DECL is an associated
13568 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
13569 Issue error and warning messages under control of COMPLAIN. Note
13570 that we must be relatively non-tolerant of extensions here, in
13571 order to preserve conformance; if we allow substitutions that
13572 should not be allowed, we may allow argument deductions that should
13573 not succeed, and therefore report ambiguous overload situations
13574 where there are none. In theory, we could allow the substitution,
13575 but indicate that it should have failed, and allow our caller to
13576 make sure that the right thing happens, but we don't try to do this
13579 This function is used for dealing with types, decls and the like;
13580 for expressions, use tsubst_expr or tsubst_copy. */
13583 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
13585 enum tree_code code
;
13586 tree type
, r
= NULL_TREE
;
13588 if (t
== NULL_TREE
|| t
== error_mark_node
13589 || t
== integer_type_node
13590 || t
== void_type_node
13591 || t
== char_type_node
13592 || t
== unknown_type_node
13593 || TREE_CODE (t
) == NAMESPACE_DECL
13594 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
13598 return tsubst_decl (t
, args
, complain
);
13600 if (args
== NULL_TREE
)
13603 code
= TREE_CODE (t
);
13605 if (code
== IDENTIFIER_NODE
)
13606 type
= IDENTIFIER_TYPE_VALUE (t
);
13608 type
= TREE_TYPE (t
);
13610 gcc_assert (type
!= unknown_type_node
);
13612 /* Reuse typedefs. We need to do this to handle dependent attributes,
13613 such as attribute aligned. */
13615 && typedef_variant_p (t
))
13617 tree decl
= TYPE_NAME (t
);
13619 if (alias_template_specialization_p (t
))
13621 /* DECL represents an alias template and we want to
13623 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
13624 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
13625 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
13627 else if (DECL_CLASS_SCOPE_P (decl
)
13628 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
13629 && uses_template_parms (DECL_CONTEXT (decl
)))
13631 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
13632 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
13633 r
= retrieve_specialization (tmpl
, gen_args
, 0);
13635 else if (DECL_FUNCTION_SCOPE_P (decl
)
13636 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
13637 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
13638 r
= retrieve_local_specialization (decl
);
13640 /* The typedef is from a non-template context. */
13646 r
= cp_build_qualified_type_real
13647 (r
, cp_type_quals (t
) | cp_type_quals (r
),
13648 complain
| tf_ignore_bad_quals
);
13653 /* We don't have an instantiation yet, so drop the typedef. */
13654 int quals
= cp_type_quals (t
);
13655 t
= DECL_ORIGINAL_TYPE (decl
);
13656 t
= cp_build_qualified_type_real (t
, quals
,
13657 complain
| tf_ignore_bad_quals
);
13661 bool fndecl_type
= (complain
& tf_fndecl_type
);
13662 complain
&= ~tf_fndecl_type
;
13665 && code
!= TYPENAME_TYPE
13666 && code
!= TEMPLATE_TYPE_PARM
13667 && code
!= TEMPLATE_PARM_INDEX
13668 && code
!= IDENTIFIER_NODE
13669 && code
!= FUNCTION_TYPE
13670 && code
!= METHOD_TYPE
)
13671 type
= tsubst (type
, args
, complain
, in_decl
);
13672 if (type
== error_mark_node
)
13673 return error_mark_node
;
13679 case ENUMERAL_TYPE
:
13680 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
13681 /*entering_scope=*/0);
13684 case IDENTIFIER_NODE
:
13695 if (t
== integer_type_node
)
13698 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
13699 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
13703 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
13705 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
13706 /*integral_constant_expression_p=*/false);
13708 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
13710 if (TREE_CODE (max
) == NOP_EXPR
13711 && TREE_SIDE_EFFECTS (omax
)
13712 && !TREE_TYPE (max
))
13713 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
13715 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
13716 with TREE_SIDE_EFFECTS that indicates this is not an integral
13717 constant expression. */
13718 if (processing_template_decl
13719 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
13721 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
13722 TREE_SIDE_EFFECTS (max
) = 1;
13725 return compute_array_index_type (NULL_TREE
, max
, complain
);
13728 case TEMPLATE_TYPE_PARM
:
13729 case TEMPLATE_TEMPLATE_PARM
:
13730 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13731 case TEMPLATE_PARM_INDEX
:
13736 tree arg
= NULL_TREE
;
13738 /* Early in template argument deduction substitution, we don't
13739 want to reduce the level of 'auto', or it will be confused
13740 with a normal template parm in subsequent deduction. */
13741 if (is_auto (t
) && (complain
& tf_partial
))
13746 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
13747 template_parm_level_and_index (t
, &level
, &idx
);
13749 levels
= TMPL_ARGS_DEPTH (args
);
13750 if (level
<= levels
13751 && TREE_VEC_LENGTH (TMPL_ARGS_LEVEL (args
, level
)) > 0)
13753 arg
= TMPL_ARG (args
, level
, idx
);
13755 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
13757 /* See through ARGUMENT_PACK_SELECT arguments. */
13758 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
13759 /* If the selected argument is an expansion E, that most
13760 likely means we were called from
13761 gen_elem_of_pack_expansion_instantiation during the
13762 substituting of pack an argument pack (which Ith
13763 element is a pack expansion, where I is
13764 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
13765 In this case, the Ith element resulting from this
13766 substituting is going to be a pack expansion, which
13767 pattern is the pattern of E. Let's return the
13769 gen_elem_of_pack_expansion_instantiation will
13770 build the resulting pack expansion from it. */
13771 if (PACK_EXPANSION_P (arg
))
13773 /* Make sure we aren't throwing away arg info. */
13774 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
13775 arg
= PACK_EXPANSION_PATTERN (arg
);
13780 if (arg
== error_mark_node
)
13781 return error_mark_node
;
13782 else if (arg
!= NULL_TREE
)
13784 if (ARGUMENT_PACK_P (arg
))
13785 /* If ARG is an argument pack, we don't actually want to
13786 perform a substitution here, because substitutions
13787 for argument packs are only done
13788 element-by-element. We can get to this point when
13789 substituting the type of a non-type template
13790 parameter pack, when that type actually contains
13791 template parameter packs from an outer template, e.g.,
13793 template<typename... Types> struct A {
13794 template<Types... Values> struct B { };
13798 if (code
== TEMPLATE_TYPE_PARM
)
13801 gcc_assert (TYPE_P (arg
));
13803 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
13805 return cp_build_qualified_type_real
13806 (arg
, quals
, complain
| tf_ignore_bad_quals
);
13808 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
13810 /* We are processing a type constructed from a
13811 template template parameter. */
13812 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
13813 args
, complain
, in_decl
);
13814 if (argvec
== error_mark_node
)
13815 return error_mark_node
;
13817 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
13818 || TREE_CODE (arg
) == TEMPLATE_DECL
13819 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
13821 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
13822 /* Consider this code:
13824 template <template <class> class Template>
13826 template <class Arg> using Bind = Template<Arg>;
13829 template <template <class> class Template, class Arg>
13830 using Instantiate = Template<Arg>; //#0
13832 template <template <class> class Template,
13835 Instantiate<Internal<Template>::template Bind,
13838 When #1 is parsed, the
13839 BOUND_TEMPLATE_TEMPLATE_PARM representing the
13840 parameter `Template' in #0 matches the
13841 UNBOUND_CLASS_TEMPLATE representing the argument
13842 `Internal<Template>::template Bind'; We then want
13843 to assemble the type `Bind<Argument>' that can't
13844 be fully created right now, because
13845 `Internal<Template>' not being complete, the Bind
13846 template cannot be looked up in that context. So
13847 we need to "store" `Bind<Argument>' for later
13848 when the context of Bind becomes complete. Let's
13849 store that in a TYPENAME_TYPE. */
13850 return make_typename_type (TYPE_CONTEXT (arg
),
13851 build_nt (TEMPLATE_ID_EXPR
,
13852 TYPE_IDENTIFIER (arg
),
13857 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
13858 are resolving nested-types in the signature of a
13859 member function templates. Otherwise ARG is a
13860 TEMPLATE_DECL and is the real template to be
13862 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
13863 arg
= TYPE_NAME (arg
);
13865 r
= lookup_template_class (arg
,
13867 DECL_CONTEXT (arg
),
13868 /*entering_scope=*/0,
13870 return cp_build_qualified_type_real
13871 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
13873 else if (code
== TEMPLATE_TEMPLATE_PARM
)
13876 /* TEMPLATE_PARM_INDEX. */
13877 return convert_from_reference (unshare_expr (arg
));
13881 /* This can happen during the attempted tsubst'ing in
13882 unify. This means that we don't yet have any information
13883 about the template parameter in question. */
13886 /* If we get here, we must have been looking at a parm for a
13887 more deeply nested template. Make a new version of this
13888 template parameter, but with a lower level. */
13891 case TEMPLATE_TYPE_PARM
:
13892 case TEMPLATE_TEMPLATE_PARM
:
13893 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13894 if (cp_type_quals (t
))
13896 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
13897 r
= cp_build_qualified_type_real
13898 (r
, cp_type_quals (t
),
13899 complain
| (code
== TEMPLATE_TYPE_PARM
13900 ? tf_ignore_bad_quals
: 0));
13902 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
13903 && PLACEHOLDER_TYPE_CONSTRAINTS (t
)
13904 && (r
= (TEMPLATE_PARM_DESCENDANTS
13905 (TEMPLATE_TYPE_PARM_INDEX (t
))))
13906 && (r
= TREE_TYPE (r
))
13907 && !PLACEHOLDER_TYPE_CONSTRAINTS (r
))
13908 /* Break infinite recursion when substituting the constraints
13909 of a constrained placeholder. */;
13913 TEMPLATE_TYPE_PARM_INDEX (r
)
13914 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
13915 r
, levels
, args
, complain
);
13916 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
13917 TYPE_MAIN_VARIANT (r
) = r
;
13918 TYPE_POINTER_TO (r
) = NULL_TREE
;
13919 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
13921 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
13923 /* Propagate constraints on placeholders. */
13924 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
13925 PLACEHOLDER_TYPE_CONSTRAINTS (r
)
13926 = tsubst_constraint (constr
, args
, complain
, in_decl
);
13927 else if (tree pl
= CLASS_PLACEHOLDER_TEMPLATE (t
))
13929 if (DECL_TEMPLATE_TEMPLATE_PARM_P (pl
))
13930 pl
= tsubst (pl
, args
, complain
, in_decl
);
13931 CLASS_PLACEHOLDER_TEMPLATE (r
) = pl
;
13935 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
13936 /* We have reduced the level of the template
13937 template parameter, but not the levels of its
13938 template parameters, so canonical_type_parameter
13939 will not be able to find the canonical template
13940 template parameter for this level. Thus, we
13941 require structural equality checking to compare
13942 TEMPLATE_TEMPLATE_PARMs. */
13943 SET_TYPE_STRUCTURAL_EQUALITY (r
);
13944 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
13945 SET_TYPE_STRUCTURAL_EQUALITY (r
);
13947 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
13949 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
13951 tree tinfo
= TYPE_TEMPLATE_INFO (t
);
13952 /* We might need to substitute into the types of non-type
13953 template parameters. */
13954 tree tmpl
= tsubst (TI_TEMPLATE (tinfo
), args
,
13955 complain
, in_decl
);
13956 if (tmpl
== error_mark_node
)
13957 return error_mark_node
;
13958 tree argvec
= tsubst (TI_ARGS (tinfo
), args
,
13959 complain
, in_decl
);
13960 if (argvec
== error_mark_node
)
13961 return error_mark_node
;
13963 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
13964 = build_template_info (tmpl
, argvec
);
13969 case TEMPLATE_PARM_INDEX
:
13970 /* OK, now substitute the type of the non-type parameter. We
13971 couldn't do it earlier because it might be an auto parameter,
13972 and we wouldn't need to if we had an argument. */
13973 type
= tsubst (type
, args
, complain
, in_decl
);
13974 if (type
== error_mark_node
)
13975 return error_mark_node
;
13976 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
13980 gcc_unreachable ();
13988 tree purpose
, value
, chain
;
13990 if (t
== void_list_node
)
13993 purpose
= TREE_PURPOSE (t
);
13996 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
13997 if (purpose
== error_mark_node
)
13998 return error_mark_node
;
14000 value
= TREE_VALUE (t
);
14003 value
= tsubst (value
, args
, complain
, in_decl
);
14004 if (value
== error_mark_node
)
14005 return error_mark_node
;
14007 chain
= TREE_CHAIN (t
);
14008 if (chain
&& chain
!= void_type_node
)
14010 chain
= tsubst (chain
, args
, complain
, in_decl
);
14011 if (chain
== error_mark_node
)
14012 return error_mark_node
;
14014 if (purpose
== TREE_PURPOSE (t
)
14015 && value
== TREE_VALUE (t
)
14016 && chain
== TREE_CHAIN (t
))
14018 return hash_tree_cons (purpose
, value
, chain
);
14022 /* We should never be tsubsting a binfo. */
14023 gcc_unreachable ();
14026 /* A vector of template arguments. */
14027 gcc_assert (!type
);
14028 return tsubst_template_args (t
, args
, complain
, in_decl
);
14031 case REFERENCE_TYPE
:
14033 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
14038 Type deduction may fail for any of the following
14041 -- Attempting to create a pointer to reference type.
14042 -- Attempting to create a reference to a reference type or
14043 a reference to void.
14045 Core issue 106 says that creating a reference to a reference
14046 during instantiation is no longer a cause for failure. We
14047 only enforce this check in strict C++98 mode. */
14048 if ((TREE_CODE (type
) == REFERENCE_TYPE
14049 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
14050 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
14052 static location_t last_loc
;
14054 /* We keep track of the last time we issued this error
14055 message to avoid spewing a ton of messages during a
14056 single bad template instantiation. */
14057 if (complain
& tf_error
14058 && last_loc
!= input_location
)
14060 if (VOID_TYPE_P (type
))
14061 error ("forming reference to void");
14062 else if (code
== POINTER_TYPE
)
14063 error ("forming pointer to reference type %qT", type
);
14065 error ("forming reference to reference type %qT", type
);
14066 last_loc
= input_location
;
14069 return error_mark_node
;
14071 else if (TREE_CODE (type
) == FUNCTION_TYPE
14072 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
14073 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
14075 if (complain
& tf_error
)
14077 if (code
== POINTER_TYPE
)
14078 error ("forming pointer to qualified function type %qT",
14081 error ("forming reference to qualified function type %qT",
14084 return error_mark_node
;
14086 else if (code
== POINTER_TYPE
)
14088 r
= build_pointer_type (type
);
14089 if (TREE_CODE (type
) == METHOD_TYPE
)
14090 r
= build_ptrmemfunc_type (r
);
14092 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
14093 /* In C++0x, during template argument substitution, when there is an
14094 attempt to create a reference to a reference type, reference
14095 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
14097 "If a template-argument for a template-parameter T names a type
14098 that is a reference to a type A, an attempt to create the type
14099 'lvalue reference to cv T' creates the type 'lvalue reference to
14100 A,' while an attempt to create the type type rvalue reference to
14101 cv T' creates the type T"
14103 r
= cp_build_reference_type
14105 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
14107 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
14108 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
14110 if (r
!= error_mark_node
)
14111 /* Will this ever be needed for TYPE_..._TO values? */
14118 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
14119 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
14123 Type deduction may fail for any of the following
14126 -- Attempting to create "pointer to member of T" when T
14127 is not a class type. */
14128 if (complain
& tf_error
)
14129 error ("creating pointer to member of non-class type %qT", r
);
14130 return error_mark_node
;
14132 if (TREE_CODE (type
) == REFERENCE_TYPE
)
14134 if (complain
& tf_error
)
14135 error ("creating pointer to member reference type %qT", type
);
14136 return error_mark_node
;
14138 if (VOID_TYPE_P (type
))
14140 if (complain
& tf_error
)
14141 error ("creating pointer to member of type void");
14142 return error_mark_node
;
14144 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
14145 if (TREE_CODE (type
) == FUNCTION_TYPE
)
14147 /* The type of the implicit object parameter gets its
14148 cv-qualifiers from the FUNCTION_TYPE. */
14151 = build_memfn_type (type
, r
, type_memfn_quals (type
),
14152 type_memfn_rqual (type
));
14153 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
14154 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
14158 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
14162 case FUNCTION_TYPE
:
14167 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
14168 if (fntype
== error_mark_node
)
14169 return error_mark_node
;
14171 /* Substitute the exception specification. */
14172 specs
= tsubst_exception_specification (t
, args
, complain
, in_decl
,
14173 /*defer_ok*/fndecl_type
);
14174 if (specs
== error_mark_node
)
14175 return error_mark_node
;
14177 fntype
= build_exception_variant (fntype
, specs
);
14182 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
14183 if (domain
== error_mark_node
)
14184 return error_mark_node
;
14186 /* As an optimization, we avoid regenerating the array type if
14187 it will obviously be the same as T. */
14188 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
14191 /* These checks should match the ones in create_array_type_for_decl.
14195 The deduction may fail for any of the following reasons:
14197 -- Attempting to create an array with an element type that
14198 is void, a function type, or a reference type, or [DR337]
14199 an abstract class type. */
14200 if (VOID_TYPE_P (type
)
14201 || TREE_CODE (type
) == FUNCTION_TYPE
14202 || (TREE_CODE (type
) == ARRAY_TYPE
14203 && TYPE_DOMAIN (type
) == NULL_TREE
)
14204 || TREE_CODE (type
) == REFERENCE_TYPE
)
14206 if (complain
& tf_error
)
14207 error ("creating array of %qT", type
);
14208 return error_mark_node
;
14211 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
14212 return error_mark_node
;
14214 r
= build_cplus_array_type (type
, domain
);
14216 if (TYPE_USER_ALIGN (t
))
14218 SET_TYPE_ALIGN (r
, TYPE_ALIGN (t
));
14219 TYPE_USER_ALIGN (r
) = 1;
14225 case TYPENAME_TYPE
:
14227 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
14228 in_decl
, /*entering_scope=*/1);
14229 if (ctx
== error_mark_node
)
14230 return error_mark_node
;
14232 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
14233 complain
, in_decl
);
14234 if (f
== error_mark_node
)
14235 return error_mark_node
;
14237 if (!MAYBE_CLASS_TYPE_P (ctx
))
14239 if (complain
& tf_error
)
14240 error ("%qT is not a class, struct, or union type", ctx
);
14241 return error_mark_node
;
14243 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
14245 /* Normally, make_typename_type does not require that the CTX
14246 have complete type in order to allow things like:
14248 template <class T> struct S { typename S<T>::X Y; };
14250 But, such constructs have already been resolved by this
14251 point, so here CTX really should have complete type, unless
14252 it's a partial instantiation. */
14253 ctx
= complete_type (ctx
);
14254 if (!COMPLETE_TYPE_P (ctx
))
14256 if (complain
& tf_error
)
14257 cxx_incomplete_type_error (NULL_TREE
, ctx
);
14258 return error_mark_node
;
14262 f
= make_typename_type (ctx
, f
, typename_type
,
14263 complain
| tf_keep_type_decl
);
14264 if (f
== error_mark_node
)
14266 if (TREE_CODE (f
) == TYPE_DECL
)
14268 complain
|= tf_ignore_bad_quals
;
14272 if (TREE_CODE (f
) != TYPENAME_TYPE
)
14274 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
14276 if (complain
& tf_error
)
14277 error ("%qT resolves to %qT, which is not an enumeration type",
14280 return error_mark_node
;
14282 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
14284 if (complain
& tf_error
)
14285 error ("%qT resolves to %qT, which is is not a class type",
14288 return error_mark_node
;
14292 return cp_build_qualified_type_real
14293 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
14296 case UNBOUND_CLASS_TEMPLATE
:
14298 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
14299 in_decl
, /*entering_scope=*/1);
14300 tree name
= TYPE_IDENTIFIER (t
);
14301 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
14303 if (ctx
== error_mark_node
|| name
== error_mark_node
)
14304 return error_mark_node
;
14307 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
14308 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
14315 ++cp_unevaluated_operand
;
14316 ++c_inhibit_evaluation_warnings
;
14318 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
14320 /*integral_constant_expression_p=*/false);
14322 --cp_unevaluated_operand
;
14323 --c_inhibit_evaluation_warnings
;
14325 type
= finish_typeof (type
);
14326 return cp_build_qualified_type_real (type
,
14328 | cp_type_quals (type
),
14332 case DECLTYPE_TYPE
:
14336 ++cp_unevaluated_operand
;
14337 ++c_inhibit_evaluation_warnings
;
14339 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
14340 complain
|tf_decltype
, in_decl
,
14341 /*function_p*/false,
14342 /*integral_constant_expression*/false);
14344 if (DECLTYPE_FOR_INIT_CAPTURE (t
))
14346 if (type
== NULL_TREE
)
14348 if (complain
& tf_error
)
14349 error ("empty initializer in lambda init-capture");
14350 type
= error_mark_node
;
14352 else if (TREE_CODE (type
) == TREE_LIST
)
14353 type
= build_x_compound_expr_from_list (type
, ELK_INIT
, complain
);
14356 --cp_unevaluated_operand
;
14357 --c_inhibit_evaluation_warnings
;
14359 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
14360 type
= lambda_capture_field_type (type
,
14361 DECLTYPE_FOR_INIT_CAPTURE (t
),
14362 DECLTYPE_FOR_REF_CAPTURE (t
));
14363 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
14364 type
= lambda_proxy_type (type
);
14367 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
14368 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
14370 /* In a template ~id could be either a complement expression
14371 or an unqualified-id naming a destructor; if instantiating
14372 it produces an expression, it's not an id-expression or
14375 type
= finish_decltype_type (type
, id
, complain
);
14377 return cp_build_qualified_type_real (type
,
14379 | cp_type_quals (type
),
14380 complain
| tf_ignore_bad_quals
);
14383 case UNDERLYING_TYPE
:
14385 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
14386 complain
, in_decl
);
14387 return finish_underlying_type (type
);
14390 case TYPE_ARGUMENT_PACK
:
14391 case NONTYPE_ARGUMENT_PACK
:
14395 if (code
== NONTYPE_ARGUMENT_PACK
)
14396 r
= make_node (code
);
14398 r
= cxx_make_type (code
);
14400 tree pack_args
= ARGUMENT_PACK_ARGS (t
);
14401 pack_args
= tsubst_template_args (pack_args
, args
, complain
, in_decl
);
14402 SET_ARGUMENT_PACK_ARGS (r
, pack_args
);
14420 /* We should use one of the expression tsubsts for these codes. */
14421 gcc_unreachable ();
14424 sorry ("use of %qs in template", get_tree_code_name (code
));
14425 return error_mark_node
;
14429 /* tsubst a BASELINK. OBJECT_TYPE, if non-NULL, is the type of the
14430 expression on the left-hand side of the "." or "->" operator. We
14431 only do the lookup if we had a dependent BASELINK. Otherwise we
14432 adjust it onto the instantiated heirarchy. */
14435 tsubst_baselink (tree baselink
, tree object_type
,
14436 tree args
, tsubst_flags_t complain
, tree in_decl
)
14438 bool qualified_p
= BASELINK_QUALIFIED_P (baselink
);
14439 tree qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
14440 qualifying_scope
= tsubst (qualifying_scope
, args
, complain
, in_decl
);
14442 tree optype
= BASELINK_OPTYPE (baselink
);
14443 optype
= tsubst (optype
, args
, complain
, in_decl
);
14445 tree template_args
= NULL_TREE
;
14446 bool template_id_p
= false;
14447 tree fns
= BASELINK_FUNCTIONS (baselink
);
14448 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
14450 template_id_p
= true;
14451 template_args
= TREE_OPERAND (fns
, 1);
14452 fns
= TREE_OPERAND (fns
, 0);
14454 template_args
= tsubst_template_args (template_args
, args
,
14455 complain
, in_decl
);
14458 tree binfo_type
= BINFO_TYPE (BASELINK_BINFO (baselink
));
14459 binfo_type
= tsubst (binfo_type
, args
, complain
, in_decl
);
14460 bool dependent_p
= binfo_type
!= BINFO_TYPE (BASELINK_BINFO (baselink
));
14464 tree name
= OVL_NAME (fns
);
14465 if (IDENTIFIER_CONV_OP_P (name
))
14466 name
= make_conv_op_name (optype
);
14468 if (name
== complete_dtor_identifier
)
14469 /* Treat as-if non-dependent below. */
14470 dependent_p
= false;
14472 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
14475 if ((complain
& tf_error
)
14476 && constructor_name_p (name
, qualifying_scope
))
14477 error ("cannot call constructor %<%T::%D%> directly",
14478 qualifying_scope
, name
);
14479 return error_mark_node
;
14482 if (BASELINK_P (baselink
))
14483 fns
= BASELINK_FUNCTIONS (baselink
);
14487 gcc_assert (optype
== BASELINK_OPTYPE (baselink
));
14488 /* We're going to overwrite pieces below, make a duplicate. */
14489 baselink
= copy_node (baselink
);
14492 /* If lookup found a single function, mark it as used at this point.
14493 (If lookup found multiple functions the one selected later by
14494 overload resolution will be marked as used at that point.) */
14495 if (!template_id_p
&& !really_overloaded_fn (fns
)
14496 && !mark_used (OVL_FIRST (fns
), complain
) && !(complain
& tf_error
))
14497 return error_mark_node
;
14499 if (BASELINK_P (baselink
))
14501 /* Add back the template arguments, if present. */
14503 BASELINK_FUNCTIONS (baselink
)
14504 = build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fns
, template_args
);
14506 /* Update the conversion operator type. */
14507 BASELINK_OPTYPE (baselink
) = optype
;
14511 object_type
= current_class_type
;
14513 if (qualified_p
|| !dependent_p
)
14515 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
14519 /* We need to call adjust_result_of_qualified_name_lookup in case the
14520 destructor names a base class, but we unset BASELINK_QUALIFIED_P
14521 so that we still get virtual function binding. */
14522 BASELINK_QUALIFIED_P (baselink
) = false;
14528 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
14529 true if the qualified-id will be a postfix-expression in-and-of
14530 itself; false if more of the postfix-expression follows the
14531 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
14535 tsubst_qualified_id (tree qualified_id
, tree args
,
14536 tsubst_flags_t complain
, tree in_decl
,
14537 bool done
, bool address_p
)
14543 tree template_args
;
14544 location_t loc
= UNKNOWN_LOCATION
;
14546 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
14548 /* Figure out what name to look up. */
14549 name
= TREE_OPERAND (qualified_id
, 1);
14550 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
14552 is_template
= true;
14553 loc
= EXPR_LOCATION (name
);
14554 template_args
= TREE_OPERAND (name
, 1);
14556 template_args
= tsubst_template_args (template_args
, args
,
14557 complain
, in_decl
);
14558 if (template_args
== error_mark_node
)
14559 return error_mark_node
;
14560 name
= TREE_OPERAND (name
, 0);
14564 is_template
= false;
14565 template_args
= NULL_TREE
;
14568 /* Substitute into the qualifying scope. When there are no ARGS, we
14569 are just trying to simplify a non-dependent expression. In that
14570 case the qualifying scope may be dependent, and, in any case,
14571 substituting will not help. */
14572 scope
= TREE_OPERAND (qualified_id
, 0);
14575 scope
= tsubst (scope
, args
, complain
, in_decl
);
14576 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
14581 if (dependent_scope_p (scope
))
14584 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
14585 tree r
= build_qualified_name (NULL_TREE
, scope
, expr
,
14586 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
14587 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (qualified_id
);
14591 if (!BASELINK_P (name
) && !DECL_P (expr
))
14593 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
14595 /* A BIT_NOT_EXPR is used to represent a destructor. */
14596 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
14598 error ("qualifying type %qT does not match destructor name ~%qT",
14599 scope
, TREE_OPERAND (expr
, 0));
14600 expr
= error_mark_node
;
14603 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
14604 /*is_type_p=*/0, false);
14607 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
14608 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
14609 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
14611 if (complain
& tf_error
)
14613 error ("dependent-name %qE is parsed as a non-type, but "
14614 "instantiation yields a type", qualified_id
);
14615 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
14617 return error_mark_node
;
14623 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
14625 /* Remember that there was a reference to this entity. */
14626 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
14627 return error_mark_node
;
14630 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
14632 if (complain
& tf_error
)
14633 qualified_name_lookup_error (scope
,
14634 TREE_OPERAND (qualified_id
, 1),
14635 expr
, input_location
);
14636 return error_mark_node
;
14641 if (variable_template_p (expr
))
14642 expr
= lookup_and_finish_template_variable (expr
, template_args
,
14645 expr
= lookup_template_function (expr
, template_args
);
14648 if (expr
== error_mark_node
&& complain
& tf_error
)
14649 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
14650 expr
, input_location
);
14651 else if (TYPE_P (scope
))
14653 expr
= (adjust_result_of_qualified_name_lookup
14654 (expr
, scope
, current_nonlambda_class_type ()));
14655 expr
= (finish_qualified_id_expr
14656 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
14657 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
14658 /*template_arg_p=*/false, complain
));
14661 /* Expressions do not generally have reference type. */
14662 if (TREE_CODE (expr
) != SCOPE_REF
14663 /* However, if we're about to form a pointer-to-member, we just
14664 want the referenced member referenced. */
14665 && TREE_CODE (expr
) != OFFSET_REF
)
14666 expr
= convert_from_reference (expr
);
14668 if (REF_PARENTHESIZED_P (qualified_id
))
14669 expr
= force_paren_expr (expr
);
14674 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
14675 initializer, DECL is the substituted VAR_DECL. Other arguments are as
14679 tsubst_init (tree init
, tree decl
, tree args
,
14680 tsubst_flags_t complain
, tree in_decl
)
14685 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
14687 if (!init
&& TREE_TYPE (decl
) != error_mark_node
)
14689 /* If we had an initializer but it
14690 instantiated to nothing,
14691 value-initialize the object. This will
14692 only occur when the initializer was a
14693 pack expansion where the parameter packs
14694 used in that expansion were of length
14696 init
= build_value_init (TREE_TYPE (decl
),
14698 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
14699 init
= get_target_expr_sfinae (init
, complain
);
14700 if (TREE_CODE (init
) == TARGET_EXPR
)
14701 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
14707 /* Like tsubst, but deals with expressions. This function just replaces
14708 template parms; to finish processing the resultant expression, use
14709 tsubst_copy_and_build or tsubst_expr. */
14712 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14714 enum tree_code code
;
14717 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
14720 code
= TREE_CODE (t
);
14725 r
= retrieve_local_specialization (t
);
14727 if (r
== NULL_TREE
)
14729 /* We get here for a use of 'this' in an NSDMI. */
14730 if (DECL_NAME (t
) == this_identifier
&& current_class_ptr
)
14731 return current_class_ptr
;
14733 /* This can happen for a parameter name used later in a function
14734 declaration (such as in a late-specified return type). Just
14735 make a dummy decl, since it's only used for its type. */
14736 gcc_assert (cp_unevaluated_operand
!= 0);
14737 r
= tsubst_decl (t
, args
, complain
);
14738 /* Give it the template pattern as its context; its true context
14739 hasn't been instantiated yet and this is good enough for
14741 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
14744 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
14745 r
= ARGUMENT_PACK_SELECT_ARG (r
);
14746 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
14747 return error_mark_node
;
14755 if (DECL_TEMPLATE_PARM_P (t
))
14756 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
14757 /* There is no need to substitute into namespace-scope
14759 if (DECL_NAMESPACE_SCOPE_P (t
))
14761 /* If ARGS is NULL, then T is known to be non-dependent. */
14762 if (args
== NULL_TREE
)
14763 return scalar_constant_value (t
);
14765 /* Unfortunately, we cannot just call lookup_name here.
14768 template <int I> int f() {
14770 struct S { void g() { E e = a; } };
14773 When we instantiate f<7>::S::g(), say, lookup_name is not
14774 clever enough to find f<7>::a. */
14776 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
14777 /*entering_scope=*/0);
14779 for (v
= TYPE_VALUES (enum_type
);
14781 v
= TREE_CHAIN (v
))
14782 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
14783 return TREE_VALUE (v
);
14785 /* We didn't find the name. That should never happen; if
14786 name-lookup found it during preliminary parsing, we
14787 should find it again here during instantiation. */
14788 gcc_unreachable ();
14793 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
14795 /* Check for a local specialization set up by
14796 tsubst_pack_expansion. */
14797 if (tree r
= retrieve_local_specialization (t
))
14799 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
14800 r
= ARGUMENT_PACK_SELECT_ARG (r
);
14804 /* When retrieving a capture pack from a generic lambda, remove the
14805 lambda call op's own template argument list from ARGS. Only the
14806 template arguments active for the closure type should be used to
14807 retrieve the pack specialization. */
14808 if (LAMBDA_FUNCTION_P (current_function_decl
)
14809 && (template_class_depth (DECL_CONTEXT (t
))
14810 != TMPL_ARGS_DEPTH (args
)))
14811 args
= strip_innermost_template_args (args
, 1);
14813 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
14814 tsubst_decl put in the hash table. */
14815 return retrieve_specialization (t
, args
, 0);
14818 if (DECL_CONTEXT (t
))
14822 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
14823 /*entering_scope=*/1);
14824 if (ctx
!= DECL_CONTEXT (t
))
14826 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
14829 if (complain
& tf_error
)
14830 error ("using invalid field %qD", t
);
14831 return error_mark_node
;
14840 case FUNCTION_DECL
:
14841 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
14842 r
= tsubst (t
, args
, complain
, in_decl
);
14843 else if (local_variable_p (t
)
14844 && uses_template_parms (DECL_CONTEXT (t
)))
14846 r
= retrieve_local_specialization (t
);
14847 if (r
== NULL_TREE
)
14849 /* First try name lookup to find the instantiation. */
14850 r
= lookup_name (DECL_NAME (t
));
14851 if (r
&& !is_capture_proxy (r
))
14853 /* Make sure that the one we found is the one we want. */
14854 tree ctx
= enclosing_instantiation_of (DECL_CONTEXT (t
));
14855 if (ctx
!= DECL_CONTEXT (r
))
14863 /* This can happen for a variable used in a
14864 late-specified return type of a local lambda, or for a
14865 local static or constant. Building a new VAR_DECL
14866 should be OK in all those cases. */
14867 r
= tsubst_decl (t
, args
, complain
);
14868 if (local_specializations
)
14869 /* Avoid infinite recursion (79640). */
14870 register_local_specialization (r
, t
);
14871 if (decl_maybe_constant_var_p (r
))
14873 /* We can't call cp_finish_decl, so handle the
14874 initializer by hand. */
14875 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
14876 complain
, in_decl
);
14877 if (!processing_template_decl
)
14878 init
= maybe_constant_init (init
);
14879 if (processing_template_decl
14880 ? potential_constant_expression (init
)
14881 : reduced_constant_expression_p (init
))
14882 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
14883 = TREE_CONSTANT (r
) = true;
14884 DECL_INITIAL (r
) = init
;
14885 if (tree auto_node
= type_uses_auto (TREE_TYPE (r
)))
14887 = do_auto_deduction (TREE_TYPE (r
), init
, auto_node
,
14888 complain
, adc_variable_type
);
14890 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
14891 || decl_constant_var_p (r
)
14892 || errorcount
|| sorrycount
);
14893 if (!processing_template_decl
14894 && !TREE_STATIC (r
))
14895 r
= process_outer_var_ref (r
, complain
);
14897 /* Remember this for subsequent uses. */
14898 if (local_specializations
)
14899 register_local_specialization (r
, t
);
14904 if (!mark_used (r
, complain
))
14905 return error_mark_node
;
14908 case NAMESPACE_DECL
:
14912 /* An OVERLOAD will always be a non-dependent overload set; an
14913 overload set from function scope will just be represented with an
14914 IDENTIFIER_NODE, and from class scope with a BASELINK. */
14915 gcc_assert (!uses_template_parms (t
));
14916 /* We must have marked any lookups as persistent. */
14917 gcc_assert (!OVL_LOOKUP_P (t
) || OVL_USED_P (t
));
14921 return tsubst_baselink (t
, current_nonlambda_class_type (),
14922 args
, complain
, in_decl
);
14924 case TEMPLATE_DECL
:
14925 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
14926 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
14927 args
, complain
, in_decl
);
14928 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
14929 return tsubst (t
, args
, complain
, in_decl
);
14930 else if (DECL_CLASS_SCOPE_P (t
)
14931 && uses_template_parms (DECL_CONTEXT (t
)))
14933 /* Template template argument like the following example need
14936 template <template <class> class TT> struct C {};
14937 template <class T> struct D {
14938 template <class U> struct E {};
14943 We are processing the template argument `E' in #1 for
14944 the template instantiation #2. Originally, `E' is a
14945 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
14946 have to substitute this with one having context `D<int>'. */
14948 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
14949 if (dependent_scope_p (context
))
14951 /* When rewriting a constructor into a deduction guide, a
14952 non-dependent name can become dependent, so memtmpl<args>
14953 becomes context::template memtmpl<args>. */
14954 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14955 return build_qualified_name (type
, context
, DECL_NAME (t
),
14958 return lookup_field (context
, DECL_NAME(t
), 0, false);
14961 /* Ordinary template template argument. */
14965 case REINTERPRET_CAST_EXPR
:
14966 case CONST_CAST_EXPR
:
14967 case STATIC_CAST_EXPR
:
14968 case DYNAMIC_CAST_EXPR
:
14969 case IMPLICIT_CONV_EXPR
:
14973 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14974 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14975 return build1 (code
, type
, op0
);
14979 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
14980 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
14982 tree expanded
, op
= TREE_OPERAND (t
, 0);
14985 if (SIZEOF_EXPR_TYPE_P (t
))
14986 op
= TREE_TYPE (op
);
14988 ++cp_unevaluated_operand
;
14989 ++c_inhibit_evaluation_warnings
;
14990 /* We only want to compute the number of arguments. */
14991 if (PACK_EXPANSION_P (op
))
14992 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
14994 expanded
= tsubst_template_args (ARGUMENT_PACK_ARGS (op
),
14995 args
, complain
, in_decl
);
14996 --cp_unevaluated_operand
;
14997 --c_inhibit_evaluation_warnings
;
14999 if (TREE_CODE (expanded
) == TREE_VEC
)
15001 len
= TREE_VEC_LENGTH (expanded
);
15002 /* Set TREE_USED for the benefit of -Wunused. */
15003 for (int i
= 0; i
< len
; i
++)
15004 if (DECL_P (TREE_VEC_ELT (expanded
, i
)))
15005 TREE_USED (TREE_VEC_ELT (expanded
, i
)) = true;
15008 if (expanded
== error_mark_node
)
15009 return error_mark_node
;
15010 else if (PACK_EXPANSION_P (expanded
)
15011 || (TREE_CODE (expanded
) == TREE_VEC
15012 && pack_expansion_args_count (expanded
)))
15015 if (PACK_EXPANSION_P (expanded
))
15017 else if (TREE_VEC_LENGTH (expanded
) == 1)
15018 expanded
= TREE_VEC_ELT (expanded
, 0);
15020 expanded
= make_argument_pack (expanded
);
15022 if (TYPE_P (expanded
))
15023 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
15024 complain
& tf_error
);
15026 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
15027 complain
& tf_error
);
15030 return build_int_cst (size_type_node
, len
);
15032 if (SIZEOF_EXPR_TYPE_P (t
))
15034 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
15035 args
, complain
, in_decl
);
15036 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
15037 r
= build1 (SIZEOF_EXPR
,
15038 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
15039 SIZEOF_EXPR_TYPE_P (r
) = 1;
15046 case TRUTH_NOT_EXPR
:
15049 case UNARY_PLUS_EXPR
: /* Unary + */
15051 case AT_ENCODE_EXPR
:
15055 case REALPART_EXPR
:
15056 case IMAGPART_EXPR
:
15059 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15060 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15061 return build1 (code
, type
, op0
);
15064 case COMPONENT_REF
:
15069 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15070 name
= TREE_OPERAND (t
, 1);
15071 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
15073 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15074 complain
, in_decl
);
15075 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
15077 else if (TREE_CODE (name
) == SCOPE_REF
15078 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
15080 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15081 complain
, in_decl
);
15082 name
= TREE_OPERAND (name
, 1);
15083 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15084 complain
, in_decl
);
15085 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
15086 name
= build_qualified_name (/*type=*/NULL_TREE
,
15088 /*template_p=*/false);
15090 else if (BASELINK_P (name
))
15091 name
= tsubst_baselink (name
,
15092 non_reference (TREE_TYPE (object
)),
15096 name
= tsubst_copy (name
, args
, complain
, in_decl
);
15097 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
15103 case TRUNC_DIV_EXPR
:
15104 case CEIL_DIV_EXPR
:
15105 case FLOOR_DIV_EXPR
:
15106 case ROUND_DIV_EXPR
:
15107 case EXACT_DIV_EXPR
:
15111 case TRUNC_MOD_EXPR
:
15112 case FLOOR_MOD_EXPR
:
15113 case TRUTH_ANDIF_EXPR
:
15114 case TRUTH_ORIF_EXPR
:
15115 case TRUTH_AND_EXPR
:
15116 case TRUTH_OR_EXPR
:
15129 case COMPOUND_EXPR
:
15132 case PREDECREMENT_EXPR
:
15133 case PREINCREMENT_EXPR
:
15134 case POSTDECREMENT_EXPR
:
15135 case POSTINCREMENT_EXPR
:
15137 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15138 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15139 return build_nt (code
, op0
, op1
);
15144 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15145 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15146 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
15147 QUALIFIED_NAME_IS_TEMPLATE (t
));
15152 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15153 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15154 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
15159 int n
= VL_EXP_OPERAND_LENGTH (t
);
15160 tree result
= build_vl_exp (CALL_EXPR
, n
);
15162 for (i
= 0; i
< n
; i
++)
15163 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
15164 complain
, in_decl
);
15170 case PSEUDO_DTOR_EXPR
:
15171 case VEC_PERM_EXPR
:
15173 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15174 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15175 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15176 r
= build_nt (code
, op0
, op1
, op2
);
15177 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
15183 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15184 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15185 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15186 r
= build_nt (code
, op0
, op1
, op2
);
15187 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
15193 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15194 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15195 r
= build_nt (code
, op0
, op1
);
15196 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
15197 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
15201 case TEMPLATE_ID_EXPR
:
15203 /* Substituted template arguments */
15204 tree fn
= TREE_OPERAND (t
, 0);
15205 tree targs
= TREE_OPERAND (t
, 1);
15207 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
15209 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
15211 return lookup_template_function (fn
, targs
);
15216 tree purpose
, value
, chain
;
15218 if (t
== void_list_node
)
15221 purpose
= TREE_PURPOSE (t
);
15223 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
15224 value
= TREE_VALUE (t
);
15226 value
= tsubst_copy (value
, args
, complain
, in_decl
);
15227 chain
= TREE_CHAIN (t
);
15228 if (chain
&& chain
!= void_type_node
)
15229 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
15230 if (purpose
== TREE_PURPOSE (t
)
15231 && value
== TREE_VALUE (t
)
15232 && chain
== TREE_CHAIN (t
))
15234 return tree_cons (purpose
, value
, chain
);
15239 case ENUMERAL_TYPE
:
15241 case TEMPLATE_TYPE_PARM
:
15242 case TEMPLATE_TEMPLATE_PARM
:
15243 case BOUND_TEMPLATE_TEMPLATE_PARM
:
15244 case TEMPLATE_PARM_INDEX
:
15246 case REFERENCE_TYPE
:
15248 case FUNCTION_TYPE
:
15251 case TYPENAME_TYPE
:
15252 case UNBOUND_CLASS_TEMPLATE
:
15254 case DECLTYPE_TYPE
:
15256 return tsubst (t
, args
, complain
, in_decl
);
15260 /* Fall through. */
15261 case IDENTIFIER_NODE
:
15262 if (IDENTIFIER_CONV_OP_P (t
))
15264 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15265 return make_conv_op_name (new_type
);
15271 /* This is handled by tsubst_copy_and_build. */
15272 gcc_unreachable ();
15276 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15277 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15278 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
15281 case CLEANUP_POINT_EXPR
:
15282 /* We shouldn't have built any of these during initial template
15283 generation. Instead, they should be built during instantiation
15284 in response to the saved STMT_IS_FULL_EXPR_P setting. */
15285 gcc_unreachable ();
15289 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15290 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15291 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15292 r
= build2 (code
, type
, op0
, op1
);
15293 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
15294 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
15295 && !(complain
& tf_error
))
15296 return error_mark_node
;
15300 case EXPR_PACK_EXPANSION
:
15301 error ("invalid use of pack expansion expression");
15302 return error_mark_node
;
15304 case NONTYPE_ARGUMENT_PACK
:
15305 error ("use %<...%> to expand argument pack");
15306 return error_mark_node
;
15309 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
15317 /* Instantiate any typedefs in the type. */
15318 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15319 r
= fold_convert (type
, t
);
15320 gcc_assert (TREE_CODE (r
) == code
);
15325 /* These can sometimes show up in a partial instantiation, but never
15326 involve template parms. */
15327 gcc_assert (!uses_template_parms (t
));
15330 case UNARY_LEFT_FOLD_EXPR
:
15331 return tsubst_unary_left_fold (t
, args
, complain
, in_decl
);
15332 case UNARY_RIGHT_FOLD_EXPR
:
15333 return tsubst_unary_right_fold (t
, args
, complain
, in_decl
);
15334 case BINARY_LEFT_FOLD_EXPR
:
15335 return tsubst_binary_left_fold (t
, args
, complain
, in_decl
);
15336 case BINARY_RIGHT_FOLD_EXPR
:
15337 return tsubst_binary_right_fold (t
, args
, complain
, in_decl
);
15341 case DEBUG_BEGIN_STMT
:
15342 /* ??? There's no point in copying it for now, but maybe some
15343 day it will contain more information, such as a pointer back
15344 to the containing function, inlined copy or so. */
15348 /* We shouldn't get here, but keep going if !flag_checking. */
15350 gcc_unreachable ();
15355 /* Helper function for tsubst_omp_clauses, used for instantiation of
15356 OMP_CLAUSE_DECL of clauses. */
15359 tsubst_omp_clause_decl (tree decl
, tree args
, tsubst_flags_t complain
,
15362 if (decl
== NULL_TREE
)
15365 /* Handle an OpenMP array section represented as a TREE_LIST (or
15366 OMP_CLAUSE_DEPEND_KIND). An OMP_CLAUSE_DEPEND (with a depend
15367 kind of OMP_CLAUSE_DEPEND_SINK) can also be represented as a
15368 TREE_LIST. We can handle it exactly the same as an array section
15369 (purpose, value, and a chain), even though the nomenclature
15370 (low_bound, length, etc) is different. */
15371 if (TREE_CODE (decl
) == TREE_LIST
)
15374 = tsubst_expr (TREE_PURPOSE (decl
), args
, complain
, in_decl
,
15375 /*integral_constant_expression_p=*/false);
15376 tree length
= tsubst_expr (TREE_VALUE (decl
), args
, complain
, in_decl
,
15377 /*integral_constant_expression_p=*/false);
15378 tree chain
= tsubst_omp_clause_decl (TREE_CHAIN (decl
), args
, complain
,
15380 if (TREE_PURPOSE (decl
) == low_bound
15381 && TREE_VALUE (decl
) == length
15382 && TREE_CHAIN (decl
) == chain
)
15384 tree ret
= tree_cons (low_bound
, length
, chain
);
15385 OMP_CLAUSE_DEPEND_SINK_NEGATIVE (ret
)
15386 = OMP_CLAUSE_DEPEND_SINK_NEGATIVE (decl
);
15389 tree ret
= tsubst_expr (decl
, args
, complain
, in_decl
,
15390 /*integral_constant_expression_p=*/false);
15391 /* Undo convert_from_reference tsubst_expr could have called. */
15393 && REFERENCE_REF_P (ret
)
15394 && !REFERENCE_REF_P (decl
))
15395 ret
= TREE_OPERAND (ret
, 0);
15399 /* Like tsubst_copy, but specifically for OpenMP clauses. */
15402 tsubst_omp_clauses (tree clauses
, enum c_omp_region_type ort
,
15403 tree args
, tsubst_flags_t complain
, tree in_decl
)
15405 tree new_clauses
= NULL_TREE
, nc
, oc
;
15406 tree linear_no_step
= NULL_TREE
;
15408 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
15410 nc
= copy_node (oc
);
15411 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
15414 switch (OMP_CLAUSE_CODE (nc
))
15416 case OMP_CLAUSE_LASTPRIVATE
:
15417 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
15419 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
15420 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
15421 in_decl
, /*integral_constant_expression_p=*/false);
15422 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
15423 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
15426 case OMP_CLAUSE_PRIVATE
:
15427 case OMP_CLAUSE_SHARED
:
15428 case OMP_CLAUSE_FIRSTPRIVATE
:
15429 case OMP_CLAUSE_COPYIN
:
15430 case OMP_CLAUSE_COPYPRIVATE
:
15431 case OMP_CLAUSE_UNIFORM
:
15432 case OMP_CLAUSE_DEPEND
:
15433 case OMP_CLAUSE_FROM
:
15434 case OMP_CLAUSE_TO
:
15435 case OMP_CLAUSE_MAP
:
15436 case OMP_CLAUSE_USE_DEVICE_PTR
:
15437 case OMP_CLAUSE_IS_DEVICE_PTR
:
15438 OMP_CLAUSE_DECL (nc
)
15439 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
15442 case OMP_CLAUSE_TILE
:
15443 case OMP_CLAUSE_IF
:
15444 case OMP_CLAUSE_NUM_THREADS
:
15445 case OMP_CLAUSE_SCHEDULE
:
15446 case OMP_CLAUSE_COLLAPSE
:
15447 case OMP_CLAUSE_FINAL
:
15448 case OMP_CLAUSE_DEVICE
:
15449 case OMP_CLAUSE_DIST_SCHEDULE
:
15450 case OMP_CLAUSE_NUM_TEAMS
:
15451 case OMP_CLAUSE_THREAD_LIMIT
:
15452 case OMP_CLAUSE_SAFELEN
:
15453 case OMP_CLAUSE_SIMDLEN
:
15454 case OMP_CLAUSE_NUM_TASKS
:
15455 case OMP_CLAUSE_GRAINSIZE
:
15456 case OMP_CLAUSE_PRIORITY
:
15457 case OMP_CLAUSE_ORDERED
:
15458 case OMP_CLAUSE_HINT
:
15459 case OMP_CLAUSE_NUM_GANGS
:
15460 case OMP_CLAUSE_NUM_WORKERS
:
15461 case OMP_CLAUSE_VECTOR_LENGTH
:
15462 case OMP_CLAUSE_WORKER
:
15463 case OMP_CLAUSE_VECTOR
:
15464 case OMP_CLAUSE_ASYNC
:
15465 case OMP_CLAUSE_WAIT
:
15466 OMP_CLAUSE_OPERAND (nc
, 0)
15467 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
15468 in_decl
, /*integral_constant_expression_p=*/false);
15470 case OMP_CLAUSE_REDUCTION
:
15471 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
15473 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
15474 if (TREE_CODE (placeholder
) == SCOPE_REF
)
15476 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
15477 complain
, in_decl
);
15478 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
15479 = build_qualified_name (NULL_TREE
, scope
,
15480 TREE_OPERAND (placeholder
, 1),
15484 gcc_assert (identifier_p (placeholder
));
15486 OMP_CLAUSE_DECL (nc
)
15487 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
15490 case OMP_CLAUSE_GANG
:
15491 case OMP_CLAUSE_ALIGNED
:
15492 OMP_CLAUSE_DECL (nc
)
15493 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
15495 OMP_CLAUSE_OPERAND (nc
, 1)
15496 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
15497 in_decl
, /*integral_constant_expression_p=*/false);
15499 case OMP_CLAUSE_LINEAR
:
15500 OMP_CLAUSE_DECL (nc
)
15501 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
15503 if (OMP_CLAUSE_LINEAR_STEP (oc
) == NULL_TREE
)
15505 gcc_assert (!linear_no_step
);
15506 linear_no_step
= nc
;
15508 else if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (oc
))
15509 OMP_CLAUSE_LINEAR_STEP (nc
)
15510 = tsubst_omp_clause_decl (OMP_CLAUSE_LINEAR_STEP (oc
), args
,
15511 complain
, in_decl
);
15513 OMP_CLAUSE_LINEAR_STEP (nc
)
15514 = tsubst_expr (OMP_CLAUSE_LINEAR_STEP (oc
), args
, complain
,
15516 /*integral_constant_expression_p=*/false);
15518 case OMP_CLAUSE_NOWAIT
:
15519 case OMP_CLAUSE_DEFAULT
:
15520 case OMP_CLAUSE_UNTIED
:
15521 case OMP_CLAUSE_MERGEABLE
:
15522 case OMP_CLAUSE_INBRANCH
:
15523 case OMP_CLAUSE_NOTINBRANCH
:
15524 case OMP_CLAUSE_PROC_BIND
:
15525 case OMP_CLAUSE_FOR
:
15526 case OMP_CLAUSE_PARALLEL
:
15527 case OMP_CLAUSE_SECTIONS
:
15528 case OMP_CLAUSE_TASKGROUP
:
15529 case OMP_CLAUSE_NOGROUP
:
15530 case OMP_CLAUSE_THREADS
:
15531 case OMP_CLAUSE_SIMD
:
15532 case OMP_CLAUSE_DEFAULTMAP
:
15533 case OMP_CLAUSE_INDEPENDENT
:
15534 case OMP_CLAUSE_AUTO
:
15535 case OMP_CLAUSE_SEQ
:
15538 gcc_unreachable ();
15540 if ((ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
)
15541 switch (OMP_CLAUSE_CODE (nc
))
15543 case OMP_CLAUSE_SHARED
:
15544 case OMP_CLAUSE_PRIVATE
:
15545 case OMP_CLAUSE_FIRSTPRIVATE
:
15546 case OMP_CLAUSE_LASTPRIVATE
:
15547 case OMP_CLAUSE_COPYPRIVATE
:
15548 case OMP_CLAUSE_LINEAR
:
15549 case OMP_CLAUSE_REDUCTION
:
15550 case OMP_CLAUSE_USE_DEVICE_PTR
:
15551 case OMP_CLAUSE_IS_DEVICE_PTR
:
15552 /* tsubst_expr on SCOPE_REF results in returning
15553 finish_non_static_data_member result. Undo that here. */
15554 if (TREE_CODE (OMP_CLAUSE_DECL (oc
)) == SCOPE_REF
15555 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (oc
), 1))
15556 == IDENTIFIER_NODE
))
15558 tree t
= OMP_CLAUSE_DECL (nc
);
15561 switch (TREE_CODE (v
))
15563 case COMPONENT_REF
:
15567 case POINTER_PLUS_EXPR
:
15568 v
= TREE_OPERAND (v
, 0);
15571 if (DECL_CONTEXT (v
) == current_function_decl
15572 && DECL_ARTIFICIAL (v
)
15573 && DECL_NAME (v
) == this_identifier
)
15574 OMP_CLAUSE_DECL (nc
) = TREE_OPERAND (t
, 1);
15581 else if (VAR_P (OMP_CLAUSE_DECL (oc
))
15582 && DECL_HAS_VALUE_EXPR_P (OMP_CLAUSE_DECL (oc
))
15583 && DECL_ARTIFICIAL (OMP_CLAUSE_DECL (oc
))
15584 && DECL_LANG_SPECIFIC (OMP_CLAUSE_DECL (oc
))
15585 && DECL_OMP_PRIVATIZED_MEMBER (OMP_CLAUSE_DECL (oc
)))
15587 tree decl
= OMP_CLAUSE_DECL (nc
);
15590 retrofit_lang_decl (decl
);
15591 DECL_OMP_PRIVATIZED_MEMBER (decl
) = 1;
15600 new_clauses
= nreverse (new_clauses
);
15601 if (ort
!= C_ORT_OMP_DECLARE_SIMD
)
15603 new_clauses
= finish_omp_clauses (new_clauses
, ort
);
15604 if (linear_no_step
)
15605 for (nc
= new_clauses
; nc
; nc
= OMP_CLAUSE_CHAIN (nc
))
15606 if (nc
== linear_no_step
)
15608 OMP_CLAUSE_LINEAR_STEP (nc
) = NULL_TREE
;
15612 return new_clauses
;
15615 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
15618 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
15621 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
15623 tree purpose
, value
, chain
;
15628 if (TREE_CODE (t
) != TREE_LIST
)
15629 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
15630 /*function_p=*/false,
15631 /*integral_constant_expression_p=*/false);
15633 if (t
== void_list_node
)
15636 purpose
= TREE_PURPOSE (t
);
15638 purpose
= RECUR (purpose
);
15639 value
= TREE_VALUE (t
);
15642 if (TREE_CODE (value
) != LABEL_DECL
)
15643 value
= RECUR (value
);
15646 value
= lookup_label (DECL_NAME (value
));
15647 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
15648 TREE_USED (value
) = 1;
15651 chain
= TREE_CHAIN (t
);
15652 if (chain
&& chain
!= void_type_node
)
15653 chain
= RECUR (chain
);
15654 return tree_cons (purpose
, value
, chain
);
15658 /* Used to temporarily communicate the list of #pragma omp parallel
15659 clauses to #pragma omp for instantiation if they are combined
15662 static tree
*omp_parallel_combined_clauses
;
15664 /* Substitute one OMP_FOR iterator. */
15667 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree orig_declv
,
15668 tree initv
, tree condv
, tree incrv
, tree
*clauses
,
15669 tree args
, tsubst_flags_t complain
, tree in_decl
,
15670 bool integral_constant_expression_p
)
15672 #define RECUR(NODE) \
15673 tsubst_expr ((NODE), args, complain, in_decl, \
15674 integral_constant_expression_p)
15675 tree decl
, init
, cond
, incr
;
15677 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
15678 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
15680 if (orig_declv
&& OMP_FOR_ORIG_DECLS (t
))
15682 tree o
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t
), i
);
15683 TREE_VEC_ELT (orig_declv
, i
) = RECUR (o
);
15686 decl
= TREE_OPERAND (init
, 0);
15687 init
= TREE_OPERAND (init
, 1);
15688 tree decl_expr
= NULL_TREE
;
15689 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
15691 /* We need to jump through some hoops to handle declarations in the
15692 init-statement, since we might need to handle auto deduction,
15693 but we need to keep control of initialization. */
15695 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
15696 decl
= tsubst_decl (decl
, args
, complain
);
15700 if (TREE_CODE (decl
) == SCOPE_REF
)
15702 decl
= RECUR (decl
);
15703 if (TREE_CODE (decl
) == COMPONENT_REF
)
15707 switch (TREE_CODE (v
))
15709 case COMPONENT_REF
:
15713 case POINTER_PLUS_EXPR
:
15714 v
= TREE_OPERAND (v
, 0);
15717 if (DECL_CONTEXT (v
) == current_function_decl
15718 && DECL_ARTIFICIAL (v
)
15719 && DECL_NAME (v
) == this_identifier
)
15721 decl
= TREE_OPERAND (decl
, 1);
15722 decl
= omp_privatize_field (decl
, false);
15732 decl
= RECUR (decl
);
15734 init
= RECUR (init
);
15736 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
15737 if (auto_node
&& init
)
15739 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
15741 gcc_assert (!type_dependent_expression_p (decl
));
15743 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
15747 /* Declare the variable, but don't let that initialize it. */
15748 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
15749 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
15751 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
15754 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
15755 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
15756 if (TREE_CODE (incr
) == MODIFY_EXPR
)
15758 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
15759 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
15760 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
15761 NOP_EXPR
, rhs
, complain
);
15764 incr
= RECUR (incr
);
15765 TREE_VEC_ELT (declv
, i
) = decl
;
15766 TREE_VEC_ELT (initv
, i
) = init
;
15767 TREE_VEC_ELT (condv
, i
) = cond
;
15768 TREE_VEC_ELT (incrv
, i
) = incr
;
15774 /* Declare and initialize the variable. */
15782 for (j
= (omp_parallel_combined_clauses
== NULL
? 1 : 0); j
< 2; j
++)
15784 for (pc
= j
? clauses
: omp_parallel_combined_clauses
; *pc
; )
15786 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
15787 && OMP_CLAUSE_DECL (*pc
) == decl
)
15789 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_LASTPRIVATE
15790 && OMP_CLAUSE_DECL (*pc
) == decl
)
15794 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
15796 *pc
= OMP_CLAUSE_CHAIN (c
);
15797 OMP_CLAUSE_CHAIN (c
) = *clauses
;
15800 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_FIRSTPRIVATE
15801 && OMP_CLAUSE_DECL (*pc
) == decl
)
15803 error ("iteration variable %qD should not be firstprivate",
15805 *pc
= OMP_CLAUSE_CHAIN (*pc
);
15807 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_REDUCTION
15808 && OMP_CLAUSE_DECL (*pc
) == decl
)
15810 error ("iteration variable %qD should not be reduction",
15812 *pc
= OMP_CLAUSE_CHAIN (*pc
);
15815 pc
= &OMP_CLAUSE_CHAIN (*pc
);
15820 if (*pc
== NULL_TREE
)
15822 tree c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
15823 OMP_CLAUSE_DECL (c
) = decl
;
15824 c
= finish_omp_clauses (c
, C_ORT_OMP
);
15827 OMP_CLAUSE_CHAIN (c
) = *clauses
;
15832 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
15833 if (COMPARISON_CLASS_P (cond
))
15835 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
15836 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
15837 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
15840 cond
= RECUR (cond
);
15841 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
15842 switch (TREE_CODE (incr
))
15844 case PREINCREMENT_EXPR
:
15845 case PREDECREMENT_EXPR
:
15846 case POSTINCREMENT_EXPR
:
15847 case POSTDECREMENT_EXPR
:
15848 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
15849 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
15852 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
15853 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
15855 tree rhs
= TREE_OPERAND (incr
, 1);
15856 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
15857 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
15858 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
15859 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
15860 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
15864 incr
= RECUR (incr
);
15867 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
15868 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
15870 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
15871 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
15872 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
15873 TREE_TYPE (decl
), lhs
,
15874 RECUR (TREE_OPERAND (incr
, 2))));
15876 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
15877 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
15878 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
15880 tree rhs
= TREE_OPERAND (incr
, 2);
15881 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
15882 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
15883 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
15884 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
15885 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
15889 incr
= RECUR (incr
);
15892 incr
= RECUR (incr
);
15896 TREE_VEC_ELT (declv
, i
) = decl
;
15897 TREE_VEC_ELT (initv
, i
) = init
;
15898 TREE_VEC_ELT (condv
, i
) = cond
;
15899 TREE_VEC_ELT (incrv
, i
) = incr
;
15903 /* Helper function of tsubst_expr, find OMP_TEAMS inside
15904 of OMP_TARGET's body. */
15907 tsubst_find_omp_teams (tree
*tp
, int *walk_subtrees
, void *)
15909 *walk_subtrees
= 0;
15910 switch (TREE_CODE (*tp
))
15915 case STATEMENT_LIST
:
15916 *walk_subtrees
= 1;
15924 /* Helper function for tsubst_expr. For decomposition declaration
15925 artificial base DECL, which is tsubsted PATTERN_DECL, tsubst
15926 also the corresponding decls representing the identifiers
15927 of the decomposition declaration. Return DECL if successful
15928 or error_mark_node otherwise, set *FIRST to the first decl
15929 in the list chained through DECL_CHAIN and *CNT to the number
15933 tsubst_decomp_names (tree decl
, tree pattern_decl
, tree args
,
15934 tsubst_flags_t complain
, tree in_decl
, tree
*first
,
15937 tree decl2
, decl3
, prev
= decl
;
15939 gcc_assert (DECL_NAME (decl
) == NULL_TREE
);
15940 for (decl2
= DECL_CHAIN (pattern_decl
);
15943 && DECL_DECOMPOSITION_P (decl2
)
15944 && DECL_NAME (decl2
);
15945 decl2
= DECL_CHAIN (decl2
))
15947 if (TREE_TYPE (decl2
) == error_mark_node
&& *cnt
== 0)
15949 gcc_assert (errorcount
);
15950 return error_mark_node
;
15953 gcc_assert (DECL_DECOMP_BASE (decl2
) == pattern_decl
);
15954 gcc_assert (DECL_HAS_VALUE_EXPR_P (decl2
));
15955 tree v
= DECL_VALUE_EXPR (decl2
);
15956 DECL_HAS_VALUE_EXPR_P (decl2
) = 0;
15957 SET_DECL_VALUE_EXPR (decl2
, NULL_TREE
);
15958 decl3
= tsubst (decl2
, args
, complain
, in_decl
);
15959 SET_DECL_VALUE_EXPR (decl2
, v
);
15960 DECL_HAS_VALUE_EXPR_P (decl2
) = 1;
15962 DECL_TEMPLATE_INSTANTIATED (decl3
) = 1;
15963 maybe_push_decl (decl3
);
15964 if (error_operand_p (decl3
))
15965 decl
= error_mark_node
;
15966 else if (decl
!= error_mark_node
15967 && DECL_CHAIN (decl3
) != prev
)
15969 gcc_assert (errorcount
);
15970 decl
= error_mark_node
;
15979 /* Like tsubst_copy for expressions, etc. but also does semantic
15983 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
15984 bool integral_constant_expression_p
)
15986 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
15987 #define RECUR(NODE) \
15988 tsubst_expr ((NODE), args, complain, in_decl, \
15989 integral_constant_expression_p)
15995 if (t
== NULL_TREE
|| t
== error_mark_node
)
15998 loc
= input_location
;
15999 if (EXPR_HAS_LOCATION (t
))
16000 input_location
= EXPR_LOCATION (t
);
16001 if (STATEMENT_CODE_P (TREE_CODE (t
)))
16002 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
16004 switch (TREE_CODE (t
))
16006 case STATEMENT_LIST
:
16008 tree_stmt_iterator i
;
16009 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
16010 RECUR (tsi_stmt (i
));
16014 case CTOR_INITIALIZER
:
16015 finish_mem_initializers (tsubst_initializer_list
16016 (TREE_OPERAND (t
, 0), args
));
16020 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
16024 tmp
= RECUR (EXPR_STMT_EXPR (t
));
16025 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
16026 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
16028 finish_expr_stmt (tmp
);
16032 finish_local_using_directive (USING_STMT_NAMESPACE (t
),
16033 /*attribs=*/NULL_TREE
);
16038 tree decl
, pattern_decl
;
16041 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
16042 if (TREE_CODE (decl
) == LABEL_DECL
)
16043 finish_label_decl (DECL_NAME (decl
));
16044 else if (TREE_CODE (decl
) == USING_DECL
)
16046 tree scope
= USING_DECL_SCOPE (decl
);
16047 tree name
= DECL_NAME (decl
);
16049 scope
= tsubst (scope
, args
, complain
, in_decl
);
16050 decl
= lookup_qualified_name (scope
, name
,
16051 /*is_type_p=*/false,
16052 /*complain=*/false);
16053 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
16054 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
16056 finish_local_using_decl (decl
, scope
, name
);
16058 else if (DECL_PACK_P (decl
))
16060 /* Don't build up decls for a variadic capture proxy, we'll
16061 instantiate the elements directly as needed. */
16064 else if (is_capture_proxy (decl
)
16065 && !DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
16067 /* We're in tsubst_lambda_expr, we've already inserted a new
16068 capture proxy, so look it up and register it. */
16069 tree inst
= lookup_name_real (DECL_NAME (decl
), 0, 0,
16070 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
16071 gcc_assert (inst
!= decl
&& is_capture_proxy (inst
));
16072 register_local_specialization (inst
, decl
);
16075 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
16076 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
16077 /* Don't copy the old closure; we'll create a new one in
16078 tsubst_lambda_expr. */
16082 init
= DECL_INITIAL (decl
);
16083 decl
= tsubst (decl
, args
, complain
, in_decl
);
16084 if (decl
!= error_mark_node
)
16086 /* By marking the declaration as instantiated, we avoid
16087 trying to instantiate it. Since instantiate_decl can't
16088 handle local variables, and since we've already done
16089 all that needs to be done, that's the right thing to
16092 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
16094 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
16095 /* Anonymous aggregates are a special case. */
16096 finish_anon_union (decl
);
16097 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
16099 DECL_CONTEXT (decl
) = current_function_decl
;
16100 if (DECL_NAME (decl
) == this_identifier
)
16102 tree lam
= DECL_CONTEXT (current_function_decl
);
16103 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
16104 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
16106 insert_capture_proxy (decl
);
16108 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
16109 /* We already did a pushtag. */;
16110 else if (TREE_CODE (decl
) == FUNCTION_DECL
16111 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
16112 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
16114 DECL_CONTEXT (decl
) = NULL_TREE
;
16116 DECL_CONTEXT (decl
) = current_function_decl
;
16117 cp_check_omp_declare_reduction (decl
);
16121 int const_init
= false;
16122 maybe_push_decl (decl
);
16124 && DECL_PRETTY_FUNCTION_P (decl
))
16126 /* For __PRETTY_FUNCTION__ we have to adjust the
16128 const char *const name
16129 = cxx_printable_name (current_function_decl
, 2);
16130 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
16133 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
16136 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
16139 && DECL_DECOMPOSITION_P (decl
)
16140 && TREE_TYPE (pattern_decl
) != error_mark_node
)
16145 = tsubst_decomp_names (decl
, pattern_decl
, args
,
16146 complain
, in_decl
, &first
, &cnt
);
16147 if (ndecl
!= error_mark_node
)
16148 cp_maybe_mangle_decomp (ndecl
, first
, cnt
);
16149 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
16150 if (ndecl
!= error_mark_node
)
16151 cp_finish_decomp (ndecl
, first
, cnt
);
16154 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
16163 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
16164 RECUR (FOR_INIT_STMT (t
));
16165 finish_init_stmt (stmt
);
16166 tmp
= RECUR (FOR_COND (t
));
16167 finish_for_cond (tmp
, stmt
, false);
16168 tmp
= RECUR (FOR_EXPR (t
));
16169 finish_for_expr (tmp
, stmt
);
16171 bool prev
= note_iteration_stmt_body_start ();
16172 RECUR (FOR_BODY (t
));
16173 note_iteration_stmt_body_end (prev
);
16175 finish_for_stmt (stmt
);
16178 case RANGE_FOR_STMT
:
16181 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
16182 decl
= RANGE_FOR_DECL (t
);
16183 decl
= tsubst (decl
, args
, complain
, in_decl
);
16184 maybe_push_decl (decl
);
16185 expr
= RECUR (RANGE_FOR_EXPR (t
));
16186 if (VAR_P (decl
) && DECL_DECOMPOSITION_P (decl
))
16190 decl
= tsubst_decomp_names (decl
, RANGE_FOR_DECL (t
), args
,
16191 complain
, in_decl
, &first
, &cnt
);
16192 stmt
= cp_convert_range_for (stmt
, decl
, expr
, first
, cnt
,
16193 RANGE_FOR_IVDEP (t
));
16196 stmt
= cp_convert_range_for (stmt
, decl
, expr
, NULL_TREE
, 0,
16197 RANGE_FOR_IVDEP (t
));
16198 bool prev
= note_iteration_stmt_body_start ();
16199 RECUR (RANGE_FOR_BODY (t
));
16200 note_iteration_stmt_body_end (prev
);
16201 finish_for_stmt (stmt
);
16206 stmt
= begin_while_stmt ();
16207 tmp
= RECUR (WHILE_COND (t
));
16208 finish_while_stmt_cond (tmp
, stmt
, false);
16210 bool prev
= note_iteration_stmt_body_start ();
16211 RECUR (WHILE_BODY (t
));
16212 note_iteration_stmt_body_end (prev
);
16214 finish_while_stmt (stmt
);
16218 stmt
= begin_do_stmt ();
16220 bool prev
= note_iteration_stmt_body_start ();
16221 RECUR (DO_BODY (t
));
16222 note_iteration_stmt_body_end (prev
);
16224 finish_do_body (stmt
);
16225 tmp
= RECUR (DO_COND (t
));
16226 finish_do_stmt (tmp
, stmt
, false);
16230 stmt
= begin_if_stmt ();
16231 IF_STMT_CONSTEXPR_P (stmt
) = IF_STMT_CONSTEXPR_P (t
);
16232 tmp
= RECUR (IF_COND (t
));
16233 tmp
= finish_if_stmt_cond (tmp
, stmt
);
16234 if (IF_STMT_CONSTEXPR_P (t
) && integer_zerop (tmp
))
16235 /* Don't instantiate the THEN_CLAUSE. */;
16238 bool inhibit
= integer_zerop (fold_non_dependent_expr (tmp
));
16240 ++c_inhibit_evaluation_warnings
;
16241 RECUR (THEN_CLAUSE (t
));
16243 --c_inhibit_evaluation_warnings
;
16245 finish_then_clause (stmt
);
16247 if (IF_STMT_CONSTEXPR_P (t
) && integer_nonzerop (tmp
))
16248 /* Don't instantiate the ELSE_CLAUSE. */;
16249 else if (ELSE_CLAUSE (t
))
16251 bool inhibit
= integer_nonzerop (fold_non_dependent_expr (tmp
));
16252 begin_else_clause (stmt
);
16254 ++c_inhibit_evaluation_warnings
;
16255 RECUR (ELSE_CLAUSE (t
));
16257 --c_inhibit_evaluation_warnings
;
16258 finish_else_clause (stmt
);
16261 finish_if_stmt (stmt
);
16265 if (BIND_EXPR_BODY_BLOCK (t
))
16266 stmt
= begin_function_body ();
16268 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
16269 ? BCS_TRY_BLOCK
: 0);
16271 RECUR (BIND_EXPR_BODY (t
));
16273 if (BIND_EXPR_BODY_BLOCK (t
))
16274 finish_function_body (stmt
);
16276 finish_compound_stmt (stmt
);
16280 finish_break_stmt ();
16283 case CONTINUE_STMT
:
16284 finish_continue_stmt ();
16288 stmt
= begin_switch_stmt ();
16289 tmp
= RECUR (SWITCH_STMT_COND (t
));
16290 finish_switch_cond (tmp
, stmt
);
16291 RECUR (SWITCH_STMT_BODY (t
));
16292 finish_switch_stmt (stmt
);
16295 case CASE_LABEL_EXPR
:
16297 tree low
= RECUR (CASE_LOW (t
));
16298 tree high
= RECUR (CASE_HIGH (t
));
16299 tree l
= finish_case_label (EXPR_LOCATION (t
), low
, high
);
16300 if (l
&& TREE_CODE (l
) == CASE_LABEL_EXPR
)
16301 FALLTHROUGH_LABEL_P (CASE_LABEL (l
))
16302 = FALLTHROUGH_LABEL_P (CASE_LABEL (t
));
16308 tree decl
= LABEL_EXPR_LABEL (t
);
16311 label
= finish_label_stmt (DECL_NAME (decl
));
16312 if (TREE_CODE (label
) == LABEL_DECL
)
16313 FALLTHROUGH_LABEL_P (label
) = FALLTHROUGH_LABEL_P (decl
);
16314 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
16315 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
16320 tmp
= GOTO_DESTINATION (t
);
16321 if (TREE_CODE (tmp
) != LABEL_DECL
)
16322 /* Computed goto's must be tsubst'd into. On the other hand,
16323 non-computed gotos must not be; the identifier in question
16324 will have no binding. */
16327 tmp
= DECL_NAME (tmp
);
16328 finish_goto_stmt (tmp
);
16333 tree string
= RECUR (ASM_STRING (t
));
16334 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
16335 complain
, in_decl
);
16336 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
16337 complain
, in_decl
);
16338 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
16339 complain
, in_decl
);
16340 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
16341 complain
, in_decl
);
16342 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
16344 tree asm_expr
= tmp
;
16345 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
16346 asm_expr
= TREE_OPERAND (asm_expr
, 0);
16347 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
16354 stmt
= begin_try_block ();
16355 RECUR (TRY_STMTS (t
));
16356 finish_cleanup_try_block (stmt
);
16357 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
16361 tree compound_stmt
= NULL_TREE
;
16363 if (FN_TRY_BLOCK_P (t
))
16364 stmt
= begin_function_try_block (&compound_stmt
);
16366 stmt
= begin_try_block ();
16368 RECUR (TRY_STMTS (t
));
16370 if (FN_TRY_BLOCK_P (t
))
16371 finish_function_try_block (stmt
);
16373 finish_try_block (stmt
);
16375 RECUR (TRY_HANDLERS (t
));
16376 if (FN_TRY_BLOCK_P (t
))
16377 finish_function_handler_sequence (stmt
, compound_stmt
);
16379 finish_handler_sequence (stmt
);
16385 tree decl
= HANDLER_PARMS (t
);
16389 decl
= tsubst (decl
, args
, complain
, in_decl
);
16390 /* Prevent instantiate_decl from trying to instantiate
16391 this variable. We've already done all that needs to be
16393 if (decl
!= error_mark_node
)
16394 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
16396 stmt
= begin_handler ();
16397 finish_handler_parms (decl
, stmt
);
16398 RECUR (HANDLER_BODY (t
));
16399 finish_handler (stmt
);
16404 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
16405 if (CLASS_TYPE_P (tmp
))
16407 /* Local classes are not independent templates; they are
16408 instantiated along with their containing function. And this
16409 way we don't have to deal with pushing out of one local class
16410 to instantiate a member of another local class. */
16411 /* Closures are handled by the LAMBDA_EXPR. */
16412 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
16413 complete_type (tmp
);
16414 for (tree fld
= TYPE_FIELDS (tmp
); fld
; fld
= DECL_CHAIN (fld
))
16416 || (TREE_CODE (fld
) == FUNCTION_DECL
16417 && !DECL_ARTIFICIAL (fld
)))
16418 && DECL_TEMPLATE_INSTANTIATION (fld
))
16419 instantiate_decl (fld
, /*defer_ok=*/false,
16420 /*expl_inst_class=*/false);
16424 case STATIC_ASSERT
:
16428 ++c_inhibit_evaluation_warnings
;
16430 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
16433 /*integral_constant_expression_p=*/true);
16434 --c_inhibit_evaluation_warnings
;
16436 finish_static_assert (condition
,
16437 STATIC_ASSERT_MESSAGE (t
),
16438 STATIC_ASSERT_SOURCE_LOCATION (t
),
16439 /*member_p=*/false);
16444 case OACC_PARALLEL
:
16445 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_ACC
, args
, complain
,
16447 stmt
= begin_omp_parallel ();
16448 RECUR (OMP_BODY (t
));
16449 finish_omp_construct (TREE_CODE (t
), stmt
, tmp
);
16453 r
= push_omp_privatization_clauses (OMP_PARALLEL_COMBINED (t
));
16454 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), C_ORT_OMP
, args
,
16455 complain
, in_decl
);
16456 if (OMP_PARALLEL_COMBINED (t
))
16457 omp_parallel_combined_clauses
= &tmp
;
16458 stmt
= begin_omp_parallel ();
16459 RECUR (OMP_PARALLEL_BODY (t
));
16460 gcc_assert (omp_parallel_combined_clauses
== NULL
);
16461 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
16462 = OMP_PARALLEL_COMBINED (t
);
16463 pop_omp_privatization_clauses (r
);
16467 r
= push_omp_privatization_clauses (false);
16468 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), C_ORT_OMP
, args
,
16469 complain
, in_decl
);
16470 stmt
= begin_omp_task ();
16471 RECUR (OMP_TASK_BODY (t
));
16472 finish_omp_task (tmp
, stmt
);
16473 pop_omp_privatization_clauses (r
);
16478 case OMP_DISTRIBUTE
:
16482 tree clauses
, body
, pre_body
;
16483 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
16484 tree orig_declv
= NULL_TREE
;
16485 tree incrv
= NULL_TREE
;
16486 enum c_omp_region_type ort
= C_ORT_OMP
;
16489 if (TREE_CODE (t
) == OACC_LOOP
)
16492 r
= push_omp_privatization_clauses (OMP_FOR_INIT (t
) == NULL_TREE
);
16493 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), ort
, args
, complain
,
16495 if (OMP_FOR_INIT (t
) != NULL_TREE
)
16497 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16498 if (OMP_FOR_ORIG_DECLS (t
))
16499 orig_declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16500 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16501 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16502 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16505 stmt
= begin_omp_structured_block ();
16507 pre_body
= push_stmt_list ();
16508 RECUR (OMP_FOR_PRE_BODY (t
));
16509 pre_body
= pop_stmt_list (pre_body
);
16511 if (OMP_FOR_INIT (t
) != NULL_TREE
)
16512 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
16513 tsubst_omp_for_iterator (t
, i
, declv
, orig_declv
, initv
, condv
,
16514 incrv
, &clauses
, args
, complain
, in_decl
,
16515 integral_constant_expression_p
);
16516 omp_parallel_combined_clauses
= NULL
;
16518 body
= push_stmt_list ();
16519 RECUR (OMP_FOR_BODY (t
));
16520 body
= pop_stmt_list (body
);
16522 if (OMP_FOR_INIT (t
) != NULL_TREE
)
16523 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
,
16524 orig_declv
, initv
, condv
, incrv
, body
, pre_body
,
16528 t
= make_node (TREE_CODE (t
));
16529 TREE_TYPE (t
) = void_type_node
;
16530 OMP_FOR_BODY (t
) = body
;
16531 OMP_FOR_PRE_BODY (t
) = pre_body
;
16532 OMP_FOR_CLAUSES (t
) = clauses
;
16533 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
16537 add_stmt (finish_omp_structured_block (stmt
));
16538 pop_omp_privatization_clauses (r
);
16543 omp_parallel_combined_clauses
= NULL
;
16548 r
= push_omp_privatization_clauses (TREE_CODE (t
) == OMP_TEAMS
16549 && OMP_TEAMS_COMBINED (t
));
16550 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_OMP
, args
, complain
,
16552 stmt
= push_stmt_list ();
16553 RECUR (OMP_BODY (t
));
16554 stmt
= pop_stmt_list (stmt
);
16557 OMP_BODY (t
) = stmt
;
16558 OMP_CLAUSES (t
) = tmp
;
16560 pop_omp_privatization_clauses (r
);
16564 case OMP_TARGET_DATA
:
16566 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), (TREE_CODE (t
) == OACC_DATA
)
16567 ? C_ORT_ACC
: C_ORT_OMP
, args
, complain
,
16569 keep_next_level (true);
16570 stmt
= begin_omp_structured_block ();
16572 RECUR (OMP_BODY (t
));
16573 stmt
= finish_omp_structured_block (stmt
);
16576 OMP_BODY (t
) = stmt
;
16577 OMP_CLAUSES (t
) = tmp
;
16578 if (TREE_CODE (t
) == OMP_TARGET
&& OMP_TARGET_COMBINED (t
))
16580 tree teams
= cp_walk_tree (&stmt
, tsubst_find_omp_teams
, NULL
, NULL
);
16583 /* For combined target teams, ensure the num_teams and
16584 thread_limit clause expressions are evaluated on the host,
16585 before entering the target construct. */
16587 for (c
= OMP_TEAMS_CLAUSES (teams
);
16588 c
; c
= OMP_CLAUSE_CHAIN (c
))
16589 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
16590 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
16591 && TREE_CODE (OMP_CLAUSE_OPERAND (c
, 0)) != INTEGER_CST
)
16593 tree expr
= OMP_CLAUSE_OPERAND (c
, 0);
16594 expr
= force_target_expr (TREE_TYPE (expr
), expr
, tf_none
);
16595 if (expr
== error_mark_node
)
16597 tmp
= TARGET_EXPR_SLOT (expr
);
16599 OMP_CLAUSE_OPERAND (c
, 0) = expr
;
16600 tree tc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
16601 OMP_CLAUSE_FIRSTPRIVATE
);
16602 OMP_CLAUSE_DECL (tc
) = tmp
;
16603 OMP_CLAUSE_CHAIN (tc
) = OMP_TARGET_CLAUSES (t
);
16604 OMP_TARGET_CLAUSES (t
) = tc
;
16613 tmp
= tsubst_omp_clauses (OACC_DECLARE_CLAUSES (t
), C_ORT_ACC
, args
,
16614 complain
, in_decl
);
16615 OACC_DECLARE_CLAUSES (t
) = tmp
;
16619 case OMP_TARGET_UPDATE
:
16620 case OMP_TARGET_ENTER_DATA
:
16621 case OMP_TARGET_EXIT_DATA
:
16622 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_OMP
, args
,
16623 complain
, in_decl
);
16625 OMP_STANDALONE_CLAUSES (t
) = tmp
;
16629 case OACC_ENTER_DATA
:
16630 case OACC_EXIT_DATA
:
16632 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_ACC
, args
,
16633 complain
, in_decl
);
16635 OMP_STANDALONE_CLAUSES (t
) = tmp
;
16640 tmp
= tsubst_omp_clauses (OMP_ORDERED_CLAUSES (t
), C_ORT_OMP
, args
,
16641 complain
, in_decl
);
16642 stmt
= push_stmt_list ();
16643 RECUR (OMP_BODY (t
));
16644 stmt
= pop_stmt_list (stmt
);
16647 OMP_BODY (t
) = stmt
;
16648 OMP_ORDERED_CLAUSES (t
) = tmp
;
16654 case OMP_TASKGROUP
:
16655 stmt
= push_stmt_list ();
16656 RECUR (OMP_BODY (t
));
16657 stmt
= pop_stmt_list (stmt
);
16660 OMP_BODY (t
) = stmt
;
16665 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
16666 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
16668 tree op1
= TREE_OPERAND (t
, 1);
16669 tree rhs1
= NULL_TREE
;
16671 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
16673 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
16674 op1
= TREE_OPERAND (op1
, 1);
16676 lhs
= RECUR (TREE_OPERAND (op1
, 0));
16677 rhs
= RECUR (TREE_OPERAND (op1
, 1));
16678 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
16679 NULL_TREE
, NULL_TREE
, rhs1
,
16680 OMP_ATOMIC_SEQ_CST (t
));
16684 tree op1
= TREE_OPERAND (t
, 1);
16685 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
16686 tree rhs1
= NULL_TREE
;
16687 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
16688 enum tree_code opcode
= NOP_EXPR
;
16689 if (code
== OMP_ATOMIC_READ
)
16691 v
= RECUR (TREE_OPERAND (op1
, 0));
16692 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
16694 else if (code
== OMP_ATOMIC_CAPTURE_OLD
16695 || code
== OMP_ATOMIC_CAPTURE_NEW
)
16697 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
16698 v
= RECUR (TREE_OPERAND (op1
, 0));
16699 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
16700 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
16702 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
16703 op11
= TREE_OPERAND (op11
, 1);
16705 lhs
= RECUR (TREE_OPERAND (op11
, 0));
16706 rhs
= RECUR (TREE_OPERAND (op11
, 1));
16707 opcode
= TREE_CODE (op11
);
16708 if (opcode
== MODIFY_EXPR
)
16714 lhs
= RECUR (TREE_OPERAND (op1
, 0));
16715 rhs
= RECUR (TREE_OPERAND (op1
, 1));
16717 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
16718 OMP_ATOMIC_SEQ_CST (t
));
16722 case TRANSACTION_EXPR
:
16725 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
16726 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
16728 if (TRANSACTION_EXPR_IS_STMT (t
))
16730 tree body
= TRANSACTION_EXPR_BODY (t
);
16731 tree noex
= NULL_TREE
;
16732 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
16734 noex
= MUST_NOT_THROW_COND (body
);
16735 if (noex
== NULL_TREE
)
16736 noex
= boolean_true_node
;
16737 body
= TREE_OPERAND (body
, 0);
16739 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
16741 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
16745 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
16746 RECUR (TRANSACTION_EXPR_BODY (t
)),
16753 case MUST_NOT_THROW_EXPR
:
16755 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16756 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
16757 RETURN (build_must_not_throw_expr (op0
, cond
));
16760 case EXPR_PACK_EXPANSION
:
16761 error ("invalid use of pack expansion expression");
16762 RETURN (error_mark_node
);
16764 case NONTYPE_ARGUMENT_PACK
:
16765 error ("use %<...%> to expand argument pack");
16766 RETURN (error_mark_node
);
16768 case COMPOUND_EXPR
:
16769 tmp
= RECUR (TREE_OPERAND (t
, 0));
16770 if (tmp
== NULL_TREE
)
16771 /* If the first operand was a statement, we're done with it. */
16772 RETURN (RECUR (TREE_OPERAND (t
, 1)));
16773 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
16774 RECUR (TREE_OPERAND (t
, 1)),
16777 case ANNOTATE_EXPR
:
16778 tmp
= RECUR (TREE_OPERAND (t
, 0));
16779 RETURN (build3_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
16780 TREE_TYPE (tmp
), tmp
,
16781 RECUR (TREE_OPERAND (t
, 1)),
16782 RECUR (TREE_OPERAND (t
, 2))));
16785 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
16787 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
16788 /*function_p=*/false,
16789 integral_constant_expression_p
));
16792 RETURN (NULL_TREE
);
16794 input_location
= loc
;
16800 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
16801 function. For description of the body see comment above
16802 cp_parser_omp_declare_reduction_exprs. */
16805 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
16807 if (t
== NULL_TREE
|| t
== error_mark_node
)
16810 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
16812 tree_stmt_iterator tsi
;
16815 memset (stmts
, 0, sizeof stmts
);
16816 for (i
= 0, tsi
= tsi_start (t
);
16817 i
< 7 && !tsi_end_p (tsi
);
16818 i
++, tsi_next (&tsi
))
16819 stmts
[i
] = tsi_stmt (tsi
);
16820 gcc_assert (tsi_end_p (tsi
));
16824 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
16825 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
16826 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
16827 args
, complain
, in_decl
);
16828 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
16829 args
, complain
, in_decl
);
16830 DECL_CONTEXT (omp_out
) = current_function_decl
;
16831 DECL_CONTEXT (omp_in
) = current_function_decl
;
16832 keep_next_level (true);
16833 tree block
= begin_omp_structured_block ();
16834 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
16835 block
= finish_omp_structured_block (block
);
16836 block
= maybe_cleanup_point_expr_void (block
);
16837 add_decl_expr (omp_out
);
16838 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
16839 TREE_NO_WARNING (omp_out
) = 1;
16840 add_decl_expr (omp_in
);
16841 finish_expr_stmt (block
);
16845 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
16846 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
16847 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
16848 args
, complain
, in_decl
);
16849 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
16850 args
, complain
, in_decl
);
16851 DECL_CONTEXT (omp_priv
) = current_function_decl
;
16852 DECL_CONTEXT (omp_orig
) = current_function_decl
;
16853 keep_next_level (true);
16854 tree block
= begin_omp_structured_block ();
16855 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
16856 block
= finish_omp_structured_block (block
);
16857 block
= maybe_cleanup_point_expr_void (block
);
16858 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
16859 add_decl_expr (omp_priv
);
16860 add_decl_expr (omp_orig
);
16861 finish_expr_stmt (block
);
16863 add_decl_expr (omp_orig
);
16867 /* T is a postfix-expression that is not being used in a function
16868 call. Return the substituted version of T. */
16871 tsubst_non_call_postfix_expression (tree t
, tree args
,
16872 tsubst_flags_t complain
,
16875 if (TREE_CODE (t
) == SCOPE_REF
)
16876 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
16877 /*done=*/false, /*address_p=*/false);
16879 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
16880 /*function_p=*/false,
16881 /*integral_constant_expression_p=*/false);
16886 /* T is a LAMBDA_EXPR. Generate a new LAMBDA_EXPR for the current
16887 instantiation context. Instantiating a pack expansion containing a lambda
16888 might result in multiple lambdas all based on the same lambda in the
16892 tsubst_lambda_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
16894 tree oldfn
= lambda_function (t
);
16897 tree r
= build_lambda_expr ();
16899 LAMBDA_EXPR_LOCATION (r
)
16900 = LAMBDA_EXPR_LOCATION (t
);
16901 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
16902 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
16903 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
16905 if (LAMBDA_EXPR_EXTRA_SCOPE (t
) == NULL_TREE
)
16906 LAMBDA_EXPR_EXTRA_SCOPE (r
) = NULL_TREE
;
16908 record_lambda_scope (r
);
16910 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
16911 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
16913 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
); cap
;
16914 cap
= TREE_CHAIN (cap
))
16916 tree field
= TREE_PURPOSE (cap
);
16917 if (PACK_EXPANSION_P (field
))
16918 field
= PACK_EXPANSION_PATTERN (field
);
16919 field
= tsubst_decl (field
, args
, complain
);
16921 if (field
== error_mark_node
)
16922 return error_mark_node
;
16924 tree init
= TREE_VALUE (cap
);
16925 if (PACK_EXPANSION_P (init
))
16926 init
= tsubst_pack_expansion (init
, args
, complain
, in_decl
);
16928 init
= tsubst_copy_and_build (init
, args
, complain
, in_decl
,
16929 /*fn*/false, /*constexpr*/false);
16931 if (TREE_CODE (field
) == TREE_VEC
)
16933 int len
= TREE_VEC_LENGTH (field
);
16934 gcc_assert (TREE_CODE (init
) == TREE_VEC
16935 && TREE_VEC_LENGTH (init
) == len
);
16936 for (int i
= 0; i
< len
; ++i
)
16937 LAMBDA_EXPR_CAPTURE_LIST (r
)
16938 = tree_cons (TREE_VEC_ELT (field
, i
),
16939 TREE_VEC_ELT (init
, i
),
16940 LAMBDA_EXPR_CAPTURE_LIST (r
));
16944 LAMBDA_EXPR_CAPTURE_LIST (r
)
16945 = tree_cons (field
, init
, LAMBDA_EXPR_CAPTURE_LIST (r
));
16947 if (id_equal (DECL_NAME (field
), "__this"))
16948 LAMBDA_EXPR_THIS_CAPTURE (r
) = field
;
16952 tree type
= begin_lambda_type (r
);
16954 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
16955 determine_visibility (TYPE_NAME (type
));
16957 register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (r
));
16959 tree oldtmpl
= (generic_lambda_fn_p (oldfn
)
16960 ? DECL_TI_TEMPLATE (oldfn
)
16963 tree fntype
= static_fn_type (oldfn
);
16965 ++processing_template_decl
;
16966 fntype
= tsubst (fntype
, args
, complain
, in_decl
);
16968 --processing_template_decl
;
16970 if (fntype
== error_mark_node
)
16971 r
= error_mark_node
;
16974 /* Fix the type of 'this'. */
16975 fntype
= build_memfn_type (fntype
, type
,
16976 type_memfn_quals (fntype
),
16977 type_memfn_rqual (fntype
));
16981 tmpl
= tsubst_template_decl (oldtmpl
, args
, complain
, fntype
);
16982 fn
= DECL_TEMPLATE_RESULT (tmpl
);
16983 finish_member_declaration (tmpl
);
16988 fn
= tsubst_function_decl (oldfn
, args
, complain
, fntype
);
16989 finish_member_declaration (fn
);
16992 /* Let finish_function set this. */
16993 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
16995 bool nested
= cfun
;
16997 push_function_context ();
16999 local_specialization_stack
s (lss_copy
);
17001 tree body
= start_lambda_function (fn
, r
);
17003 register_parameter_specializations (oldfn
, fn
);
17005 tsubst_expr (DECL_SAVED_TREE (oldfn
), args
, complain
, r
,
17006 /*constexpr*/false);
17008 finish_lambda_function (body
);
17011 pop_function_context ();
17013 /* The capture list was built up in reverse order; fix that now. */
17014 LAMBDA_EXPR_CAPTURE_LIST (r
)
17015 = nreverse (LAMBDA_EXPR_CAPTURE_LIST (r
));
17017 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
17019 maybe_add_lambda_conv_op (type
);
17022 finish_struct (type
, /*attr*/NULL_TREE
);
17024 insert_pending_capture_proxies ();
17029 /* Like tsubst but deals with expressions and performs semantic
17030 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
17033 tsubst_copy_and_build (tree t
,
17035 tsubst_flags_t complain
,
17038 bool integral_constant_expression_p
)
17040 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
17041 #define RECUR(NODE) \
17042 tsubst_copy_and_build (NODE, args, complain, in_decl, \
17043 /*function_p=*/false, \
17044 integral_constant_expression_p)
17049 if (t
== NULL_TREE
|| t
== error_mark_node
)
17052 loc
= input_location
;
17053 if (EXPR_HAS_LOCATION (t
))
17054 input_location
= EXPR_LOCATION (t
);
17056 /* N3276 decltype magic only applies to calls at the top level or on the
17057 right side of a comma. */
17058 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
17059 complain
&= ~tf_decltype
;
17061 switch (TREE_CODE (t
))
17065 /* Fall through. */
17066 case IDENTIFIER_NODE
:
17070 bool non_integral_constant_expression_p
;
17071 const char *error_msg
;
17073 if (IDENTIFIER_CONV_OP_P (t
))
17075 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17076 t
= make_conv_op_name (new_type
);
17079 /* Look up the name. */
17080 decl
= lookup_name (t
);
17082 /* By convention, expressions use ERROR_MARK_NODE to indicate
17083 failure, not NULL_TREE. */
17084 if (decl
== NULL_TREE
)
17085 decl
= error_mark_node
;
17087 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
17089 integral_constant_expression_p
,
17090 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
17091 &non_integral_constant_expression_p
,
17092 /*template_p=*/false,
17094 /*address_p=*/false,
17095 /*template_arg_p=*/false,
17100 if (!function_p
&& identifier_p (decl
))
17102 if (complain
& tf_error
)
17103 unqualified_name_lookup_error (decl
);
17104 decl
= error_mark_node
;
17109 case TEMPLATE_ID_EXPR
:
17112 tree templ
= RECUR (TREE_OPERAND (t
, 0));
17113 tree targs
= TREE_OPERAND (t
, 1);
17116 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
17117 if (targs
== error_mark_node
)
17118 return error_mark_node
;
17120 if (TREE_CODE (templ
) == SCOPE_REF
)
17122 tree name
= TREE_OPERAND (templ
, 1);
17123 tree tid
= lookup_template_function (name
, targs
);
17124 TREE_OPERAND (templ
, 1) = tid
;
17128 if (variable_template_p (templ
))
17129 RETURN (lookup_and_finish_template_variable (templ
, targs
, complain
));
17131 if (TREE_CODE (templ
) == COMPONENT_REF
)
17133 object
= TREE_OPERAND (templ
, 0);
17134 templ
= TREE_OPERAND (templ
, 1);
17137 object
= NULL_TREE
;
17138 templ
= lookup_template_function (templ
, targs
);
17141 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
17142 object
, templ
, NULL_TREE
));
17144 RETURN (baselink_for_fns (templ
));
17149 tree r
= RECUR (TREE_OPERAND (t
, 0));
17151 if (REFERENCE_REF_P (t
))
17153 /* A type conversion to reference type will be enclosed in
17154 such an indirect ref, but the substitution of the cast
17155 will have also added such an indirect ref. */
17156 r
= convert_from_reference (r
);
17159 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
17160 complain
|decltype_flag
);
17162 if (TREE_CODE (r
) == INDIRECT_REF
)
17163 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
17170 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17171 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17172 RETURN (build_nop (type
, op0
));
17175 case IMPLICIT_CONV_EXPR
:
17177 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17178 tree expr
= RECUR (TREE_OPERAND (t
, 0));
17179 if (dependent_type_p (type
) || type_dependent_expression_p (expr
))
17181 retval
= copy_node (t
);
17182 TREE_TYPE (retval
) = type
;
17183 TREE_OPERAND (retval
, 0) = expr
;
17186 if (IMPLICIT_CONV_EXPR_NONTYPE_ARG (t
))
17187 /* We'll pass this to convert_nontype_argument again, we don't need
17188 to actually perform any conversion here. */
17190 int flags
= LOOKUP_IMPLICIT
;
17191 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
17192 flags
= LOOKUP_NORMAL
;
17193 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
17199 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17200 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17201 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
17205 case REINTERPRET_CAST_EXPR
:
17206 case CONST_CAST_EXPR
:
17207 case DYNAMIC_CAST_EXPR
:
17208 case STATIC_CAST_EXPR
:
17211 tree op
, r
= NULL_TREE
;
17213 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17214 if (integral_constant_expression_p
17215 && !cast_valid_in_integral_constant_expression_p (type
))
17217 if (complain
& tf_error
)
17218 error ("a cast to a type other than an integral or "
17219 "enumeration type cannot appear in a constant-expression");
17220 RETURN (error_mark_node
);
17223 op
= RECUR (TREE_OPERAND (t
, 0));
17225 warning_sentinel
s(warn_useless_cast
);
17226 warning_sentinel
s2(warn_ignored_qualifiers
);
17227 switch (TREE_CODE (t
))
17230 r
= build_functional_cast (type
, op
, complain
);
17232 case REINTERPRET_CAST_EXPR
:
17233 r
= build_reinterpret_cast (type
, op
, complain
);
17235 case CONST_CAST_EXPR
:
17236 r
= build_const_cast (type
, op
, complain
);
17238 case DYNAMIC_CAST_EXPR
:
17239 r
= build_dynamic_cast (type
, op
, complain
);
17241 case STATIC_CAST_EXPR
:
17242 r
= build_static_cast (type
, op
, complain
);
17245 gcc_unreachable ();
17251 case POSTDECREMENT_EXPR
:
17252 case POSTINCREMENT_EXPR
:
17253 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
17254 args
, complain
, in_decl
);
17255 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
17256 complain
|decltype_flag
));
17258 case PREDECREMENT_EXPR
:
17259 case PREINCREMENT_EXPR
:
17263 case TRUTH_NOT_EXPR
:
17264 case UNARY_PLUS_EXPR
: /* Unary + */
17265 case REALPART_EXPR
:
17266 case IMAGPART_EXPR
:
17267 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
17268 RECUR (TREE_OPERAND (t
, 0)),
17269 complain
|decltype_flag
));
17271 case FIX_TRUNC_EXPR
:
17272 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
17276 op1
= TREE_OPERAND (t
, 0);
17277 if (TREE_CODE (op1
) == LABEL_DECL
)
17278 RETURN (finish_label_address_expr (DECL_NAME (op1
),
17279 EXPR_LOCATION (op1
)));
17280 if (TREE_CODE (op1
) == SCOPE_REF
)
17281 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
17282 /*done=*/true, /*address_p=*/true);
17284 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
17286 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
17287 complain
|decltype_flag
));
17292 case TRUNC_DIV_EXPR
:
17293 case CEIL_DIV_EXPR
:
17294 case FLOOR_DIV_EXPR
:
17295 case ROUND_DIV_EXPR
:
17296 case EXACT_DIV_EXPR
:
17300 case TRUNC_MOD_EXPR
:
17301 case FLOOR_MOD_EXPR
:
17302 case TRUTH_ANDIF_EXPR
:
17303 case TRUTH_ORIF_EXPR
:
17304 case TRUTH_AND_EXPR
:
17305 case TRUTH_OR_EXPR
:
17321 warning_sentinel
s1(warn_type_limits
);
17322 warning_sentinel
s2(warn_div_by_zero
);
17323 warning_sentinel
s3(warn_logical_op
);
17324 warning_sentinel
s4(warn_tautological_compare
);
17325 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17326 tree op1
= RECUR (TREE_OPERAND (t
, 1));
17327 tree r
= build_x_binary_op
17328 (input_location
, TREE_CODE (t
),
17330 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
17332 : TREE_CODE (TREE_OPERAND (t
, 0))),
17334 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
17336 : TREE_CODE (TREE_OPERAND (t
, 1))),
17338 complain
|decltype_flag
);
17339 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
17340 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
17345 case POINTER_PLUS_EXPR
:
17347 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17348 tree op1
= RECUR (TREE_OPERAND (t
, 1));
17349 return fold_build_pointer_plus (op0
, op1
);
17353 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
17354 /*address_p=*/false));
17356 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
17357 args
, complain
, in_decl
);
17358 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
17359 RECUR (TREE_OPERAND (t
, 1)),
17360 complain
|decltype_flag
));
17363 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
17364 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
17365 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
17372 op1
= TREE_OPERAND (t
, 0);
17373 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
17374 op1
= TREE_TYPE (op1
);
17377 /* When there are no ARGS, we are trying to evaluate a
17378 non-dependent expression from the parser. Trying to do
17379 the substitutions may not work. */
17381 op1
= TREE_TYPE (op1
);
17385 ++cp_unevaluated_operand
;
17386 ++c_inhibit_evaluation_warnings
;
17388 op1
= tsubst (op1
, args
, complain
, in_decl
);
17390 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
17391 /*function_p=*/false,
17392 /*integral_constant_expression_p=*/
17394 --cp_unevaluated_operand
;
17395 --c_inhibit_evaluation_warnings
;
17398 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
17399 complain
& tf_error
);
17401 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
17402 complain
& tf_error
);
17403 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
17405 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
17407 if (!processing_template_decl
&& TYPE_P (op1
))
17409 r
= build_min (SIZEOF_EXPR
, size_type_node
,
17410 build1 (NOP_EXPR
, op1
, error_mark_node
));
17411 SIZEOF_EXPR_TYPE_P (r
) = 1;
17414 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
17415 TREE_SIDE_EFFECTS (r
) = 0;
17416 TREE_READONLY (r
) = 1;
17418 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
17423 case AT_ENCODE_EXPR
:
17425 op1
= TREE_OPERAND (t
, 0);
17426 ++cp_unevaluated_operand
;
17427 ++c_inhibit_evaluation_warnings
;
17428 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
17429 /*function_p=*/false,
17430 /*integral_constant_expression_p=*/false);
17431 --cp_unevaluated_operand
;
17432 --c_inhibit_evaluation_warnings
;
17433 RETURN (objc_build_encode_expr (op1
));
17436 case NOEXCEPT_EXPR
:
17437 op1
= TREE_OPERAND (t
, 0);
17438 ++cp_unevaluated_operand
;
17439 ++c_inhibit_evaluation_warnings
;
17440 ++cp_noexcept_operand
;
17441 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
17442 /*function_p=*/false,
17443 /*integral_constant_expression_p=*/false);
17444 --cp_unevaluated_operand
;
17445 --c_inhibit_evaluation_warnings
;
17446 --cp_noexcept_operand
;
17447 RETURN (finish_noexcept_expr (op1
, complain
));
17451 warning_sentinel
s(warn_div_by_zero
);
17452 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
17453 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
17454 tree r
= build_x_modify_expr
17455 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
17456 complain
|decltype_flag
);
17457 /* TREE_NO_WARNING must be set if either the expression was
17458 parenthesized or it uses an operator such as >>= rather
17459 than plain assignment. In the former case, it was already
17460 set and must be copied. In the latter case,
17461 build_x_modify_expr sets it and it must not be reset
17463 if (TREE_NO_WARNING (t
))
17464 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
17470 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
17471 args
, complain
, in_decl
);
17472 /* Remember that there was a reference to this entity. */
17474 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
17475 RETURN (error_mark_node
);
17476 RETURN (build_x_arrow (input_location
, op1
, complain
));
17480 tree placement
= RECUR (TREE_OPERAND (t
, 0));
17481 tree init
= RECUR (TREE_OPERAND (t
, 3));
17482 vec
<tree
, va_gc
> *placement_vec
;
17483 vec
<tree
, va_gc
> *init_vec
;
17486 if (placement
== NULL_TREE
)
17487 placement_vec
= NULL
;
17490 placement_vec
= make_tree_vector ();
17491 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
17492 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
17495 /* If there was an initializer in the original tree, but it
17496 instantiated to an empty list, then we should pass a
17497 non-NULL empty vector to tell build_new that it was an
17498 empty initializer() rather than no initializer. This can
17499 only happen when the initializer is a pack expansion whose
17500 parameter packs are of length zero. */
17501 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
17505 init_vec
= make_tree_vector ();
17506 if (init
== void_node
)
17507 gcc_assert (init_vec
!= NULL
);
17510 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
17511 vec_safe_push (init_vec
, TREE_VALUE (init
));
17515 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
17516 tree op2
= RECUR (TREE_OPERAND (t
, 2));
17517 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
17518 NEW_EXPR_USE_GLOBAL (t
),
17521 if (placement_vec
!= NULL
)
17522 release_tree_vector (placement_vec
);
17523 if (init_vec
!= NULL
)
17524 release_tree_vector (init_vec
);
17531 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17532 tree op1
= RECUR (TREE_OPERAND (t
, 1));
17533 RETURN (delete_sanity (op0
, op1
,
17534 DELETE_EXPR_USE_VEC (t
),
17535 DELETE_EXPR_USE_GLOBAL (t
),
17539 case COMPOUND_EXPR
:
17541 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
17542 complain
& ~tf_decltype
, in_decl
,
17543 /*function_p=*/false,
17544 integral_constant_expression_p
);
17545 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
17547 RECUR (TREE_OPERAND (t
, 1)),
17548 complain
|decltype_flag
));
17554 vec
<tree
, va_gc
> *call_args
;
17555 unsigned int nargs
, i
;
17560 function
= CALL_EXPR_FN (t
);
17561 /* Internal function with no arguments. */
17562 if (function
== NULL_TREE
&& call_expr_nargs (t
) == 0)
17565 /* When we parsed the expression, we determined whether or
17566 not Koenig lookup should be performed. */
17567 koenig_p
= KOENIG_LOOKUP_P (t
);
17568 if (function
== NULL_TREE
)
17571 qualified_p
= false;
17573 else if (TREE_CODE (function
) == SCOPE_REF
)
17575 qualified_p
= true;
17576 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
17578 /*address_p=*/false);
17580 else if (koenig_p
&& identifier_p (function
))
17582 /* Do nothing; calling tsubst_copy_and_build on an identifier
17583 would incorrectly perform unqualified lookup again.
17585 Note that we can also have an IDENTIFIER_NODE if the earlier
17586 unqualified lookup found a member function; in that case
17587 koenig_p will be false and we do want to do the lookup
17588 again to find the instantiated member function.
17590 FIXME but doing that causes c++/15272, so we need to stop
17591 using IDENTIFIER_NODE in that situation. */
17592 qualified_p
= false;
17596 if (TREE_CODE (function
) == COMPONENT_REF
)
17598 tree op
= TREE_OPERAND (function
, 1);
17600 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
17601 || (BASELINK_P (op
)
17602 && BASELINK_QUALIFIED_P (op
)));
17605 qualified_p
= false;
17607 if (TREE_CODE (function
) == ADDR_EXPR
17608 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
17609 /* Avoid error about taking the address of a constructor. */
17610 function
= TREE_OPERAND (function
, 0);
17612 function
= tsubst_copy_and_build (function
, args
, complain
,
17615 integral_constant_expression_p
);
17617 if (BASELINK_P (function
))
17618 qualified_p
= true;
17621 nargs
= call_expr_nargs (t
);
17622 call_args
= make_tree_vector ();
17623 for (i
= 0; i
< nargs
; ++i
)
17625 tree arg
= CALL_EXPR_ARG (t
, i
);
17627 if (!PACK_EXPANSION_P (arg
))
17628 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
17631 /* Expand the pack expansion and push each entry onto
17633 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
17634 if (TREE_CODE (arg
) == TREE_VEC
)
17636 unsigned int len
, j
;
17638 len
= TREE_VEC_LENGTH (arg
);
17639 for (j
= 0; j
< len
; ++j
)
17641 tree value
= TREE_VEC_ELT (arg
, j
);
17642 if (value
!= NULL_TREE
)
17643 value
= convert_from_reference (value
);
17644 vec_safe_push (call_args
, value
);
17649 /* A partial substitution. Add one entry. */
17650 vec_safe_push (call_args
, arg
);
17655 /* We do not perform argument-dependent lookup if normal
17656 lookup finds a non-function, in accordance with the
17657 expected resolution of DR 218. */
17659 && ((is_overloaded_fn (function
)
17660 /* If lookup found a member function, the Koenig lookup is
17661 not appropriate, even if an unqualified-name was used
17662 to denote the function. */
17663 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
17664 || identifier_p (function
))
17665 /* Only do this when substitution turns a dependent call
17666 into a non-dependent call. */
17667 && type_dependent_expression_p_push (t
)
17668 && !any_type_dependent_arguments_p (call_args
))
17669 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
17671 if (function
!= NULL_TREE
17672 && identifier_p (function
)
17673 && !any_type_dependent_arguments_p (call_args
))
17675 if (koenig_p
&& (complain
& tf_warning_or_error
))
17677 /* For backwards compatibility and good diagnostics, try
17678 the unqualified lookup again if we aren't in SFINAE
17680 tree unq
= (tsubst_copy_and_build
17681 (function
, args
, complain
, in_decl
, true,
17682 integral_constant_expression_p
));
17683 if (unq
== error_mark_node
)
17685 release_tree_vector (call_args
);
17686 RETURN (error_mark_node
);
17689 if (unq
!= function
)
17691 /* In a lambda fn, we have to be careful to not
17692 introduce new this captures. Legacy code can't
17693 be using lambdas anyway, so it's ok to be
17695 bool in_lambda
= (current_class_type
17696 && LAMBDA_TYPE_P (current_class_type
));
17697 char const *const msg
17698 = G_("%qD was not declared in this scope, "
17699 "and no declarations were found by "
17700 "argument-dependent lookup at the point "
17701 "of instantiation");
17705 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
17708 diag
= permerror (EXPR_LOC_OR_LOC (t
, input_location
),
17714 if (INDIRECT_REF_P (fn
))
17715 fn
= TREE_OPERAND (fn
, 0);
17716 if (is_overloaded_fn (fn
))
17717 fn
= get_first_fn (fn
);
17720 /* Can't say anything more. */;
17721 else if (DECL_CLASS_SCOPE_P (fn
))
17723 location_t loc
= EXPR_LOC_OR_LOC (t
,
17726 "declarations in dependent base %qT are "
17727 "not found by unqualified lookup",
17728 DECL_CLASS_CONTEXT (fn
));
17729 if (current_class_ptr
)
17731 "use %<this->%D%> instead", function
);
17734 "use %<%T::%D%> instead",
17735 current_class_name
, function
);
17738 inform (DECL_SOURCE_LOCATION (fn
),
17739 "%qD declared here, later in the "
17740 "translation unit", fn
);
17743 release_tree_vector (call_args
);
17744 RETURN (error_mark_node
);
17751 if (identifier_p (function
))
17753 if (complain
& tf_error
)
17754 unqualified_name_lookup_error (function
);
17755 release_tree_vector (call_args
);
17756 RETURN (error_mark_node
);
17760 /* Remember that there was a reference to this entity. */
17761 if (function
!= NULL_TREE
17762 && DECL_P (function
)
17763 && !mark_used (function
, complain
) && !(complain
& tf_error
))
17765 release_tree_vector (call_args
);
17766 RETURN (error_mark_node
);
17769 /* Put back tf_decltype for the actual call. */
17770 complain
|= decltype_flag
;
17772 if (function
== NULL_TREE
)
17773 switch (CALL_EXPR_IFN (t
))
17776 gcc_assert (nargs
== 1);
17777 if (vec_safe_length (call_args
) != 1)
17779 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
17780 "wrong number of arguments to "
17781 "%<__builtin_launder%>");
17782 ret
= error_mark_node
;
17785 ret
= finish_builtin_launder (EXPR_LOC_OR_LOC (t
,
17787 (*call_args
)[0], complain
);
17791 /* Unsupported internal function with arguments. */
17792 gcc_unreachable ();
17794 else if (TREE_CODE (function
) == OFFSET_REF
)
17795 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
17797 else if (TREE_CODE (function
) == COMPONENT_REF
)
17799 tree instance
= TREE_OPERAND (function
, 0);
17800 tree fn
= TREE_OPERAND (function
, 1);
17802 if (processing_template_decl
17803 && (type_dependent_expression_p (instance
)
17804 || (!BASELINK_P (fn
)
17805 && TREE_CODE (fn
) != FIELD_DECL
)
17806 || type_dependent_expression_p (fn
)
17807 || any_type_dependent_arguments_p (call_args
)))
17808 ret
= build_min_nt_call_vec (function
, call_args
);
17809 else if (!BASELINK_P (fn
))
17810 ret
= finish_call_expr (function
, &call_args
,
17811 /*disallow_virtual=*/false,
17812 /*koenig_p=*/false,
17815 ret
= (build_new_method_call
17817 &call_args
, NULL_TREE
,
17818 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
17823 ret
= finish_call_expr (function
, &call_args
,
17824 /*disallow_virtual=*/qualified_p
,
17828 release_tree_vector (call_args
);
17830 if (ret
!= error_mark_node
)
17832 bool op
= CALL_EXPR_OPERATOR_SYNTAX (t
);
17833 bool ord
= CALL_EXPR_ORDERED_ARGS (t
);
17834 bool rev
= CALL_EXPR_REVERSE_ARGS (t
);
17835 bool thk
= CALL_FROM_THUNK_P (t
);
17836 if (op
|| ord
|| rev
|| thk
)
17838 function
= extract_call_expr (ret
);
17839 CALL_EXPR_OPERATOR_SYNTAX (function
) = op
;
17840 CALL_EXPR_ORDERED_ARGS (function
) = ord
;
17841 CALL_EXPR_REVERSE_ARGS (function
) = rev
;
17844 CALL_FROM_THUNK_P (function
) = true;
17845 /* The thunk location is not interesting. */
17846 SET_EXPR_LOCATION (function
, UNKNOWN_LOCATION
);
17856 tree cond
= RECUR (TREE_OPERAND (t
, 0));
17857 tree folded_cond
= fold_non_dependent_expr (cond
);
17860 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
17862 if (integer_zerop (folded_cond
))
17864 ++c_inhibit_evaluation_warnings
;
17865 exp1
= RECUR (TREE_OPERAND (t
, 1));
17866 --c_inhibit_evaluation_warnings
;
17867 exp2
= RECUR (TREE_OPERAND (t
, 2));
17871 exp1
= RECUR (TREE_OPERAND (t
, 1));
17872 ++c_inhibit_evaluation_warnings
;
17873 exp2
= RECUR (TREE_OPERAND (t
, 2));
17874 --c_inhibit_evaluation_warnings
;
17876 cond
= folded_cond
;
17880 exp1
= RECUR (TREE_OPERAND (t
, 1));
17881 exp2
= RECUR (TREE_OPERAND (t
, 2));
17884 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
17885 cond
, exp1
, exp2
, complain
));
17888 case PSEUDO_DTOR_EXPR
:
17890 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17891 tree op1
= RECUR (TREE_OPERAND (t
, 1));
17892 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
17893 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
17899 tree purpose
, value
, chain
;
17901 if (t
== void_list_node
)
17904 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
17905 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
17907 /* We have pack expansions, so expand those and
17908 create a new list out of it. */
17909 tree purposevec
= NULL_TREE
;
17910 tree valuevec
= NULL_TREE
;
17914 /* Expand the argument expressions. */
17915 if (TREE_PURPOSE (t
))
17916 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
17917 complain
, in_decl
);
17918 if (TREE_VALUE (t
))
17919 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
17920 complain
, in_decl
);
17922 /* Build the rest of the list. */
17923 chain
= TREE_CHAIN (t
);
17924 if (chain
&& chain
!= void_type_node
)
17925 chain
= RECUR (chain
);
17927 /* Determine the number of arguments. */
17928 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
17930 len
= TREE_VEC_LENGTH (purposevec
);
17931 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
17933 else if (TREE_CODE (valuevec
) == TREE_VEC
)
17934 len
= TREE_VEC_LENGTH (valuevec
);
17937 /* Since we only performed a partial substitution into
17938 the argument pack, we only RETURN (a single list
17940 if (purposevec
== TREE_PURPOSE (t
)
17941 && valuevec
== TREE_VALUE (t
)
17942 && chain
== TREE_CHAIN (t
))
17945 RETURN (tree_cons (purposevec
, valuevec
, chain
));
17948 /* Convert the argument vectors into a TREE_LIST */
17952 /* Grab the Ith values. */
17954 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
17957 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
17960 /* Build the list (backwards). */
17961 chain
= tree_cons (purpose
, value
, chain
);
17967 purpose
= TREE_PURPOSE (t
);
17969 purpose
= RECUR (purpose
);
17970 value
= TREE_VALUE (t
);
17972 value
= RECUR (value
);
17973 chain
= TREE_CHAIN (t
);
17974 if (chain
&& chain
!= void_type_node
)
17975 chain
= RECUR (chain
);
17976 if (purpose
== TREE_PURPOSE (t
)
17977 && value
== TREE_VALUE (t
)
17978 && chain
== TREE_CHAIN (t
))
17980 RETURN (tree_cons (purpose
, value
, chain
));
17983 case COMPONENT_REF
:
17990 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
17991 args
, complain
, in_decl
);
17992 /* Remember that there was a reference to this entity. */
17993 if (DECL_P (object
)
17994 && !mark_used (object
, complain
) && !(complain
& tf_error
))
17995 RETURN (error_mark_node
);
17996 object_type
= TREE_TYPE (object
);
17998 member
= TREE_OPERAND (t
, 1);
17999 if (BASELINK_P (member
))
18000 member
= tsubst_baselink (member
,
18001 non_reference (TREE_TYPE (object
)),
18002 args
, complain
, in_decl
);
18004 member
= tsubst_copy (member
, args
, complain
, in_decl
);
18005 if (member
== error_mark_node
)
18006 RETURN (error_mark_node
);
18008 if (TREE_CODE (member
) == FIELD_DECL
)
18010 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
18011 if (TREE_CODE (r
) == COMPONENT_REF
)
18012 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
18015 else if (type_dependent_expression_p (object
))
18016 /* We can't do much here. */;
18017 else if (!CLASS_TYPE_P (object_type
))
18019 if (scalarish_type_p (object_type
))
18021 tree s
= NULL_TREE
;
18022 tree dtor
= member
;
18024 if (TREE_CODE (dtor
) == SCOPE_REF
)
18026 s
= TREE_OPERAND (dtor
, 0);
18027 dtor
= TREE_OPERAND (dtor
, 1);
18029 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
18031 dtor
= TREE_OPERAND (dtor
, 0);
18033 RETURN (finish_pseudo_destructor_expr
18034 (object
, s
, dtor
, input_location
));
18038 else if (TREE_CODE (member
) == SCOPE_REF
18039 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
18041 /* Lookup the template functions now that we know what the
18043 tree scope
= TREE_OPERAND (member
, 0);
18044 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
18045 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
18046 member
= lookup_qualified_name (scope
, tmpl
,
18047 /*is_type_p=*/false,
18048 /*complain=*/false);
18049 if (BASELINK_P (member
))
18051 BASELINK_FUNCTIONS (member
)
18052 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
18054 member
= (adjust_result_of_qualified_name_lookup
18055 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
18060 qualified_name_lookup_error (scope
, tmpl
, member
,
18062 RETURN (error_mark_node
);
18065 else if (TREE_CODE (member
) == SCOPE_REF
18066 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
18067 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
18069 if (complain
& tf_error
)
18071 if (TYPE_P (TREE_OPERAND (member
, 0)))
18072 error ("%qT is not a class or namespace",
18073 TREE_OPERAND (member
, 0));
18075 error ("%qD is not a class or namespace",
18076 TREE_OPERAND (member
, 0));
18078 RETURN (error_mark_node
);
18081 r
= finish_class_member_access_expr (object
, member
,
18082 /*template_p=*/false,
18084 if (TREE_CODE (r
) == COMPONENT_REF
)
18085 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
18090 RETURN (build_throw
18091 (RECUR (TREE_OPERAND (t
, 0))));
18095 vec
<constructor_elt
, va_gc
> *n
;
18096 constructor_elt
*ce
;
18097 unsigned HOST_WIDE_INT idx
;
18098 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18099 bool process_index_p
;
18101 bool need_copy_p
= false;
18104 if (type
== error_mark_node
)
18105 RETURN (error_mark_node
);
18107 /* digest_init will do the wrong thing if we let it. */
18108 if (type
&& TYPE_PTRMEMFUNC_P (type
))
18111 /* We do not want to process the index of aggregate
18112 initializers as they are identifier nodes which will be
18113 looked up by digest_init. */
18114 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
18116 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
18117 newlen
= vec_safe_length (n
);
18118 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
18120 if (ce
->index
&& process_index_p
18121 /* An identifier index is looked up in the type
18122 being initialized, not the current scope. */
18123 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
18124 ce
->index
= RECUR (ce
->index
);
18126 if (PACK_EXPANSION_P (ce
->value
))
18128 /* Substitute into the pack expansion. */
18129 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
18132 if (ce
->value
== error_mark_node
18133 || PACK_EXPANSION_P (ce
->value
))
18135 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
18136 /* Just move the argument into place. */
18137 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
18140 /* Update the length of the final CONSTRUCTOR
18141 arguments vector, and note that we will need to
18143 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
18144 need_copy_p
= true;
18148 ce
->value
= RECUR (ce
->value
);
18153 vec
<constructor_elt
, va_gc
> *old_n
= n
;
18155 vec_alloc (n
, newlen
);
18156 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
18158 if (TREE_CODE (ce
->value
) == TREE_VEC
)
18160 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
18161 for (i
= 0; i
< len
; ++i
)
18162 CONSTRUCTOR_APPEND_ELT (n
, 0,
18163 TREE_VEC_ELT (ce
->value
, i
));
18166 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
18170 r
= build_constructor (init_list_type_node
, n
);
18171 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
18173 if (TREE_HAS_CONSTRUCTOR (t
))
18175 fcl_t cl
= fcl_functional
;
18176 if (CONSTRUCTOR_C99_COMPOUND_LITERAL (t
))
18178 RETURN (finish_compound_literal (type
, r
, complain
, cl
));
18181 TREE_TYPE (r
) = type
;
18187 tree operand_0
= TREE_OPERAND (t
, 0);
18188 if (TYPE_P (operand_0
))
18190 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
18191 RETURN (get_typeid (operand_0
, complain
));
18195 operand_0
= RECUR (operand_0
);
18196 RETURN (build_typeid (operand_0
, complain
));
18203 else if (DECL_PACK_P (t
))
18205 /* We don't build decls for an instantiation of a
18206 variadic capture proxy, we instantiate the elements
18208 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
18209 return RECUR (DECL_VALUE_EXPR (t
));
18215 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
18216 /* ??? We're doing a subset of finish_id_expression here. */
18218 && !processing_template_decl
18219 && !cp_unevaluated_operand
18220 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
18221 && CP_DECL_THREAD_LOCAL_P (r
))
18223 if (tree wrap
= get_tls_wrapper_fn (r
))
18224 /* Replace an evaluated use of the thread_local variable with
18225 a call to its wrapper. */
18226 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
18228 else if (outer_automatic_var_p (r
))
18229 r
= process_outer_var_ref (r
, complain
);
18231 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
18232 /* If the original type was a reference, we'll be wrapped in
18233 the appropriate INDIRECT_REF. */
18234 r
= convert_from_reference (r
);
18240 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18241 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18242 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
18245 case OFFSETOF_EXPR
:
18248 = tsubst_copy_and_build (TREE_OPERAND (t
, 1), args
, complain
,
18249 in_decl
, /*function_p=*/false,
18250 /*integral_constant_expression_p=*/false);
18251 RETURN (finish_offsetof (object_ptr
,
18252 RECUR (TREE_OPERAND (t
, 0)),
18253 EXPR_LOCATION (t
)));
18256 case ADDRESSOF_EXPR
:
18257 RETURN (cp_build_addressof (EXPR_LOCATION (t
),
18258 RECUR (TREE_OPERAND (t
, 0)), complain
));
18262 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
18263 complain
, in_decl
);
18265 tree type2
= TRAIT_EXPR_TYPE2 (t
);
18266 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
18267 type2
= RECUR (type2
);
18269 type2
= tsubst (type2
, args
, complain
, in_decl
);
18271 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
18276 tree old_stmt_expr
= cur_stmt_expr
;
18277 tree stmt_expr
= begin_stmt_expr ();
18279 cur_stmt_expr
= stmt_expr
;
18280 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
18281 integral_constant_expression_p
);
18282 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
18283 cur_stmt_expr
= old_stmt_expr
;
18285 /* If the resulting list of expression statement is empty,
18286 fold it further into void_node. */
18287 if (empty_expr_stmt_p (stmt_expr
))
18288 stmt_expr
= void_node
;
18290 RETURN (stmt_expr
);
18295 tree r
= tsubst_lambda_expr (t
, args
, complain
, in_decl
);
18297 RETURN (build_lambda_object (r
));
18301 /* We can get here for a constant initializer of non-dependent type.
18302 FIXME stop folding in cp_parser_initializer_clause. */
18304 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
18309 case TRANSACTION_EXPR
:
18310 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
18311 integral_constant_expression_p
));
18314 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
18316 case VEC_PERM_EXPR
:
18318 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18319 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18320 tree op2
= RECUR (TREE_OPERAND (t
, 2));
18321 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
18325 case REQUIRES_EXPR
:
18326 RETURN (tsubst_requires_expr (t
, args
, complain
, in_decl
));
18329 /* Handle Objective-C++ constructs, if appropriate. */
18332 = objcp_tsubst_copy_and_build (t
, args
, complain
,
18333 in_decl
, /*function_p=*/false);
18337 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
18343 input_location
= loc
;
18347 /* Verify that the instantiated ARGS are valid. For type arguments,
18348 make sure that the type's linkage is ok. For non-type arguments,
18349 make sure they are constants if they are integral or enumerations.
18350 Emit an error under control of COMPLAIN, and return TRUE on error. */
18353 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
18355 if (dependent_template_arg_p (t
))
18357 if (ARGUMENT_PACK_P (t
))
18359 tree vec
= ARGUMENT_PACK_ARGS (t
);
18360 int len
= TREE_VEC_LENGTH (vec
);
18361 bool result
= false;
18364 for (i
= 0; i
< len
; ++i
)
18365 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
18369 else if (TYPE_P (t
))
18371 /* [basic.link]: A name with no linkage (notably, the name
18372 of a class or enumeration declared in a local scope)
18373 shall not be used to declare an entity with linkage.
18374 This implies that names with no linkage cannot be used as
18377 DR 757 relaxes this restriction for C++0x. */
18378 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
18379 : no_linkage_check (t
, /*relaxed_p=*/false));
18383 /* DR 488 makes use of a type with no linkage cause
18384 type deduction to fail. */
18385 if (complain
& tf_error
)
18387 if (TYPE_UNNAMED_P (nt
))
18388 error ("%qT is/uses unnamed type", t
);
18390 error ("template argument for %qD uses local type %qT",
18395 /* In order to avoid all sorts of complications, we do not
18396 allow variably-modified types as template arguments. */
18397 else if (variably_modified_type_p (t
, NULL_TREE
))
18399 if (complain
& tf_error
)
18400 error ("%qT is a variably modified type", t
);
18404 /* Class template and alias template arguments should be OK. */
18405 else if (DECL_TYPE_TEMPLATE_P (t
))
18407 /* A non-type argument of integral or enumerated type must be a
18409 else if (TREE_TYPE (t
)
18410 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
18411 && !REFERENCE_REF_P (t
)
18412 && !TREE_CONSTANT (t
))
18414 if (complain
& tf_error
)
18415 error ("integral expression %qE is not constant", t
);
18422 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
18424 int ix
, len
= DECL_NTPARMS (tmpl
);
18425 bool result
= false;
18427 for (ix
= 0; ix
!= len
; ix
++)
18429 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
18432 if (result
&& (complain
& tf_error
))
18433 error (" trying to instantiate %qD", tmpl
);
18437 /* We're out of SFINAE context now, so generate diagnostics for the access
18438 errors we saw earlier when instantiating D from TMPL and ARGS. */
18441 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
18443 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
18444 tree type
= TREE_TYPE (pattern
);
18445 location_t loc
= input_location
;
18447 push_access_scope (d
);
18448 push_deferring_access_checks (dk_no_deferred
);
18449 input_location
= DECL_SOURCE_LOCATION (pattern
);
18450 tsubst (type
, args
, tf_warning_or_error
, d
);
18451 input_location
= loc
;
18452 pop_deferring_access_checks ();
18453 pop_access_scope (d
);
18456 /* Instantiate the indicated variable, function, or alias template TMPL with
18457 the template arguments in TARG_PTR. */
18460 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
18462 tree targ_ptr
= orig_args
;
18466 bool access_ok
= true;
18468 if (tmpl
== error_mark_node
)
18469 return error_mark_node
;
18471 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
18473 /* If this function is a clone, handle it specially. */
18474 if (DECL_CLONED_FUNCTION_P (tmpl
))
18479 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
18480 DECL_CLONED_FUNCTION. */
18481 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
18482 targ_ptr
, complain
);
18483 if (spec
== error_mark_node
)
18484 return error_mark_node
;
18486 /* Look for the clone. */
18487 FOR_EACH_CLONE (clone
, spec
)
18488 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
18490 /* We should always have found the clone by now. */
18491 gcc_unreachable ();
18495 if (targ_ptr
== error_mark_node
)
18496 return error_mark_node
;
18498 /* Check to see if we already have this specialization. */
18499 gen_tmpl
= most_general_template (tmpl
);
18500 if (TMPL_ARGS_DEPTH (targ_ptr
)
18501 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
)))
18502 /* targ_ptr only has the innermost template args, so add the outer ones
18503 from tmpl, which could be either a partial instantiation or gen_tmpl (in
18504 the case of a non-dependent call within a template definition). */
18505 targ_ptr
= (add_outermost_template_args
18506 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (tmpl
)),
18509 /* It would be nice to avoid hashing here and then again in tsubst_decl,
18510 but it doesn't seem to be on the hot path. */
18511 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
18513 gcc_assert (tmpl
== gen_tmpl
18514 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
18516 || fndecl
== NULL_TREE
);
18518 if (spec
!= NULL_TREE
)
18520 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
18522 if (complain
& tf_error
)
18523 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
18524 return error_mark_node
;
18529 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
18531 return error_mark_node
;
18533 /* We are building a FUNCTION_DECL, during which the access of its
18534 parameters and return types have to be checked. However this
18535 FUNCTION_DECL which is the desired context for access checking
18536 is not built yet. We solve this chicken-and-egg problem by
18537 deferring all checks until we have the FUNCTION_DECL. */
18538 push_deferring_access_checks (dk_deferred
);
18540 /* Instantiation of the function happens in the context of the function
18541 template, not the context of the overload resolution we're doing. */
18542 push_to_top_level ();
18543 /* If there are dependent arguments, e.g. because we're doing partial
18544 ordering, make sure processing_template_decl stays set. */
18545 if (uses_template_parms (targ_ptr
))
18546 ++processing_template_decl
;
18547 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
18549 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
18550 complain
, gen_tmpl
, true);
18551 push_nested_class (ctx
);
18554 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
18556 fndecl
= NULL_TREE
;
18557 if (VAR_P (pattern
))
18559 /* We need to determine if we're using a partial or explicit
18560 specialization now, because the type of the variable could be
18562 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
18563 tree elt
= most_specialized_partial_spec (tid
, complain
);
18564 if (elt
== error_mark_node
)
18565 pattern
= error_mark_node
;
18568 tree partial_tmpl
= TREE_VALUE (elt
);
18569 tree partial_args
= TREE_PURPOSE (elt
);
18570 tree partial_pat
= DECL_TEMPLATE_RESULT (partial_tmpl
);
18571 fndecl
= tsubst (partial_pat
, partial_args
, complain
, gen_tmpl
);
18575 /* Substitute template parameters to obtain the specialization. */
18576 if (fndecl
== NULL_TREE
)
18577 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
18578 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
18579 pop_nested_class ();
18580 pop_from_top_level ();
18582 if (fndecl
== error_mark_node
)
18584 pop_deferring_access_checks ();
18585 return error_mark_node
;
18588 /* The DECL_TI_TEMPLATE should always be the immediate parent
18589 template, not the most general template. */
18590 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
18591 DECL_TI_ARGS (fndecl
) = targ_ptr
;
18593 /* Now we know the specialization, compute access previously
18594 deferred. Do no access control for inheriting constructors,
18595 as we already checked access for the inherited constructor. */
18596 if (!(flag_new_inheriting_ctors
18597 && DECL_INHERITED_CTOR (fndecl
)))
18599 push_access_scope (fndecl
);
18600 if (!perform_deferred_access_checks (complain
))
18602 pop_access_scope (fndecl
);
18604 pop_deferring_access_checks ();
18606 /* If we've just instantiated the main entry point for a function,
18607 instantiate all the alternate entry points as well. We do this
18608 by cloning the instantiation of the main entry point, not by
18609 instantiating the template clones. */
18610 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
18611 clone_function_decl (fndecl
, /*update_methods=*/false);
18615 if (!(complain
& tf_error
))
18617 /* Remember to reinstantiate when we're out of SFINAE so the user
18618 can see the errors. */
18619 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
18621 return error_mark_node
;
18626 /* Wrapper for instantiate_template_1. */
18629 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
18632 timevar_push (TV_TEMPLATE_INST
);
18633 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
18634 timevar_pop (TV_TEMPLATE_INST
);
18638 /* Instantiate the alias template TMPL with ARGS. Also push a template
18639 instantiation level, which instantiate_template doesn't do because
18640 functions and variables have sufficient context established by the
18644 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
18646 struct pending_template
*old_last_pend
= last_pending_template
;
18647 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
18648 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
18649 return error_mark_node
;
18650 tree tinst
= build_tree_list (tmpl
, args
);
18651 if (!push_tinst_level (tinst
))
18654 return error_mark_node
;
18658 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
18659 args
, tmpl
, complain
,
18660 /*require_all_args=*/true,
18661 /*use_default_args=*/true);
18663 tree r
= instantiate_template (tmpl
, args
, complain
);
18664 pop_tinst_level ();
18665 /* We can't free this if a pending_template entry or last_error_tinst_level
18666 is pointing at it. */
18667 if (last_pending_template
== old_last_pend
18668 && last_error_tinst_level
== old_error_tinst
)
18674 /* PARM is a template parameter pack for FN. Returns true iff
18675 PARM is used in a deducible way in the argument list of FN. */
18678 pack_deducible_p (tree parm
, tree fn
)
18680 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
18681 for (; t
; t
= TREE_CHAIN (t
))
18683 tree type
= TREE_VALUE (t
);
18685 if (!PACK_EXPANSION_P (type
))
18687 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
18688 packs
; packs
= TREE_CHAIN (packs
))
18689 if (template_args_equal (TREE_VALUE (packs
), parm
))
18691 /* The template parameter pack is used in a function parameter
18692 pack. If this is the end of the parameter list, the
18693 template parameter pack is deducible. */
18694 if (TREE_CHAIN (t
) == void_list_node
)
18697 /* Otherwise, not. Well, it could be deduced from
18698 a non-pack parameter, but doing so would end up with
18699 a deduction mismatch, so don't bother. */
18703 /* The template parameter pack isn't used in any function parameter
18704 packs, but it might be used deeper, e.g. tuple<Args...>. */
18708 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
18709 NARGS elements of the arguments that are being used when calling
18710 it. TARGS is a vector into which the deduced template arguments
18713 Returns either a FUNCTION_DECL for the matching specialization of FN or
18714 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
18715 true, diagnostics will be printed to explain why it failed.
18717 If FN is a conversion operator, or we are trying to produce a specific
18718 specialization, RETURN_TYPE is the return type desired.
18720 The EXPLICIT_TARGS are explicit template arguments provided via a
18723 The parameter STRICT is one of:
18726 We are deducing arguments for a function call, as in
18727 [temp.deduct.call]. If RETURN_TYPE is non-null, we are
18728 deducing arguments for a call to the result of a conversion
18729 function template, as in [over.call.object].
18732 We are deducing arguments for a conversion function, as in
18733 [temp.deduct.conv].
18736 We are deducing arguments when doing an explicit instantiation
18737 as in [temp.explicit], when determining an explicit specialization
18738 as in [temp.expl.spec], or when taking the address of a function
18739 template, as in [temp.deduct.funcaddr]. */
18742 fn_type_unification (tree fn
,
18743 tree explicit_targs
,
18746 unsigned int nargs
,
18748 unification_kind_t strict
,
18755 tree decl
= NULL_TREE
;
18756 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
18758 static int deduction_depth
;
18759 struct pending_template
*old_last_pend
= last_pending_template
;
18760 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
18763 if (flag_new_inheriting_ctors
)
18764 fn
= strip_inheriting_ctors (fn
);
18766 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
18768 tree r
= error_mark_node
;
18770 tree full_targs
= targs
;
18771 if (TMPL_ARGS_DEPTH (targs
)
18772 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (fn
)))
18773 full_targs
= (add_outermost_template_args
18774 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (fn
)),
18778 complain
|= tf_decltype
;
18780 /* In C++0x, it's possible to have a function template whose type depends
18781 on itself recursively. This is most obvious with decltype, but can also
18782 occur with enumeration scope (c++/48969). So we need to catch infinite
18783 recursion and reject the substitution at deduction time; this function
18784 will return error_mark_node for any repeated substitution.
18786 This also catches excessive recursion such as when f<N> depends on
18787 f<N-1> across all integers, and returns error_mark_node for all the
18788 substitutions back up to the initial one.
18790 This is, of course, not reentrant. */
18791 if (excessive_deduction_depth
)
18792 return error_mark_node
;
18793 tinst
= build_tree_list (fn
, NULL_TREE
);
18796 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
18798 fntype
= TREE_TYPE (fn
);
18799 if (explicit_targs
)
18803 The specified template arguments must match the template
18804 parameters in kind (i.e., type, nontype, template), and there
18805 must not be more arguments than there are parameters;
18806 otherwise type deduction fails.
18808 Nontype arguments must match the types of the corresponding
18809 nontype template parameters, or must be convertible to the
18810 types of the corresponding nontype parameters as specified in
18811 _temp.arg.nontype_, otherwise type deduction fails.
18813 All references in the function type of the function template
18814 to the corresponding template parameters are replaced by the
18815 specified template argument values. If a substitution in a
18816 template parameter or in the function type of the function
18817 template results in an invalid type, type deduction fails. */
18818 int i
, len
= TREE_VEC_LENGTH (tparms
);
18819 location_t loc
= input_location
;
18820 bool incomplete
= false;
18822 if (explicit_targs
== error_mark_node
)
18825 if (TMPL_ARGS_DEPTH (explicit_targs
)
18826 < TMPL_ARGS_DEPTH (full_targs
))
18827 explicit_targs
= add_outermost_template_args (full_targs
,
18830 /* Adjust any explicit template arguments before entering the
18831 substitution context. */
18833 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
18835 /*require_all_args=*/false,
18836 /*use_default_args=*/false));
18837 if (explicit_targs
== error_mark_node
)
18840 /* Substitute the explicit args into the function type. This is
18841 necessary so that, for instance, explicitly declared function
18842 arguments can match null pointed constants. If we were given
18843 an incomplete set of explicit args, we must not do semantic
18844 processing during substitution as we could create partial
18846 for (i
= 0; i
< len
; i
++)
18848 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
18849 bool parameter_pack
= false;
18850 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
18852 /* Dig out the actual parm. */
18853 if (TREE_CODE (parm
) == TYPE_DECL
18854 || TREE_CODE (parm
) == TEMPLATE_DECL
)
18856 parm
= TREE_TYPE (parm
);
18857 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
18859 else if (TREE_CODE (parm
) == PARM_DECL
)
18861 parm
= DECL_INITIAL (parm
);
18862 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
18865 if (!parameter_pack
&& targ
== NULL_TREE
)
18866 /* No explicit argument for this template parameter. */
18869 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
18871 /* Mark the argument pack as "incomplete". We could
18872 still deduce more arguments during unification.
18873 We remove this mark in type_unification_real. */
18876 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
18877 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
18878 = ARGUMENT_PACK_ARGS (targ
);
18881 /* We have some incomplete argument packs. */
18886 TREE_VALUE (tinst
) = explicit_targs
;
18887 if (!push_tinst_level (tinst
))
18889 excessive_deduction_depth
= true;
18892 processing_template_decl
+= incomplete
;
18893 input_location
= DECL_SOURCE_LOCATION (fn
);
18894 /* Ignore any access checks; we'll see them again in
18895 instantiate_template and they might have the wrong
18896 access path at this point. */
18897 push_deferring_access_checks (dk_deferred
);
18898 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
18899 complain
| tf_partial
| tf_fndecl_type
, NULL_TREE
);
18900 pop_deferring_access_checks ();
18901 input_location
= loc
;
18902 processing_template_decl
-= incomplete
;
18903 pop_tinst_level ();
18905 if (fntype
== error_mark_node
)
18908 /* Place the explicitly specified arguments in TARGS. */
18909 explicit_targs
= INNERMOST_TEMPLATE_ARGS (explicit_targs
);
18910 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
18911 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
18914 /* Never do unification on the 'this' parameter. */
18915 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
18917 if (return_type
&& strict
== DEDUCE_CALL
)
18919 /* We're deducing for a call to the result of a template conversion
18920 function. The parms we really want are in return_type. */
18921 if (POINTER_TYPE_P (return_type
))
18922 return_type
= TREE_TYPE (return_type
);
18923 parms
= TYPE_ARG_TYPES (return_type
);
18925 else if (return_type
)
18929 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
18930 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
18931 new_args
[0] = return_type
;
18932 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
18937 /* We allow incomplete unification without an error message here
18938 because the standard doesn't seem to explicitly prohibit it. Our
18939 callers must be ready to deal with unification failures in any
18942 TREE_VALUE (tinst
) = targs
;
18943 /* If we aren't explaining yet, push tinst context so we can see where
18944 any errors (e.g. from class instantiations triggered by instantiation
18945 of default template arguments) come from. If we are explaining, this
18946 context is redundant. */
18947 if (!explain_p
&& !push_tinst_level (tinst
))
18949 excessive_deduction_depth
= true;
18953 /* type_unification_real will pass back any access checks from default
18954 template argument substitution. */
18955 vec
<deferred_access_check
, va_gc
> *checks
;
18958 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
18959 full_targs
, parms
, args
, nargs
, /*subr=*/0,
18960 strict
, flags
, &checks
, explain_p
);
18962 pop_tinst_level ();
18966 /* Now that we have bindings for all of the template arguments,
18967 ensure that the arguments deduced for the template template
18968 parameters have compatible template parameter lists. We cannot
18969 check this property before we have deduced all template
18970 arguments, because the template parameter types of a template
18971 template parameter might depend on prior template parameters
18972 deduced after the template template parameter. The following
18973 ill-formed example illustrates this issue:
18975 template<typename T, template<T> class C> void f(C<5>, T);
18977 template<int N> struct X {};
18980 f(X<5>(), 5l); // error: template argument deduction fails
18983 The template parameter list of 'C' depends on the template type
18984 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
18985 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
18986 time that we deduce 'C'. */
18987 if (!template_template_parm_bindings_ok_p
18988 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
18990 unify_inconsistent_template_template_parameters (explain_p
);
18994 /* All is well so far. Now, check:
18998 When all template arguments have been deduced, all uses of
18999 template parameters in nondeduced contexts are replaced with
19000 the corresponding deduced argument values. If the
19001 substitution results in an invalid type, as described above,
19002 type deduction fails. */
19003 TREE_VALUE (tinst
) = targs
;
19004 if (!push_tinst_level (tinst
))
19006 excessive_deduction_depth
= true;
19010 /* Also collect access checks from the instantiation. */
19011 reopen_deferring_access_checks (checks
);
19013 decl
= instantiate_template (fn
, targs
, complain
);
19015 checks
= get_deferred_access_checks ();
19016 pop_deferring_access_checks ();
19018 pop_tinst_level ();
19020 if (decl
== error_mark_node
)
19023 /* Now perform any access checks encountered during substitution. */
19024 push_access_scope (decl
);
19025 ok
= perform_access_checks (checks
, complain
);
19026 pop_access_scope (decl
);
19030 /* If we're looking for an exact match, check that what we got
19031 is indeed an exact match. It might not be if some template
19032 parameters are used in non-deduced contexts. But don't check
19033 for an exact match if we have dependent template arguments;
19034 in that case we're doing partial ordering, and we already know
19035 that we have two candidates that will provide the actual type. */
19036 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
19038 tree substed
= TREE_TYPE (decl
);
19042 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
19044 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
19045 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
19046 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
19048 unify_type_mismatch (explain_p
, args
[i
],
19049 TREE_VALUE (sarg
));
19054 /* After doing deduction with the inherited constructor, actually return an
19055 instantiation of the inheriting constructor. */
19057 decl
= instantiate_template (orig_fn
, targs
, complain
);
19063 if (excessive_deduction_depth
)
19065 if (deduction_depth
== 0)
19066 /* Reset once we're all the way out. */
19067 excessive_deduction_depth
= false;
19070 /* We can't free this if a pending_template entry or last_error_tinst_level
19071 is pointing at it. */
19072 if (last_pending_template
== old_last_pend
19073 && last_error_tinst_level
== old_error_tinst
)
19079 /* Adjust types before performing type deduction, as described in
19080 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
19081 sections are symmetric. PARM is the type of a function parameter
19082 or the return type of the conversion function. ARG is the type of
19083 the argument passed to the call, or the type of the value
19084 initialized with the result of the conversion function.
19085 ARG_EXPR is the original argument expression, which may be null. */
19088 maybe_adjust_types_for_deduction (unification_kind_t strict
,
19101 /* Swap PARM and ARG throughout the remainder of this
19102 function; the handling is precisely symmetric since PARM
19103 will initialize ARG rather than vice versa. */
19104 std::swap (parm
, arg
);
19108 /* Core issue #873: Do the DR606 thing (see below) for these cases,
19109 too, but here handle it by stripping the reference from PARM
19110 rather than by adding it to ARG. */
19111 if (TREE_CODE (*parm
) == REFERENCE_TYPE
19112 && TYPE_REF_IS_RVALUE (*parm
)
19113 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
19114 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
19115 && TREE_CODE (*arg
) == REFERENCE_TYPE
19116 && !TYPE_REF_IS_RVALUE (*arg
))
19117 *parm
= TREE_TYPE (*parm
);
19118 /* Nothing else to do in this case. */
19122 gcc_unreachable ();
19125 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
19127 /* [temp.deduct.call]
19129 If P is not a reference type:
19131 --If A is an array type, the pointer type produced by the
19132 array-to-pointer standard conversion (_conv.array_) is
19133 used in place of A for type deduction; otherwise,
19135 --If A is a function type, the pointer type produced by
19136 the function-to-pointer standard conversion
19137 (_conv.func_) is used in place of A for type deduction;
19140 --If A is a cv-qualified type, the top level
19141 cv-qualifiers of A's type are ignored for type
19143 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
19144 *arg
= build_pointer_type (TREE_TYPE (*arg
));
19145 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
19146 *arg
= build_pointer_type (*arg
);
19148 *arg
= TYPE_MAIN_VARIANT (*arg
);
19151 /* [14.8.2.1/3 temp.deduct.call], "A forwarding reference is an rvalue
19152 reference to a cv-unqualified template parameter that does not represent a
19153 template parameter of a class template (during class template argument
19154 deduction (13.3.1.8)). If P is a forwarding reference and the argument is
19155 an lvalue, the type "lvalue reference to A" is used in place of A for type
19157 if (TREE_CODE (*parm
) == REFERENCE_TYPE
19158 && TYPE_REF_IS_RVALUE (*parm
)
19159 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
19160 && !TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (*parm
))
19161 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
19162 && (arg_expr
? lvalue_p (arg_expr
)
19163 /* try_one_overload doesn't provide an arg_expr, but
19164 functions are always lvalues. */
19165 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
19166 *arg
= build_reference_type (*arg
);
19168 /* [temp.deduct.call]
19170 If P is a cv-qualified type, the top level cv-qualifiers
19171 of P's type are ignored for type deduction. If P is a
19172 reference type, the type referred to by P is used for
19174 *parm
= TYPE_MAIN_VARIANT (*parm
);
19175 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
19177 *parm
= TREE_TYPE (*parm
);
19178 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
19181 /* DR 322. For conversion deduction, remove a reference type on parm
19182 too (which has been swapped into ARG). */
19183 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
19184 *arg
= TREE_TYPE (*arg
);
19189 /* Subroutine of unify_one_argument. PARM is a function parameter of a
19190 template which does contain any deducible template parameters; check if
19191 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
19192 unify_one_argument. */
19195 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
19196 int flags
, bool explain_p
)
19201 type
= TREE_TYPE (arg
);
19205 if (same_type_p (parm
, type
))
19206 return unify_success (explain_p
);
19208 if (strict
== DEDUCE_CONV
)
19210 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
19211 explain_p
? tf_warning_or_error
: tf_none
))
19212 return unify_success (explain_p
);
19214 else if (strict
!= DEDUCE_EXACT
)
19216 if (can_convert_arg (parm
, type
,
19217 TYPE_P (arg
) ? NULL_TREE
: arg
,
19218 flags
, explain_p
? tf_warning_or_error
: tf_none
))
19219 return unify_success (explain_p
);
19222 if (strict
== DEDUCE_EXACT
)
19223 return unify_type_mismatch (explain_p
, parm
, arg
);
19225 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
19228 static bool uses_deducible_template_parms (tree type
);
19230 /* Returns true iff the expression EXPR is one from which a template
19231 argument can be deduced. In other words, if it's an undecorated
19232 use of a template non-type parameter. */
19235 deducible_expression (tree expr
)
19237 /* Strip implicit conversions. */
19238 while (CONVERT_EXPR_P (expr
))
19239 expr
= TREE_OPERAND (expr
, 0);
19240 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
19243 /* Returns true iff the array domain DOMAIN uses a template parameter in a
19244 deducible way; that is, if it has a max value of <PARM> - 1. */
19247 deducible_array_bound (tree domain
)
19249 if (domain
== NULL_TREE
)
19252 tree max
= TYPE_MAX_VALUE (domain
);
19253 if (TREE_CODE (max
) != MINUS_EXPR
)
19256 return deducible_expression (TREE_OPERAND (max
, 0));
19259 /* Returns true iff the template arguments ARGS use a template parameter
19260 in a deducible way. */
19263 deducible_template_args (tree args
)
19265 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
19268 tree elt
= TREE_VEC_ELT (args
, i
);
19269 if (ARGUMENT_PACK_P (elt
))
19270 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
19273 if (PACK_EXPANSION_P (elt
))
19274 elt
= PACK_EXPANSION_PATTERN (elt
);
19275 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
19277 else if (TYPE_P (elt
))
19278 deducible
= uses_deducible_template_parms (elt
);
19280 deducible
= deducible_expression (elt
);
19288 /* Returns true iff TYPE contains any deducible references to template
19289 parameters, as per 14.8.2.5. */
19292 uses_deducible_template_parms (tree type
)
19294 if (PACK_EXPANSION_P (type
))
19295 type
= PACK_EXPANSION_PATTERN (type
);
19302 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
19303 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
19309 if (POINTER_TYPE_P (type
))
19310 return uses_deducible_template_parms (TREE_TYPE (type
));
19312 /* T[integer-constant ]
19314 if (TREE_CODE (type
) == ARRAY_TYPE
)
19315 return (uses_deducible_template_parms (TREE_TYPE (type
))
19316 || deducible_array_bound (TYPE_DOMAIN (type
)));
19328 if (TYPE_PTRMEM_P (type
))
19329 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
19330 || (uses_deducible_template_parms
19331 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
19333 /* template-name <T> (where template-name refers to a class template)
19334 template-name <i> (where template-name refers to a class template) */
19335 if (CLASS_TYPE_P (type
)
19336 && CLASSTYPE_TEMPLATE_INFO (type
)
19337 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
19338 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
19339 (CLASSTYPE_TI_ARGS (type
)));
19344 if (TREE_CODE (type
) == FUNCTION_TYPE
19345 || TREE_CODE (type
) == METHOD_TYPE
)
19347 if (uses_deducible_template_parms (TREE_TYPE (type
)))
19349 tree parm
= TYPE_ARG_TYPES (type
);
19350 if (TREE_CODE (type
) == METHOD_TYPE
)
19351 parm
= TREE_CHAIN (parm
);
19352 for (; parm
; parm
= TREE_CHAIN (parm
))
19353 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
19360 /* Subroutine of type_unification_real and unify_pack_expansion to
19361 handle unification of a single P/A pair. Parameters are as
19362 for those functions. */
19365 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
19366 int subr
, unification_kind_t strict
,
19369 tree arg_expr
= NULL_TREE
;
19372 if (arg
== error_mark_node
|| parm
== error_mark_node
)
19373 return unify_invalid (explain_p
);
19374 if (arg
== unknown_type_node
)
19375 /* We can't deduce anything from this, but we might get all the
19376 template args from other function args. */
19377 return unify_success (explain_p
);
19379 /* Implicit conversions (Clause 4) will be performed on a function
19380 argument to convert it to the type of the corresponding function
19381 parameter if the parameter type contains no template-parameters that
19382 participate in template argument deduction. */
19383 if (strict
!= DEDUCE_EXACT
19384 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
19385 /* For function parameters with no deducible template parameters,
19386 just return. We'll check non-dependent conversions later. */
19387 return unify_success (explain_p
);
19392 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
19393 | UNIFY_ALLOW_MORE_CV_QUAL
19394 | UNIFY_ALLOW_DERIVED
);
19398 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
19402 arg_strict
= UNIFY_ALLOW_NONE
;
19406 gcc_unreachable ();
19409 /* We only do these transformations if this is the top-level
19410 parameter_type_list in a call or declaration matching; in other
19411 situations (nested function declarators, template argument lists) we
19412 won't be comparing a type to an expression, and we don't do any type
19418 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
19419 if (type_unknown_p (arg
))
19421 /* [temp.deduct.type] A template-argument can be
19422 deduced from a pointer to function or pointer
19423 to member function argument if the set of
19424 overloaded functions does not contain function
19425 templates and at most one of a set of
19426 overloaded functions provides a unique
19428 resolve_overloaded_unification (tparms
, targs
, parm
,
19430 arg_strict
, explain_p
);
19431 /* If a unique match was not found, this is a
19432 non-deduced context, so we still succeed. */
19433 return unify_success (explain_p
);
19437 arg
= unlowered_expr_type (arg
);
19438 if (arg
== error_mark_node
)
19439 return unify_invalid (explain_p
);
19443 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
19446 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
19447 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
19448 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
19450 /* For deduction from an init-list we need the actual list. */
19451 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
19453 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
19456 /* for_each_template_parm callback that always returns 0. */
19459 zero_r (tree
, void *)
19464 /* for_each_template_parm any_fn callback to handle deduction of a template
19465 type argument from the type of an array bound. */
19468 array_deduction_r (tree t
, void *data
)
19470 tree_pair_p d
= (tree_pair_p
)data
;
19471 tree
&tparms
= d
->purpose
;
19472 tree
&targs
= d
->value
;
19474 if (TREE_CODE (t
) == ARRAY_TYPE
)
19475 if (tree dom
= TYPE_DOMAIN (t
))
19476 if (tree max
= TYPE_MAX_VALUE (dom
))
19478 if (TREE_CODE (max
) == MINUS_EXPR
)
19479 max
= TREE_OPERAND (max
, 0);
19480 if (TREE_CODE (max
) == TEMPLATE_PARM_INDEX
)
19481 unify (tparms
, targs
, TREE_TYPE (max
), size_type_node
,
19482 UNIFY_ALLOW_NONE
, /*explain*/false);
19485 /* Keep walking. */
19489 /* Try to deduce any not-yet-deduced template type arguments from the type of
19490 an array bound. This is handled separately from unify because 14.8.2.5 says
19491 "The type of a type parameter is only deduced from an array bound if it is
19492 not otherwise deduced." */
19495 try_array_deduction (tree tparms
, tree targs
, tree parm
)
19497 tree_pair_s data
= { tparms
, targs
};
19498 hash_set
<tree
> visited
;
19499 for_each_template_parm (parm
, zero_r
, &data
, &visited
,
19500 /*nondeduced*/false, array_deduction_r
);
19503 /* Most parms like fn_type_unification.
19505 If SUBR is 1, we're being called recursively (to unify the
19506 arguments of a function or method parameter of a function
19509 CHECKS is a pointer to a vector of access checks encountered while
19510 substituting default template arguments. */
19513 type_unification_real (tree tparms
,
19517 unsigned int xnargs
,
19519 unification_kind_t strict
,
19521 vec
<deferred_access_check
, va_gc
> **checks
,
19526 int ntparms
= TREE_VEC_LENGTH (tparms
);
19527 int saw_undeduced
= 0;
19530 unsigned int nargs
;
19533 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
19534 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
19535 gcc_assert (ntparms
> 0);
19537 tree targs
= INNERMOST_TEMPLATE_ARGS (full_targs
);
19539 /* Reset the number of non-defaulted template arguments contained
19541 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
19549 while (parms
&& parms
!= void_list_node
19552 parm
= TREE_VALUE (parms
);
19554 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
19555 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
19556 /* For a function parameter pack that occurs at the end of the
19557 parameter-declaration-list, the type A of each remaining
19558 argument of the call is compared with the type P of the
19559 declarator-id of the function parameter pack. */
19562 parms
= TREE_CHAIN (parms
);
19564 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
19565 /* For a function parameter pack that does not occur at the
19566 end of the parameter-declaration-list, the type of the
19567 parameter pack is a non-deduced context. */
19573 if (unify_one_argument (tparms
, full_targs
, parm
, arg
, subr
, strict
,
19579 && parms
!= void_list_node
19580 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
19582 /* Unify the remaining arguments with the pack expansion type. */
19584 tree parmvec
= make_tree_vec (1);
19586 /* Allocate a TREE_VEC and copy in all of the arguments */
19587 argvec
= make_tree_vec (nargs
- ia
);
19588 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
19589 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
19591 /* Copy the parameter into parmvec. */
19592 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
19593 if (unify_pack_expansion (tparms
, full_targs
, parmvec
, argvec
, strict
,
19594 /*subr=*/subr
, explain_p
))
19597 /* Advance to the end of the list of parameters. */
19598 parms
= TREE_CHAIN (parms
);
19601 /* Fail if we've reached the end of the parm list, and more args
19602 are present, and the parm list isn't variadic. */
19603 if (ia
< nargs
&& parms
== void_list_node
)
19604 return unify_too_many_arguments (explain_p
, nargs
, ia
);
19605 /* Fail if parms are left and they don't have default values and
19606 they aren't all deduced as empty packs (c++/57397). This is
19607 consistent with sufficient_parms_p. */
19608 if (parms
&& parms
!= void_list_node
19609 && TREE_PURPOSE (parms
) == NULL_TREE
)
19611 unsigned int count
= nargs
;
19616 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
19619 p
= TREE_CHAIN (p
);
19621 while (p
&& p
!= void_list_node
);
19622 if (count
!= nargs
)
19623 return unify_too_few_arguments (explain_p
, ia
, count
,
19629 tsubst_flags_t complain
= (explain_p
19630 ? tf_warning_or_error
19632 bool tried_array_deduction
= (cxx_dialect
< cxx17
);
19634 for (i
= 0; i
< ntparms
; i
++)
19636 tree targ
= TREE_VEC_ELT (targs
, i
);
19637 tree tparm
= TREE_VEC_ELT (tparms
, i
);
19639 /* Clear the "incomplete" flags on all argument packs now so that
19640 substituting them into later default arguments works. */
19641 if (targ
&& ARGUMENT_PACK_P (targ
))
19643 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
19644 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
19647 if (targ
|| tparm
== error_mark_node
)
19649 tparm
= TREE_VALUE (tparm
);
19651 if (TREE_CODE (tparm
) == TYPE_DECL
19652 && !tried_array_deduction
)
19654 try_array_deduction (tparms
, targs
, xparms
);
19655 tried_array_deduction
= true;
19656 if (TREE_VEC_ELT (targs
, i
))
19660 /* If this is an undeduced nontype parameter that depends on
19661 a type parameter, try another pass; its type may have been
19662 deduced from a later argument than the one from which
19663 this parameter can be deduced. */
19664 if (TREE_CODE (tparm
) == PARM_DECL
19665 && uses_template_parms (TREE_TYPE (tparm
))
19666 && saw_undeduced
< 2)
19672 /* Core issue #226 (C++0x) [temp.deduct]:
19674 If a template argument has not been deduced, its
19675 default template argument, if any, is used.
19677 When we are in C++98 mode, TREE_PURPOSE will either
19678 be NULL_TREE or ERROR_MARK_NODE, so we do not need
19679 to explicitly check cxx_dialect here. */
19680 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
19681 /* OK, there is a default argument. Wait until after the
19682 conversion check to do substitution. */
19685 /* If the type parameter is a parameter pack, then it will
19686 be deduced to an empty parameter pack. */
19687 if (template_parameter_pack_p (tparm
))
19691 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
19693 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
19694 TREE_CONSTANT (arg
) = 1;
19697 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
19699 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
19701 TREE_VEC_ELT (targs
, i
) = arg
;
19705 return unify_parameter_deduction_failure (explain_p
, tparm
);
19708 /* DR 1391: All parameters have args, now check non-dependent parms for
19710 if (saw_undeduced
< 2)
19711 for (ia
= 0, parms
= xparms
, args
= xargs
, nargs
= xnargs
;
19712 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
19714 parm
= TREE_VALUE (parms
);
19716 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
19717 && (!TREE_CHAIN (parms
)
19718 || TREE_CHAIN (parms
) == void_list_node
))
19719 /* For a function parameter pack that occurs at the end of the
19720 parameter-declaration-list, the type A of each remaining
19721 argument of the call is compared with the type P of the
19722 declarator-id of the function parameter pack. */
19725 parms
= TREE_CHAIN (parms
);
19727 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
19728 /* For a function parameter pack that does not occur at the
19729 end of the parameter-declaration-list, the type of the
19730 parameter pack is a non-deduced context. */
19736 if (uses_template_parms (parm
))
19738 if (check_non_deducible_conversion (parm
, arg
, strict
, flags
,
19743 /* Now substitute into the default template arguments. */
19744 for (i
= 0; i
< ntparms
; i
++)
19746 tree targ
= TREE_VEC_ELT (targs
, i
);
19747 tree tparm
= TREE_VEC_ELT (tparms
, i
);
19749 if (targ
|| tparm
== error_mark_node
)
19751 tree parm
= TREE_VALUE (tparm
);
19753 if (TREE_CODE (parm
) == PARM_DECL
19754 && uses_template_parms (TREE_TYPE (parm
))
19755 && saw_undeduced
< 2)
19758 tree arg
= TREE_PURPOSE (tparm
);
19759 reopen_deferring_access_checks (*checks
);
19760 location_t save_loc
= input_location
;
19762 input_location
= DECL_SOURCE_LOCATION (parm
);
19763 arg
= tsubst_template_arg (arg
, full_targs
, complain
, NULL_TREE
);
19764 if (!uses_template_parms (arg
))
19765 arg
= convert_template_argument (parm
, arg
, full_targs
, complain
,
19767 else if (saw_undeduced
< 2)
19770 arg
= error_mark_node
;
19771 input_location
= save_loc
;
19772 *checks
= get_deferred_access_checks ();
19773 pop_deferring_access_checks ();
19774 if (arg
== error_mark_node
)
19778 TREE_VEC_ELT (targs
, i
) = arg
;
19779 /* The position of the first default template argument,
19780 is also the number of non-defaulted arguments in TARGS.
19782 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
19783 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
19787 if (saw_undeduced
++ == 1)
19791 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
19792 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
19794 return unify_success (explain_p
);
19797 /* Subroutine of type_unification_real. Args are like the variables
19798 at the call site. ARG is an overloaded function (or template-id);
19799 we try deducing template args from each of the overloads, and if
19800 only one succeeds, we go with that. Modifies TARGS and returns
19801 true on success. */
19804 resolve_overloaded_unification (tree tparms
,
19808 unification_kind_t strict
,
19812 tree tempargs
= copy_node (targs
);
19814 tree goodfn
= NULL_TREE
;
19817 if (TREE_CODE (arg
) == ADDR_EXPR
)
19819 arg
= TREE_OPERAND (arg
, 0);
19825 if (TREE_CODE (arg
) == COMPONENT_REF
)
19826 /* Handle `&x' where `x' is some static or non-static member
19828 arg
= TREE_OPERAND (arg
, 1);
19830 if (TREE_CODE (arg
) == OFFSET_REF
)
19831 arg
= TREE_OPERAND (arg
, 1);
19833 /* Strip baselink information. */
19834 if (BASELINK_P (arg
))
19835 arg
= BASELINK_FUNCTIONS (arg
);
19837 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
19839 /* If we got some explicit template args, we need to plug them into
19840 the affected templates before we try to unify, in case the
19841 explicit args will completely resolve the templates in question. */
19844 tree expl_subargs
= TREE_OPERAND (arg
, 1);
19845 arg
= TREE_OPERAND (arg
, 0);
19847 for (lkp_iterator
iter (arg
); iter
; ++iter
)
19850 tree subargs
, elem
;
19852 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
19855 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
19856 expl_subargs
, NULL_TREE
, tf_none
,
19857 /*require_all_args=*/true,
19858 /*use_default_args=*/true);
19859 if (subargs
!= error_mark_node
19860 && !any_dependent_template_arguments_p (subargs
))
19862 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
19863 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
19864 elem
, strict
, sub_strict
, addr_p
, explain_p
)
19865 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
19874 /* If no templates (or more than one) are fully resolved by the
19875 explicit arguments, this template-id is a non-deduced context; it
19876 could still be OK if we deduce all template arguments for the
19877 enclosing call through other arguments. */
19881 else if (TREE_CODE (arg
) != OVERLOAD
19882 && TREE_CODE (arg
) != FUNCTION_DECL
)
19883 /* If ARG is, for example, "(0, &f)" then its type will be unknown
19884 -- but the deduction does not succeed because the expression is
19885 not just the function on its own. */
19888 for (lkp_iterator
iter (arg
); iter
; ++iter
)
19891 if (try_one_overload (tparms
, targs
, tempargs
, parm
, TREE_TYPE (fn
),
19892 strict
, sub_strict
, addr_p
, explain_p
)
19893 && (!goodfn
|| !decls_match (goodfn
, fn
)))
19900 /* [temp.deduct.type] A template-argument can be deduced from a pointer
19901 to function or pointer to member function argument if the set of
19902 overloaded functions does not contain function templates and at most
19903 one of a set of overloaded functions provides a unique match.
19905 So if we found multiple possibilities, we return success but don't
19906 deduce anything. */
19910 int i
= TREE_VEC_LENGTH (targs
);
19912 if (TREE_VEC_ELT (tempargs
, i
))
19914 tree old
= TREE_VEC_ELT (targs
, i
);
19915 tree new_
= TREE_VEC_ELT (tempargs
, i
);
19916 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
19917 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
19918 /* Don't forget explicit template arguments in a pack. */
19919 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
19920 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
19921 TREE_VEC_ELT (targs
, i
) = new_
;
19930 /* Core DR 115: In contexts where deduction is done and fails, or in
19931 contexts where deduction is not done, if a template argument list is
19932 specified and it, along with any default template arguments, identifies
19933 a single function template specialization, then the template-id is an
19934 lvalue for the function template specialization. */
19937 resolve_nondeduced_context (tree orig_expr
, tsubst_flags_t complain
)
19939 tree expr
, offset
, baselink
;
19942 if (!type_unknown_p (orig_expr
))
19947 offset
= NULL_TREE
;
19948 baselink
= NULL_TREE
;
19950 if (TREE_CODE (expr
) == ADDR_EXPR
)
19952 expr
= TREE_OPERAND (expr
, 0);
19955 if (TREE_CODE (expr
) == OFFSET_REF
)
19958 expr
= TREE_OPERAND (expr
, 1);
19960 if (BASELINK_P (expr
))
19963 expr
= BASELINK_FUNCTIONS (expr
);
19966 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
19969 tree goodfn
= NULL_TREE
;
19971 /* If we got some explicit template args, we need to plug them into
19972 the affected templates before we try to unify, in case the
19973 explicit args will completely resolve the templates in question. */
19975 tree expl_subargs
= TREE_OPERAND (expr
, 1);
19976 tree arg
= TREE_OPERAND (expr
, 0);
19977 tree badfn
= NULL_TREE
;
19978 tree badargs
= NULL_TREE
;
19980 for (lkp_iterator
iter (arg
); iter
; ++iter
)
19983 tree subargs
, elem
;
19985 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
19988 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
19989 expl_subargs
, NULL_TREE
, tf_none
,
19990 /*require_all_args=*/true,
19991 /*use_default_args=*/true);
19992 if (subargs
!= error_mark_node
19993 && !any_dependent_template_arguments_p (subargs
))
19995 elem
= instantiate_template (fn
, subargs
, tf_none
);
19996 if (elem
== error_mark_node
)
20001 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
20010 mark_used (goodfn
);
20013 expr
= build_baselink (BASELINK_BINFO (baselink
),
20014 BASELINK_ACCESS_BINFO (baselink
),
20015 expr
, BASELINK_OPTYPE (baselink
));
20019 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
20020 expr
= build_offset_ref (base
, expr
, addr
, complain
);
20023 expr
= cp_build_addr_expr (expr
, complain
);
20026 else if (good
== 0 && badargs
&& (complain
& tf_error
))
20027 /* There were no good options and at least one bad one, so let the
20028 user know what the problem is. */
20029 instantiate_template (badfn
, badargs
, complain
);
20034 /* Subroutine of resolve_overloaded_unification; does deduction for a single
20035 overload. Fills TARGS with any deduced arguments, or error_mark_node if
20036 different overloads deduce different arguments for a given parm.
20037 ADDR_P is true if the expression for which deduction is being
20038 performed was of the form "& fn" rather than simply "fn".
20040 Returns 1 on success. */
20043 try_one_overload (tree tparms
,
20048 unification_kind_t strict
,
20057 if (arg
== error_mark_node
)
20060 /* [temp.deduct.type] A template-argument can be deduced from a pointer
20061 to function or pointer to member function argument if the set of
20062 overloaded functions does not contain function templates and at most
20063 one of a set of overloaded functions provides a unique match.
20065 So if this is a template, just return success. */
20067 if (uses_template_parms (arg
))
20070 if (TREE_CODE (arg
) == METHOD_TYPE
)
20071 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
20073 arg
= build_pointer_type (arg
);
20075 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
20077 /* We don't copy orig_targs for this because if we have already deduced
20078 some template args from previous args, unify would complain when we
20079 try to deduce a template parameter for the same argument, even though
20080 there isn't really a conflict. */
20081 nargs
= TREE_VEC_LENGTH (targs
);
20082 tempargs
= make_tree_vec (nargs
);
20084 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
20087 /* First make sure we didn't deduce anything that conflicts with
20088 explicitly specified args. */
20089 for (i
= nargs
; i
--; )
20091 tree elt
= TREE_VEC_ELT (tempargs
, i
);
20092 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
20096 else if (uses_template_parms (elt
))
20097 /* Since we're unifying against ourselves, we will fill in
20098 template args used in the function parm list with our own
20099 template parms. Discard them. */
20100 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
20101 else if (oldelt
&& ARGUMENT_PACK_P (oldelt
))
20103 /* Check that the argument at each index of the deduced argument pack
20104 is equivalent to the corresponding explicitly specified argument.
20105 We may have deduced more arguments than were explicitly specified,
20108 /* We used to assert ARGUMENT_PACK_INCOMPLETE_P (oldelt) here, but
20109 that's wrong if we deduce the same argument pack from multiple
20110 function arguments: it's only incomplete the first time. */
20112 tree explicit_pack
= ARGUMENT_PACK_ARGS (oldelt
);
20113 tree deduced_pack
= ARGUMENT_PACK_ARGS (elt
);
20115 if (TREE_VEC_LENGTH (deduced_pack
)
20116 < TREE_VEC_LENGTH (explicit_pack
))
20119 for (int j
= 0; j
< TREE_VEC_LENGTH (explicit_pack
); j
++)
20120 if (!template_args_equal (TREE_VEC_ELT (explicit_pack
, j
),
20121 TREE_VEC_ELT (deduced_pack
, j
)))
20124 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
20128 for (i
= nargs
; i
--; )
20130 tree elt
= TREE_VEC_ELT (tempargs
, i
);
20133 TREE_VEC_ELT (targs
, i
) = elt
;
20139 /* PARM is a template class (perhaps with unbound template
20140 parameters). ARG is a fully instantiated type. If ARG can be
20141 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
20142 TARGS are as for unify. */
20145 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
20148 tree copy_of_targs
;
20150 if (!CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
20152 else if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20153 /* Matches anything. */;
20154 else if (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
20155 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
)))
20158 /* We need to make a new template argument vector for the call to
20159 unify. If we used TARGS, we'd clutter it up with the result of
20160 the attempted unification, even if this class didn't work out.
20161 We also don't want to commit ourselves to all the unifications
20162 we've already done, since unification is supposed to be done on
20163 an argument-by-argument basis. In other words, consider the
20164 following pathological case:
20166 template <int I, int J, int K>
20169 template <int I, int J>
20170 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
20172 template <int I, int J, int K>
20173 void f(S<I, J, K>, S<I, I, I>);
20182 Now, by the time we consider the unification involving `s2', we
20183 already know that we must have `f<0, 0, 0>'. But, even though
20184 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
20185 because there are two ways to unify base classes of S<0, 1, 2>
20186 with S<I, I, I>. If we kept the already deduced knowledge, we
20187 would reject the possibility I=1. */
20188 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
20190 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20192 if (unify_bound_ttp_args (tparms
, copy_of_targs
, parm
, arg
, explain_p
))
20197 /* If unification failed, we're done. */
20198 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
20199 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
20205 /* Given a template type PARM and a class type ARG, find the unique
20206 base type in ARG that is an instance of PARM. We do not examine
20207 ARG itself; only its base-classes. If there is not exactly one
20208 appropriate base class, return NULL_TREE. PARM may be the type of
20209 a partial specialization, as well as a plain template type. Used
20212 static enum template_base_result
20213 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
20214 bool explain_p
, tree
*result
)
20216 tree rval
= NULL_TREE
;
20219 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
20221 binfo
= TYPE_BINFO (complete_type (arg
));
20224 /* The type could not be completed. */
20225 *result
= NULL_TREE
;
20226 return tbr_incomplete_type
;
20229 /* Walk in inheritance graph order. The search order is not
20230 important, and this avoids multiple walks of virtual bases. */
20231 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
20233 tree r
= try_class_unification (tparms
, targs
, parm
,
20234 BINFO_TYPE (binfo
), explain_p
);
20238 /* If there is more than one satisfactory baseclass, then:
20242 If they yield more than one possible deduced A, the type
20246 if (rval
&& !same_type_p (r
, rval
))
20248 *result
= NULL_TREE
;
20249 return tbr_ambiguous_baseclass
;
20257 return tbr_success
;
20260 /* Returns the level of DECL, which declares a template parameter. */
20263 template_decl_level (tree decl
)
20265 switch (TREE_CODE (decl
))
20268 case TEMPLATE_DECL
:
20269 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
20272 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
20275 gcc_unreachable ();
20280 /* Decide whether ARG can be unified with PARM, considering only the
20281 cv-qualifiers of each type, given STRICT as documented for unify.
20282 Returns nonzero iff the unification is OK on that basis. */
20285 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
20287 int arg_quals
= cp_type_quals (arg
);
20288 int parm_quals
= cp_type_quals (parm
);
20290 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
20291 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
20293 /* Although a CVR qualifier is ignored when being applied to a
20294 substituted template parameter ([8.3.2]/1 for example), that
20295 does not allow us to unify "const T" with "int&" because both
20296 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
20297 It is ok when we're allowing additional CV qualifiers
20298 at the outer level [14.8.2.1]/3,1st bullet. */
20299 if ((TREE_CODE (arg
) == REFERENCE_TYPE
20300 || TREE_CODE (arg
) == FUNCTION_TYPE
20301 || TREE_CODE (arg
) == METHOD_TYPE
)
20302 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
20305 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
20306 && (parm_quals
& TYPE_QUAL_RESTRICT
))
20310 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
20311 && (arg_quals
& parm_quals
) != parm_quals
)
20314 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
20315 && (parm_quals
& arg_quals
) != arg_quals
)
20321 /* Determines the LEVEL and INDEX for the template parameter PARM. */
20323 template_parm_level_and_index (tree parm
, int* level
, int* index
)
20325 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
20326 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
20327 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20329 *index
= TEMPLATE_TYPE_IDX (parm
);
20330 *level
= TEMPLATE_TYPE_LEVEL (parm
);
20334 *index
= TEMPLATE_PARM_IDX (parm
);
20335 *level
= TEMPLATE_PARM_LEVEL (parm
);
20339 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
20341 if (unify (TP, TA, P, A, S, EP)) \
20345 /* Unifies the remaining arguments in PACKED_ARGS with the pack
20346 expansion at the end of PACKED_PARMS. Returns 0 if the type
20347 deduction succeeds, 1 otherwise. STRICT is the same as in
20348 fn_type_unification. CALL_ARGS_P is true iff PACKED_ARGS is actually a
20349 function call argument list. We'll need to adjust the arguments to make them
20350 types. SUBR tells us if this is from a recursive call to
20351 type_unification_real, or for comparing two template argument
20355 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
20356 tree packed_args
, unification_kind_t strict
,
20357 bool subr
, bool explain_p
)
20360 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
20361 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
20362 tree pack
, packs
= NULL_TREE
;
20363 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
20365 /* Add in any args remembered from an earlier partial instantiation. */
20366 targs
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (parm
), targs
);
20368 packed_args
= expand_template_argument_pack (packed_args
);
20370 int len
= TREE_VEC_LENGTH (packed_args
);
20372 /* Determine the parameter packs we will be deducing from the
20373 pattern, and record their current deductions. */
20374 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
20375 pack
; pack
= TREE_CHAIN (pack
))
20377 tree parm_pack
= TREE_VALUE (pack
);
20380 /* Determine the index and level of this parameter pack. */
20381 template_parm_level_and_index (parm_pack
, &level
, &idx
);
20383 /* Keep track of the parameter packs and their corresponding
20385 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
20386 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
20389 /* Loop through all of the arguments that have not yet been
20390 unified and unify each with the pattern. */
20391 for (i
= start
; i
< len
; i
++)
20394 bool any_explicit
= false;
20395 tree arg
= TREE_VEC_ELT (packed_args
, i
);
20397 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
20398 or the element of its argument pack at the current index if
20399 this argument was explicitly specified. */
20400 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
20404 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
20407 if (TREE_VALUE (pack
)
20408 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
20409 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
20411 any_explicit
= true;
20412 arg
= TREE_VEC_ELT (pargs
, i
- start
);
20414 TMPL_ARG (targs
, level
, idx
) = arg
;
20417 /* If we had explicit template arguments, substitute them into the
20418 pattern before deduction. */
20421 /* Some arguments might still be unspecified or dependent. */
20423 ++processing_template_decl
;
20424 dependent
= any_dependent_template_arguments_p (targs
);
20426 --processing_template_decl
;
20427 parm
= tsubst (pattern
, targs
,
20428 explain_p
? tf_warning_or_error
: tf_none
,
20431 --processing_template_decl
;
20432 if (parm
== error_mark_node
)
20438 /* Unify the pattern with the current argument. */
20439 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
20443 /* For each parameter pack, collect the deduced value. */
20444 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
20447 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
20449 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
20450 TMPL_ARG (targs
, level
, idx
);
20454 /* Verify that the results of unification with the parameter packs
20455 produce results consistent with what we've seen before, and make
20456 the deduced argument packs available. */
20457 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
20459 tree old_pack
= TREE_VALUE (pack
);
20460 tree new_args
= TREE_TYPE (pack
);
20461 int i
, len
= TREE_VEC_LENGTH (new_args
);
20463 bool nondeduced_p
= false;
20465 /* By default keep the original deduced argument pack.
20466 If necessary, more specific code is going to update the
20467 resulting deduced argument later down in this function. */
20468 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
20469 TMPL_ARG (targs
, level
, idx
) = old_pack
;
20471 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
20472 actually deduce anything. */
20473 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
20474 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
20475 nondeduced_p
= true;
20479 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
20481 /* If we had fewer function args than explicit template args,
20482 just use the explicits. */
20483 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
20484 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
20485 if (len
< explicit_len
)
20486 new_args
= explicit_args
;
20492 /* Build the deduced *_ARGUMENT_PACK. */
20493 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
20495 result
= make_node (NONTYPE_ARGUMENT_PACK
);
20496 TREE_CONSTANT (result
) = 1;
20499 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
20501 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
20503 /* Note the deduced argument packs for this parameter
20505 TMPL_ARG (targs
, level
, idx
) = result
;
20507 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
20508 && (ARGUMENT_PACK_ARGS (old_pack
)
20509 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
20511 /* We only had the explicitly-provided arguments before, but
20512 now we have a complete set of arguments. */
20513 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
20515 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
20516 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
20517 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
20521 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
20522 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
20524 if (!comp_template_args (old_args
, new_args
,
20525 &bad_old_arg
, &bad_new_arg
))
20526 /* Inconsistent unification of this parameter pack. */
20527 return unify_parameter_pack_inconsistent (explain_p
,
20533 return unify_success (explain_p
);
20536 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
20537 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
20538 parameters and return value are as for unify. */
20541 unify_array_domain (tree tparms
, tree targs
,
20542 tree parm_dom
, tree arg_dom
,
20550 /* Our representation of array types uses "N - 1" as the
20551 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
20552 not an integer constant. We cannot unify arbitrarily
20553 complex expressions, so we eliminate the MINUS_EXPRs
20555 parm_max
= TYPE_MAX_VALUE (parm_dom
);
20556 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
20559 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
20560 parm_max
= TREE_OPERAND (parm_max
, 0);
20562 arg_max
= TYPE_MAX_VALUE (arg_dom
);
20563 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
20566 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
20567 trying to unify the type of a variable with the type
20568 of a template parameter. For example:
20570 template <unsigned int N>
20571 void f (char (&) [N]);
20578 Here, the type of the ARG will be "int [g(i)]", and
20579 may be a SAVE_EXPR, etc. */
20580 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
20581 return unify_vla_arg (explain_p
, arg_dom
);
20582 arg_max
= TREE_OPERAND (arg_max
, 0);
20585 /* If only one of the bounds used a MINUS_EXPR, compensate
20586 by adding one to the other bound. */
20587 if (parm_cst
&& !arg_cst
)
20588 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
20592 else if (arg_cst
&& !parm_cst
)
20593 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
20598 return unify (tparms
, targs
, parm_max
, arg_max
,
20599 UNIFY_ALLOW_INTEGER
, explain_p
);
20602 /* Returns whether T, a P or A in unify, is a type, template or expression. */
20604 enum pa_kind_t
{ pa_type
, pa_tmpl
, pa_expr
};
20609 if (PACK_EXPANSION_P (t
))
20610 t
= PACK_EXPANSION_PATTERN (t
);
20611 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
20612 || TREE_CODE (t
) == UNBOUND_CLASS_TEMPLATE
20613 || DECL_TYPE_TEMPLATE_P (t
))
20615 else if (TYPE_P (t
))
20621 /* Deduce the value of template parameters. TPARMS is the (innermost)
20622 set of template parameters to a template. TARGS is the bindings
20623 for those template parameters, as determined thus far; TARGS may
20624 include template arguments for outer levels of template parameters
20625 as well. PARM is a parameter to a template function, or a
20626 subcomponent of that parameter; ARG is the corresponding argument.
20627 This function attempts to match PARM with ARG in a manner
20628 consistent with the existing assignments in TARGS. If more values
20629 are deduced, then TARGS is updated.
20631 Returns 0 if the type deduction succeeds, 1 otherwise. The
20632 parameter STRICT is a bitwise or of the following flags:
20635 Require an exact match between PARM and ARG.
20636 UNIFY_ALLOW_MORE_CV_QUAL:
20637 Allow the deduced ARG to be more cv-qualified (by qualification
20638 conversion) than ARG.
20639 UNIFY_ALLOW_LESS_CV_QUAL:
20640 Allow the deduced ARG to be less cv-qualified than ARG.
20641 UNIFY_ALLOW_DERIVED:
20642 Allow the deduced ARG to be a template base class of ARG,
20643 or a pointer to a template base class of the type pointed to by
20645 UNIFY_ALLOW_INTEGER:
20646 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
20647 case for more information.
20648 UNIFY_ALLOW_OUTER_LEVEL:
20649 This is the outermost level of a deduction. Used to determine validity
20650 of qualification conversions. A valid qualification conversion must
20651 have const qualified pointers leading up to the inner type which
20652 requires additional CV quals, except at the outer level, where const
20653 is not required [conv.qual]. It would be normal to set this flag in
20654 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
20655 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
20656 This is the outermost level of a deduction, and PARM can be more CV
20657 qualified at this point.
20658 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
20659 This is the outermost level of a deduction, and PARM can be less CV
20660 qualified at this point. */
20663 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
20669 int strict_in
= strict
;
20670 tsubst_flags_t complain
= (explain_p
20671 ? tf_warning_or_error
20674 /* I don't think this will do the right thing with respect to types.
20675 But the only case I've seen it in so far has been array bounds, where
20676 signedness is the only information lost, and I think that will be
20678 while (CONVERT_EXPR_P (parm
))
20679 parm
= TREE_OPERAND (parm
, 0);
20681 if (arg
== error_mark_node
)
20682 return unify_invalid (explain_p
);
20683 if (arg
== unknown_type_node
20684 || arg
== init_list_type_node
)
20685 /* We can't deduce anything from this, but we might get all the
20686 template args from other function args. */
20687 return unify_success (explain_p
);
20689 if (parm
== any_targ_node
|| arg
== any_targ_node
)
20690 return unify_success (explain_p
);
20692 /* If PARM uses template parameters, then we can't bail out here,
20693 even if ARG == PARM, since we won't record unifications for the
20694 template parameters. We might need them if we're trying to
20695 figure out which of two things is more specialized. */
20696 if (arg
== parm
&& !uses_template_parms (parm
))
20697 return unify_success (explain_p
);
20699 /* Handle init lists early, so the rest of the function can assume
20700 we're dealing with a type. */
20701 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
20705 tree orig_parm
= parm
;
20707 /* Replace T with std::initializer_list<T> for deduction. */
20708 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
20709 && flag_deduce_init_list
)
20710 parm
= listify (parm
);
20712 if (!is_std_init_list (parm
)
20713 && TREE_CODE (parm
) != ARRAY_TYPE
)
20714 /* We can only deduce from an initializer list argument if the
20715 parameter is std::initializer_list or an array; otherwise this
20716 is a non-deduced context. */
20717 return unify_success (explain_p
);
20719 if (TREE_CODE (parm
) == ARRAY_TYPE
)
20720 elttype
= TREE_TYPE (parm
);
20723 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
20724 /* Deduction is defined in terms of a single type, so just punt
20725 on the (bizarre) std::initializer_list<T...>. */
20726 if (PACK_EXPANSION_P (elttype
))
20727 return unify_success (explain_p
);
20730 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
20732 int elt_strict
= strict
;
20734 if (elt
== error_mark_node
)
20735 return unify_invalid (explain_p
);
20737 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
20739 tree type
= TREE_TYPE (elt
);
20740 if (type
== error_mark_node
)
20741 return unify_invalid (explain_p
);
20742 /* It should only be possible to get here for a call. */
20743 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
20744 elt_strict
|= maybe_adjust_types_for_deduction
20745 (DEDUCE_CALL
, &elttype
, &type
, elt
);
20749 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
20753 if (TREE_CODE (parm
) == ARRAY_TYPE
20754 && deducible_array_bound (TYPE_DOMAIN (parm
)))
20756 /* Also deduce from the length of the initializer list. */
20757 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
20758 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
20759 if (idx
== error_mark_node
)
20760 return unify_invalid (explain_p
);
20761 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
20765 /* If the std::initializer_list<T> deduction worked, replace the
20766 deduced A with std::initializer_list<A>. */
20767 if (orig_parm
!= parm
)
20769 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
20770 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
20771 targ
= listify (targ
);
20772 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
20774 return unify_success (explain_p
);
20777 /* If parm and arg aren't the same kind of thing (template, type, or
20778 expression), fail early. */
20779 if (pa_kind (parm
) != pa_kind (arg
))
20780 return unify_invalid (explain_p
);
20782 /* Immediately reject some pairs that won't unify because of
20783 cv-qualification mismatches. */
20784 if (TREE_CODE (arg
) == TREE_CODE (parm
)
20786 /* It is the elements of the array which hold the cv quals of an array
20787 type, and the elements might be template type parms. We'll check
20788 when we recurse. */
20789 && TREE_CODE (arg
) != ARRAY_TYPE
20790 /* We check the cv-qualifiers when unifying with template type
20791 parameters below. We want to allow ARG `const T' to unify with
20792 PARM `T' for example, when computing which of two templates
20793 is more specialized, for example. */
20794 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
20795 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
20796 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
20798 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
20799 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
20800 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
20801 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
20802 strict
&= ~UNIFY_ALLOW_DERIVED
;
20803 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
20804 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
20806 switch (TREE_CODE (parm
))
20808 case TYPENAME_TYPE
:
20810 case UNBOUND_CLASS_TEMPLATE
:
20811 /* In a type which contains a nested-name-specifier, template
20812 argument values cannot be deduced for template parameters used
20813 within the nested-name-specifier. */
20814 return unify_success (explain_p
);
20816 case TEMPLATE_TYPE_PARM
:
20817 case TEMPLATE_TEMPLATE_PARM
:
20818 case BOUND_TEMPLATE_TEMPLATE_PARM
:
20819 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
20820 if (error_operand_p (tparm
))
20821 return unify_invalid (explain_p
);
20823 if (TEMPLATE_TYPE_LEVEL (parm
)
20824 != template_decl_level (tparm
))
20825 /* The PARM is not one we're trying to unify. Just check
20826 to see if it matches ARG. */
20828 if (TREE_CODE (arg
) == TREE_CODE (parm
)
20829 && (is_auto (parm
) ? is_auto (arg
)
20830 : same_type_p (parm
, arg
)))
20831 return unify_success (explain_p
);
20833 return unify_type_mismatch (explain_p
, parm
, arg
);
20835 idx
= TEMPLATE_TYPE_IDX (parm
);
20836 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
20837 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
20838 if (error_operand_p (tparm
))
20839 return unify_invalid (explain_p
);
20841 /* Check for mixed types and values. */
20842 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
20843 && TREE_CODE (tparm
) != TYPE_DECL
)
20844 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
20845 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
20846 gcc_unreachable ();
20848 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20850 if ((strict_in
& UNIFY_ALLOW_DERIVED
)
20851 && CLASS_TYPE_P (arg
))
20853 /* First try to match ARG directly. */
20854 tree t
= try_class_unification (tparms
, targs
, parm
, arg
,
20858 /* Otherwise, look for a suitable base of ARG, as below. */
20859 enum template_base_result r
;
20860 r
= get_template_base (tparms
, targs
, parm
, arg
,
20863 return unify_no_common_base (explain_p
, r
, parm
, arg
);
20867 /* ARG must be constructed from a template class or a template
20868 template parameter. */
20869 else if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
20870 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
20871 return unify_template_deduction_failure (explain_p
, parm
, arg
);
20873 /* Deduce arguments T, i from TT<T> or TT<i>. */
20874 if (unify_bound_ttp_args (tparms
, targs
, parm
, arg
, explain_p
))
20877 arg
= TYPE_TI_TEMPLATE (arg
);
20879 /* Fall through to deduce template name. */
20882 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
20883 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20885 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
20887 /* Simple cases: Value already set, does match or doesn't. */
20888 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
20889 return unify_success (explain_p
);
20891 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
20895 /* If PARM is `const T' and ARG is only `int', we don't have
20896 a match unless we are allowing additional qualification.
20897 If ARG is `const int' and PARM is just `T' that's OK;
20898 that binds `const int' to `T'. */
20899 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
20901 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
20903 /* Consider the case where ARG is `const volatile int' and
20904 PARM is `const T'. Then, T should be `volatile int'. */
20905 arg
= cp_build_qualified_type_real
20906 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
20907 if (arg
== error_mark_node
)
20908 return unify_invalid (explain_p
);
20910 /* Simple cases: Value already set, does match or doesn't. */
20911 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
20912 return unify_success (explain_p
);
20914 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
20916 /* Make sure that ARG is not a variable-sized array. (Note
20917 that were talking about variable-sized arrays (like
20918 `int[n]'), rather than arrays of unknown size (like
20919 `int[]').) We'll get very confused by such a type since
20920 the bound of the array is not constant, and therefore
20921 not mangleable. Besides, such types are not allowed in
20922 ISO C++, so we can do as we please here. We do allow
20923 them for 'auto' deduction, since that isn't ABI-exposed. */
20924 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
20925 return unify_vla_arg (explain_p
, arg
);
20927 /* Strip typedefs as in convert_template_argument. */
20928 arg
= canonicalize_type_argument (arg
, tf_none
);
20931 /* If ARG is a parameter pack or an expansion, we cannot unify
20932 against it unless PARM is also a parameter pack. */
20933 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
20934 && !template_parameter_pack_p (parm
))
20935 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
20937 /* If the argument deduction results is a METHOD_TYPE,
20938 then there is a problem.
20939 METHOD_TYPE doesn't map to any real C++ type the result of
20940 the deduction can not be of that type. */
20941 if (TREE_CODE (arg
) == METHOD_TYPE
)
20942 return unify_method_type_error (explain_p
, arg
);
20944 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
20945 return unify_success (explain_p
);
20947 case TEMPLATE_PARM_INDEX
:
20948 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
20949 if (error_operand_p (tparm
))
20950 return unify_invalid (explain_p
);
20952 if (TEMPLATE_PARM_LEVEL (parm
)
20953 != template_decl_level (tparm
))
20955 /* The PARM is not one we're trying to unify. Just check
20956 to see if it matches ARG. */
20957 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
20958 && cp_tree_equal (parm
, arg
));
20960 unify_expression_unequal (explain_p
, parm
, arg
);
20964 idx
= TEMPLATE_PARM_IDX (parm
);
20965 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
20969 if ((strict
& UNIFY_ALLOW_INTEGER
)
20970 && TREE_TYPE (targ
) && TREE_TYPE (arg
)
20971 && CP_INTEGRAL_TYPE_P (TREE_TYPE (targ
)))
20972 /* We're deducing from an array bound, the type doesn't matter. */
20973 arg
= fold_convert (TREE_TYPE (targ
), arg
);
20974 int x
= !cp_tree_equal (targ
, arg
);
20976 unify_inconsistency (explain_p
, parm
, targ
, arg
);
20980 /* [temp.deduct.type] If, in the declaration of a function template
20981 with a non-type template-parameter, the non-type
20982 template-parameter is used in an expression in the function
20983 parameter-list and, if the corresponding template-argument is
20984 deduced, the template-argument type shall match the type of the
20985 template-parameter exactly, except that a template-argument
20986 deduced from an array bound may be of any integral type.
20987 The non-type parameter might use already deduced type parameters. */
20988 ++processing_template_decl
;
20989 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
20990 --processing_template_decl
;
20991 if (tree a
= type_uses_auto (tparm
))
20993 tparm
= do_auto_deduction (tparm
, arg
, a
, complain
, adc_unify
);
20994 if (tparm
== error_mark_node
)
20998 if (!TREE_TYPE (arg
))
20999 /* Template-parameter dependent expression. Just accept it for now.
21000 It will later be processed in convert_template_argument. */
21002 else if (same_type_p (non_reference (TREE_TYPE (arg
)),
21003 non_reference (tparm
)))
21005 else if ((strict
& UNIFY_ALLOW_INTEGER
)
21006 && CP_INTEGRAL_TYPE_P (tparm
))
21007 /* Convert the ARG to the type of PARM; the deduced non-type
21008 template argument must exactly match the types of the
21009 corresponding parameter. */
21010 arg
= fold (build_nop (tparm
, arg
));
21011 else if (uses_template_parms (tparm
))
21013 /* We haven't deduced the type of this parameter yet. */
21014 if (cxx_dialect
>= cxx17
21015 /* We deduce from array bounds in try_array_deduction. */
21016 && !(strict
& UNIFY_ALLOW_INTEGER
))
21018 /* Deduce it from the non-type argument. */
21019 tree atype
= TREE_TYPE (arg
);
21020 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
21022 UNIFY_ALLOW_NONE
, explain_p
);
21025 /* Try again later. */
21026 return unify_success (explain_p
);
21029 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
21031 /* If ARG is a parameter pack or an expansion, we cannot unify
21032 against it unless PARM is also a parameter pack. */
21033 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
21034 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
21035 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
21038 bool removed_attr
= false;
21039 arg
= strip_typedefs_expr (arg
, &removed_attr
);
21041 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
21042 return unify_success (explain_p
);
21046 /* A pointer-to-member constant can be unified only with
21047 another constant. */
21048 if (TREE_CODE (arg
) != PTRMEM_CST
)
21049 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
21051 /* Just unify the class member. It would be useless (and possibly
21052 wrong, depending on the strict flags) to unify also
21053 PTRMEM_CST_CLASS, because we want to be sure that both parm and
21054 arg refer to the same variable, even if through different
21055 classes. For instance:
21057 struct A { int x; };
21060 Unification of &A::x and &B::x must succeed. */
21061 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
21062 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
21067 if (!TYPE_PTR_P (arg
))
21068 return unify_type_mismatch (explain_p
, parm
, arg
);
21070 /* [temp.deduct.call]
21072 A can be another pointer or pointer to member type that can
21073 be converted to the deduced A via a qualification
21074 conversion (_conv.qual_).
21076 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
21077 This will allow for additional cv-qualification of the
21078 pointed-to types if appropriate. */
21080 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
21081 /* The derived-to-base conversion only persists through one
21082 level of pointers. */
21083 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
21085 return unify (tparms
, targs
, TREE_TYPE (parm
),
21086 TREE_TYPE (arg
), strict
, explain_p
);
21089 case REFERENCE_TYPE
:
21090 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
21091 return unify_type_mismatch (explain_p
, parm
, arg
);
21092 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
21093 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
21096 if (TREE_CODE (arg
) != ARRAY_TYPE
)
21097 return unify_type_mismatch (explain_p
, parm
, arg
);
21098 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
21099 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
21100 return unify_type_mismatch (explain_p
, parm
, arg
);
21101 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
21102 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
21103 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
21104 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
21105 TYPE_DOMAIN (arg
), explain_p
);
21106 return unify_success (explain_p
);
21113 case ENUMERAL_TYPE
:
21116 if (TREE_CODE (arg
) != TREE_CODE (parm
))
21117 return unify_type_mismatch (explain_p
, parm
, arg
);
21119 /* We have already checked cv-qualification at the top of the
21121 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
21122 return unify_type_mismatch (explain_p
, parm
, arg
);
21124 /* As far as unification is concerned, this wins. Later checks
21125 will invalidate it if necessary. */
21126 return unify_success (explain_p
);
21128 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
21129 /* Type INTEGER_CST can come from ordinary constant template args. */
21131 while (CONVERT_EXPR_P (arg
))
21132 arg
= TREE_OPERAND (arg
, 0);
21134 if (TREE_CODE (arg
) != INTEGER_CST
)
21135 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
21136 return (tree_int_cst_equal (parm
, arg
)
21137 ? unify_success (explain_p
)
21138 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
21142 int i
, len
, argslen
;
21143 int parm_variadic_p
= 0;
21145 if (TREE_CODE (arg
) != TREE_VEC
)
21146 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
21148 len
= TREE_VEC_LENGTH (parm
);
21149 argslen
= TREE_VEC_LENGTH (arg
);
21151 /* Check for pack expansions in the parameters. */
21152 for (i
= 0; i
< len
; ++i
)
21154 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
21157 /* We can unify against something with a trailing
21159 parm_variadic_p
= 1;
21161 /* [temp.deduct.type]/9: If the template argument list of
21162 P contains a pack expansion that is not the last
21163 template argument, the entire template argument list
21164 is a non-deduced context. */
21165 return unify_success (explain_p
);
21169 /* If we don't have enough arguments to satisfy the parameters
21170 (not counting the pack expression at the end), or we have
21171 too many arguments for a parameter list that doesn't end in
21172 a pack expression, we can't unify. */
21173 if (parm_variadic_p
21174 ? argslen
< len
- parm_variadic_p
21176 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
21178 /* Unify all of the parameters that precede the (optional)
21179 pack expression. */
21180 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
21182 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
21183 TREE_VEC_ELT (parm
, i
),
21184 TREE_VEC_ELT (arg
, i
),
21185 UNIFY_ALLOW_NONE
, explain_p
);
21187 if (parm_variadic_p
)
21188 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
21190 /*subr=*/true, explain_p
);
21191 return unify_success (explain_p
);
21196 if (TREE_CODE (arg
) != TREE_CODE (parm
))
21197 return unify_type_mismatch (explain_p
, parm
, arg
);
21199 if (TYPE_PTRMEMFUNC_P (parm
))
21201 if (!TYPE_PTRMEMFUNC_P (arg
))
21202 return unify_type_mismatch (explain_p
, parm
, arg
);
21204 return unify (tparms
, targs
,
21205 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
21206 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
21207 strict
, explain_p
);
21209 else if (TYPE_PTRMEMFUNC_P (arg
))
21210 return unify_type_mismatch (explain_p
, parm
, arg
);
21212 if (CLASSTYPE_TEMPLATE_INFO (parm
))
21214 tree t
= NULL_TREE
;
21216 if (strict_in
& UNIFY_ALLOW_DERIVED
)
21218 /* First, we try to unify the PARM and ARG directly. */
21219 t
= try_class_unification (tparms
, targs
,
21220 parm
, arg
, explain_p
);
21224 /* Fallback to the special case allowed in
21225 [temp.deduct.call]:
21227 If P is a class, and P has the form
21228 template-id, then A can be a derived class of
21229 the deduced A. Likewise, if P is a pointer to
21230 a class of the form template-id, A can be a
21231 pointer to a derived class pointed to by the
21233 enum template_base_result r
;
21234 r
= get_template_base (tparms
, targs
, parm
, arg
,
21239 /* Don't give the derived diagnostic if we're
21240 already dealing with the same template. */
21242 = (CLASSTYPE_TEMPLATE_INFO (arg
)
21243 && (CLASSTYPE_TI_TEMPLATE (parm
)
21244 == CLASSTYPE_TI_TEMPLATE (arg
)));
21245 return unify_no_common_base (explain_p
&& !same_template
,
21250 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
21251 && (CLASSTYPE_TI_TEMPLATE (parm
)
21252 == CLASSTYPE_TI_TEMPLATE (arg
)))
21253 /* Perhaps PARM is something like S<U> and ARG is S<int>.
21254 Then, we should unify `int' and `U'. */
21257 /* There's no chance of unification succeeding. */
21258 return unify_type_mismatch (explain_p
, parm
, arg
);
21260 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
21261 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
21263 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
21264 return unify_type_mismatch (explain_p
, parm
, arg
);
21265 return unify_success (explain_p
);
21268 case FUNCTION_TYPE
:
21270 unsigned int nargs
;
21275 if (TREE_CODE (arg
) != TREE_CODE (parm
))
21276 return unify_type_mismatch (explain_p
, parm
, arg
);
21278 /* CV qualifications for methods can never be deduced, they must
21279 match exactly. We need to check them explicitly here,
21280 because type_unification_real treats them as any other
21281 cv-qualified parameter. */
21282 if (TREE_CODE (parm
) == METHOD_TYPE
21283 && (!check_cv_quals_for_unify
21285 class_of_this_parm (arg
),
21286 class_of_this_parm (parm
))))
21287 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
21288 if (TREE_CODE (arg
) == FUNCTION_TYPE
21289 && type_memfn_quals (parm
) != type_memfn_quals (arg
))
21290 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
21291 if (type_memfn_rqual (parm
) != type_memfn_rqual (arg
))
21292 return unify_type_mismatch (explain_p
, parm
, arg
);
21294 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
21295 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
21297 nargs
= list_length (TYPE_ARG_TYPES (arg
));
21298 args
= XALLOCAVEC (tree
, nargs
);
21299 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
21300 a
!= NULL_TREE
&& a
!= void_list_node
;
21301 a
= TREE_CHAIN (a
), ++i
)
21302 args
[i
] = TREE_VALUE (a
);
21305 if (type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
21306 args
, nargs
, 1, DEDUCE_EXACT
,
21307 LOOKUP_NORMAL
, NULL
, explain_p
))
21310 if (flag_noexcept_type
)
21312 tree pspec
= TYPE_RAISES_EXCEPTIONS (parm
);
21313 tree aspec
= canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (arg
));
21314 if (pspec
== NULL_TREE
) pspec
= noexcept_false_spec
;
21315 if (aspec
== NULL_TREE
) aspec
= noexcept_false_spec
;
21316 if (TREE_PURPOSE (pspec
) && TREE_PURPOSE (aspec
)
21317 && uses_template_parms (TREE_PURPOSE (pspec
)))
21318 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_PURPOSE (pspec
),
21319 TREE_PURPOSE (aspec
),
21320 UNIFY_ALLOW_NONE
, explain_p
);
21321 else if (nothrow_spec_p (pspec
) && !nothrow_spec_p (aspec
))
21322 return unify_type_mismatch (explain_p
, parm
, arg
);
21329 /* Unify a pointer to member with a pointer to member function, which
21330 deduces the type of the member as a function type. */
21331 if (TYPE_PTRMEMFUNC_P (arg
))
21333 /* Check top-level cv qualifiers */
21334 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
21335 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
21337 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
21338 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
21339 UNIFY_ALLOW_NONE
, explain_p
);
21341 /* Determine the type of the function we are unifying against. */
21342 tree fntype
= static_fn_type (arg
);
21344 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
21347 if (TREE_CODE (arg
) != OFFSET_TYPE
)
21348 return unify_type_mismatch (explain_p
, parm
, arg
);
21349 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
21350 TYPE_OFFSET_BASETYPE (arg
),
21351 UNIFY_ALLOW_NONE
, explain_p
);
21352 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
21353 strict
, explain_p
);
21356 if (DECL_TEMPLATE_PARM_P (parm
))
21357 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
21358 if (arg
!= scalar_constant_value (parm
))
21359 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
21360 return unify_success (explain_p
);
21363 case TEMPLATE_DECL
:
21364 /* Matched cases are handled by the ARG == PARM test above. */
21365 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
21368 /* We might get a variable as a non-type template argument in parm if the
21369 corresponding parameter is type-dependent. Make any necessary
21370 adjustments based on whether arg is a reference. */
21371 if (CONSTANT_CLASS_P (arg
))
21372 parm
= fold_non_dependent_expr (parm
);
21373 else if (REFERENCE_REF_P (arg
))
21375 tree sub
= TREE_OPERAND (arg
, 0);
21377 if (TREE_CODE (sub
) == ADDR_EXPR
)
21378 arg
= TREE_OPERAND (sub
, 0);
21380 /* Now use the normal expression code to check whether they match. */
21383 case TYPE_ARGUMENT_PACK
:
21384 case NONTYPE_ARGUMENT_PACK
:
21385 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
21386 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
21389 case DECLTYPE_TYPE
:
21390 case UNDERLYING_TYPE
:
21391 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
21392 or UNDERLYING_TYPE nodes. */
21393 return unify_success (explain_p
);
21396 /* Unification fails if we hit an error node. */
21397 return unify_invalid (explain_p
);
21400 if (REFERENCE_REF_P (parm
))
21402 bool pexp
= PACK_EXPANSION_P (arg
);
21404 arg
= PACK_EXPANSION_PATTERN (arg
);
21405 if (REFERENCE_REF_P (arg
))
21406 arg
= TREE_OPERAND (arg
, 0);
21408 arg
= make_pack_expansion (arg
, complain
);
21409 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
21410 strict
, explain_p
);
21415 /* An unresolved overload is a nondeduced context. */
21416 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
21417 return unify_success (explain_p
);
21418 gcc_assert (EXPR_P (parm
) || TREE_CODE (parm
) == TRAIT_EXPR
);
21420 /* We must be looking at an expression. This can happen with
21424 void foo(S<I>, S<I + 2>);
21426 This is a "nondeduced context":
21430 The nondeduced contexts are:
21432 --A type that is a template-id in which one or more of
21433 the template-arguments is an expression that references
21434 a template-parameter.
21436 In these cases, we assume deduction succeeded, but don't
21437 actually infer any unifications. */
21439 if (!uses_template_parms (parm
)
21440 && !template_args_equal (parm
, arg
))
21441 return unify_expression_unequal (explain_p
, parm
, arg
);
21443 return unify_success (explain_p
);
21446 #undef RECUR_AND_CHECK_FAILURE
21448 /* Note that DECL can be defined in this translation unit, if
21452 mark_definable (tree decl
)
21455 DECL_NOT_REALLY_EXTERN (decl
) = 1;
21456 FOR_EACH_CLONE (clone
, decl
)
21457 DECL_NOT_REALLY_EXTERN (clone
) = 1;
21460 /* Called if RESULT is explicitly instantiated, or is a member of an
21461 explicitly instantiated class. */
21464 mark_decl_instantiated (tree result
, int extern_p
)
21466 SET_DECL_EXPLICIT_INSTANTIATION (result
);
21468 /* If this entity has already been written out, it's too late to
21469 make any modifications. */
21470 if (TREE_ASM_WRITTEN (result
))
21473 /* For anonymous namespace we don't need to do anything. */
21474 if (decl_anon_ns_mem_p (result
))
21476 gcc_assert (!TREE_PUBLIC (result
));
21480 if (TREE_CODE (result
) != FUNCTION_DECL
)
21481 /* The TREE_PUBLIC flag for function declarations will have been
21482 set correctly by tsubst. */
21483 TREE_PUBLIC (result
) = 1;
21485 /* This might have been set by an earlier implicit instantiation. */
21486 DECL_COMDAT (result
) = 0;
21489 DECL_NOT_REALLY_EXTERN (result
) = 0;
21492 mark_definable (result
);
21493 mark_needed (result
);
21494 /* Always make artificials weak. */
21495 if (DECL_ARTIFICIAL (result
) && flag_weak
)
21496 comdat_linkage (result
);
21497 /* For WIN32 we also want to put explicit instantiations in
21498 linkonce sections. */
21499 else if (TREE_PUBLIC (result
))
21500 maybe_make_one_only (result
);
21503 /* If EXTERN_P, then this function will not be emitted -- unless
21504 followed by an explicit instantiation, at which point its linkage
21505 will be adjusted. If !EXTERN_P, then this function will be
21506 emitted here. In neither circumstance do we want
21507 import_export_decl to adjust the linkage. */
21508 DECL_INTERFACE_KNOWN (result
) = 1;
21511 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
21512 important template arguments. If any are missing, we check whether
21513 they're important by using error_mark_node for substituting into any
21514 args that were used for partial ordering (the ones between ARGS and END)
21515 and seeing if it bubbles up. */
21518 check_undeduced_parms (tree targs
, tree args
, tree end
)
21520 bool found
= false;
21522 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
21523 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
21526 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
21530 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
21531 if (substed
== error_mark_node
)
21537 /* Given two function templates PAT1 and PAT2, return:
21539 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
21540 -1 if PAT2 is more specialized than PAT1.
21541 0 if neither is more specialized.
21543 LEN indicates the number of parameters we should consider
21544 (defaulted parameters should not be considered).
21546 The 1998 std underspecified function template partial ordering, and
21547 DR214 addresses the issue. We take pairs of arguments, one from
21548 each of the templates, and deduce them against each other. One of
21549 the templates will be more specialized if all the *other*
21550 template's arguments deduce against its arguments and at least one
21551 of its arguments *does* *not* deduce against the other template's
21552 corresponding argument. Deduction is done as for class templates.
21553 The arguments used in deduction have reference and top level cv
21554 qualifiers removed. Iff both arguments were originally reference
21555 types *and* deduction succeeds in both directions, an lvalue reference
21556 wins against an rvalue reference and otherwise the template
21557 with the more cv-qualified argument wins for that pairing (if
21558 neither is more cv-qualified, they both are equal). Unlike regular
21559 deduction, after all the arguments have been deduced in this way,
21560 we do *not* verify the deduced template argument values can be
21561 substituted into non-deduced contexts.
21563 The logic can be a bit confusing here, because we look at deduce1 and
21564 targs1 to see if pat2 is at least as specialized, and vice versa; if we
21565 can find template arguments for pat1 to make arg1 look like arg2, that
21566 means that arg2 is at least as specialized as arg1. */
21569 more_specialized_fn (tree pat1
, tree pat2
, int len
)
21571 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
21572 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
21573 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
21574 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
21575 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
21576 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
21577 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
21578 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
21579 tree origs1
, origs2
;
21580 bool lose1
= false;
21581 bool lose2
= false;
21583 /* Remove the this parameter from non-static member functions. If
21584 one is a non-static member function and the other is not a static
21585 member function, remove the first parameter from that function
21586 also. This situation occurs for operator functions where we
21587 locate both a member function (with this pointer) and non-member
21588 operator (with explicit first operand). */
21589 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
21591 len
--; /* LEN is the number of significant arguments for DECL1 */
21592 args1
= TREE_CHAIN (args1
);
21593 if (!DECL_STATIC_FUNCTION_P (decl2
))
21594 args2
= TREE_CHAIN (args2
);
21596 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
21598 args2
= TREE_CHAIN (args2
);
21599 if (!DECL_STATIC_FUNCTION_P (decl1
))
21602 args1
= TREE_CHAIN (args1
);
21606 /* If only one is a conversion operator, they are unordered. */
21607 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
21610 /* Consider the return type for a conversion function */
21611 if (DECL_CONV_FN_P (decl1
))
21613 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
21614 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
21618 processing_template_decl
++;
21624 /* Stop when an ellipsis is seen. */
21625 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
21627 tree arg1
= TREE_VALUE (args1
);
21628 tree arg2
= TREE_VALUE (args2
);
21629 int deduce1
, deduce2
;
21635 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
21636 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
21638 /* When both arguments are pack expansions, we need only
21639 unify the patterns themselves. */
21640 arg1
= PACK_EXPANSION_PATTERN (arg1
);
21641 arg2
= PACK_EXPANSION_PATTERN (arg2
);
21643 /* This is the last comparison we need to do. */
21647 /* DR 1847: If a particular P contains no template-parameters that
21648 participate in template argument deduction, that P is not used to
21649 determine the ordering. */
21650 if (!uses_deducible_template_parms (arg1
)
21651 && !uses_deducible_template_parms (arg2
))
21654 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
21656 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
21657 arg1
= TREE_TYPE (arg1
);
21658 quals1
= cp_type_quals (arg1
);
21661 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
21663 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
21664 arg2
= TREE_TYPE (arg2
);
21665 quals2
= cp_type_quals (arg2
);
21668 arg1
= TYPE_MAIN_VARIANT (arg1
);
21669 arg2
= TYPE_MAIN_VARIANT (arg2
);
21671 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
21673 int i
, len2
= remaining_arguments (args2
);
21674 tree parmvec
= make_tree_vec (1);
21675 tree argvec
= make_tree_vec (len2
);
21678 /* Setup the parameter vector, which contains only ARG1. */
21679 TREE_VEC_ELT (parmvec
, 0) = arg1
;
21681 /* Setup the argument vector, which contains the remaining
21683 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
21684 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
21686 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
21687 argvec
, DEDUCE_EXACT
,
21688 /*subr=*/true, /*explain_p=*/false)
21691 /* We cannot deduce in the other direction, because ARG1 is
21692 a pack expansion but ARG2 is not. */
21695 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
21697 int i
, len1
= remaining_arguments (args1
);
21698 tree parmvec
= make_tree_vec (1);
21699 tree argvec
= make_tree_vec (len1
);
21702 /* Setup the parameter vector, which contains only ARG1. */
21703 TREE_VEC_ELT (parmvec
, 0) = arg2
;
21705 /* Setup the argument vector, which contains the remaining
21707 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
21708 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
21710 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
21711 argvec
, DEDUCE_EXACT
,
21712 /*subr=*/true, /*explain_p=*/false)
21715 /* We cannot deduce in the other direction, because ARG2 is
21716 a pack expansion but ARG1 is not.*/
21722 /* The normal case, where neither argument is a pack
21724 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
21725 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
21727 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
21728 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
21732 /* If we couldn't deduce arguments for tparms1 to make arg1 match
21733 arg2, then arg2 is not as specialized as arg1. */
21739 /* "If, for a given type, deduction succeeds in both directions
21740 (i.e., the types are identical after the transformations above)
21741 and both P and A were reference types (before being replaced with
21742 the type referred to above):
21743 - if the type from the argument template was an lvalue reference and
21744 the type from the parameter template was not, the argument type is
21745 considered to be more specialized than the other; otherwise,
21746 - if the type from the argument template is more cv-qualified
21747 than the type from the parameter template (as described above),
21748 the argument type is considered to be more specialized than the other;
21750 - neither type is more specialized than the other." */
21752 if (deduce1
&& deduce2
)
21754 if (ref1
&& ref2
&& ref1
!= ref2
)
21761 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
21763 if ((quals1
& quals2
) == quals2
)
21765 if ((quals1
& quals2
) == quals1
)
21770 if (lose1
&& lose2
)
21771 /* We've failed to deduce something in either direction.
21772 These must be unordered. */
21777 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
21778 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
21779 /* We have already processed all of the arguments in our
21780 handing of the pack expansion type. */
21783 args1
= TREE_CHAIN (args1
);
21784 args2
= TREE_CHAIN (args2
);
21787 /* "In most cases, all template parameters must have values in order for
21788 deduction to succeed, but for partial ordering purposes a template
21789 parameter may remain without a value provided it is not used in the
21790 types being used for partial ordering."
21792 Thus, if we are missing any of the targs1 we need to substitute into
21793 origs1, then pat2 is not as specialized as pat1. This can happen when
21794 there is a nondeduced context. */
21795 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
21797 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
21800 processing_template_decl
--;
21802 /* If both deductions succeed, the partial ordering selects the more
21803 constrained template. */
21804 if (!lose1
&& !lose2
)
21806 tree c1
= get_constraints (DECL_TEMPLATE_RESULT (pat1
));
21807 tree c2
= get_constraints (DECL_TEMPLATE_RESULT (pat2
));
21808 lose1
= !subsumes_constraints (c1
, c2
);
21809 lose2
= !subsumes_constraints (c2
, c1
);
21812 /* All things being equal, if the next argument is a pack expansion
21813 for one function but not for the other, prefer the
21814 non-variadic function. FIXME this is bogus; see c++/41958. */
21816 && args1
&& TREE_VALUE (args1
)
21817 && args2
&& TREE_VALUE (args2
))
21819 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
21820 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
21823 if (lose1
== lose2
)
21831 /* Determine which of two partial specializations of TMPL is more
21834 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
21835 to the first partial specialization. The TREE_PURPOSE is the
21836 innermost set of template parameters for the partial
21837 specialization. PAT2 is similar, but for the second template.
21839 Return 1 if the first partial specialization is more specialized;
21840 -1 if the second is more specialized; 0 if neither is more
21843 See [temp.class.order] for information about determining which of
21844 two templates is more specialized. */
21847 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
21851 bool any_deductions
= false;
21853 tree tmpl1
= TREE_VALUE (pat1
);
21854 tree tmpl2
= TREE_VALUE (pat2
);
21855 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
21856 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
21858 /* Just like what happens for functions, if we are ordering between
21859 different template specializations, we may encounter dependent
21860 types in the arguments, and we need our dependency check functions
21861 to behave correctly. */
21862 ++processing_template_decl
;
21863 targs
= get_partial_spec_bindings (tmpl
, tmpl1
, specargs2
);
21867 any_deductions
= true;
21870 targs
= get_partial_spec_bindings (tmpl
, tmpl2
, specargs1
);
21874 any_deductions
= true;
21876 --processing_template_decl
;
21878 /* If both deductions succeed, the partial ordering selects the more
21879 constrained template. */
21880 if (!winner
&& any_deductions
)
21881 return more_constrained (tmpl1
, tmpl2
);
21883 /* In the case of a tie where at least one of the templates
21884 has a parameter pack at the end, the template with the most
21885 non-packed parameters wins. */
21888 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
21889 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
21891 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
21892 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
21893 int len1
= TREE_VEC_LENGTH (args1
);
21894 int len2
= TREE_VEC_LENGTH (args2
);
21896 /* We don't count the pack expansion at the end. */
21897 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
21899 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
21904 else if (len1
< len2
)
21911 /* Return the template arguments that will produce the function signature
21912 DECL from the function template FN, with the explicit template
21913 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
21914 also match. Return NULL_TREE if no satisfactory arguments could be
21918 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
21920 int ntparms
= DECL_NTPARMS (fn
);
21921 tree targs
= make_tree_vec (ntparms
);
21922 tree decl_type
= TREE_TYPE (decl
);
21923 tree decl_arg_types
;
21925 unsigned int nargs
, ix
;
21928 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
21930 /* Never do unification on the 'this' parameter. */
21931 decl_arg_types
= skip_artificial_parms_for (decl
,
21932 TYPE_ARG_TYPES (decl_type
));
21934 nargs
= list_length (decl_arg_types
);
21935 args
= XALLOCAVEC (tree
, nargs
);
21936 for (arg
= decl_arg_types
, ix
= 0;
21937 arg
!= NULL_TREE
&& arg
!= void_list_node
;
21938 arg
= TREE_CHAIN (arg
), ++ix
)
21939 args
[ix
] = TREE_VALUE (arg
);
21941 if (fn_type_unification (fn
, explicit_args
, targs
,
21943 (check_rettype
|| DECL_CONV_FN_P (fn
)
21944 ? TREE_TYPE (decl_type
) : NULL_TREE
),
21945 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
21947 == error_mark_node
)
21953 /* Return the innermost template arguments that, when applied to a partial
21954 specialization SPEC_TMPL of TMPL, yield the ARGS.
21956 For example, suppose we have:
21958 template <class T, class U> struct S {};
21959 template <class T> struct S<T*, int> {};
21961 Then, suppose we want to get `S<double*, int>'. SPEC_TMPL will be the
21962 partial specialization and the ARGS will be {double*, int}. The resulting
21963 vector will be {double}, indicating that `T' is bound to `double'. */
21966 get_partial_spec_bindings (tree tmpl
, tree spec_tmpl
, tree args
)
21968 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
21970 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (spec_tmpl
)));
21971 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
21973 tree innermost_deduced_args
;
21975 innermost_deduced_args
= make_tree_vec (ntparms
);
21976 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
21978 deduced_args
= copy_node (args
);
21979 SET_TMPL_ARGS_LEVEL (deduced_args
,
21980 TMPL_ARGS_DEPTH (deduced_args
),
21981 innermost_deduced_args
);
21984 deduced_args
= innermost_deduced_args
;
21986 bool tried_array_deduction
= (cxx_dialect
< cxx17
);
21988 if (unify (tparms
, deduced_args
,
21989 INNERMOST_TEMPLATE_ARGS (spec_args
),
21990 INNERMOST_TEMPLATE_ARGS (args
),
21991 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
21994 for (i
= 0; i
< ntparms
; ++i
)
21995 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
21997 if (!tried_array_deduction
)
21999 try_array_deduction (tparms
, innermost_deduced_args
,
22000 INNERMOST_TEMPLATE_ARGS (spec_args
));
22001 tried_array_deduction
= true;
22002 if (TREE_VEC_ELT (innermost_deduced_args
, i
))
22008 tree tinst
= build_tree_list (spec_tmpl
, deduced_args
);
22009 if (!push_tinst_level (tinst
))
22011 excessive_deduction_depth
= true;
22015 /* Verify that nondeduced template arguments agree with the type
22016 obtained from argument deduction.
22020 struct A { typedef int X; };
22021 template <class T, class U> struct C {};
22022 template <class T> struct C<T, typename T::X> {};
22024 Then with the instantiation `C<A, int>', we can deduce that
22025 `T' is `A' but unify () does not check whether `typename T::X'
22027 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
22029 if (spec_args
!= error_mark_node
)
22030 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
22031 INNERMOST_TEMPLATE_ARGS (spec_args
),
22032 tmpl
, tf_none
, false, false);
22034 pop_tinst_level ();
22036 if (spec_args
== error_mark_node
22037 /* We only need to check the innermost arguments; the other
22038 arguments will always agree. */
22039 || !comp_template_args_porder (INNERMOST_TEMPLATE_ARGS (spec_args
),
22040 INNERMOST_TEMPLATE_ARGS (args
)))
22043 /* Now that we have bindings for all of the template arguments,
22044 ensure that the arguments deduced for the template template
22045 parameters have compatible template parameter lists. See the use
22046 of template_template_parm_bindings_ok_p in fn_type_unification
22047 for more information. */
22048 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
22051 return deduced_args
;
22054 // Compare two function templates T1 and T2 by deducing bindings
22055 // from one against the other. If both deductions succeed, compare
22056 // constraints to see which is more constrained.
22058 more_specialized_inst (tree t1
, tree t2
)
22063 if (get_bindings (t1
, DECL_TEMPLATE_RESULT (t2
), NULL_TREE
, true))
22069 if (get_bindings (t2
, DECL_TEMPLATE_RESULT (t1
), NULL_TREE
, true))
22075 // If both deductions succeed, then one may be more constrained.
22076 if (count
== 2 && fate
== 0)
22077 fate
= more_constrained (t1
, t2
);
22082 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
22083 Return the TREE_LIST node with the most specialized template, if
22084 any. If there is no most specialized template, the error_mark_node
22087 Note that this function does not look at, or modify, the
22088 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
22089 returned is one of the elements of INSTANTIATIONS, callers may
22090 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
22091 and retrieve it from the value returned. */
22094 most_specialized_instantiation (tree templates
)
22098 ++processing_template_decl
;
22101 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
22103 gcc_assert (TREE_VALUE (champ
) != TREE_VALUE (fn
));
22104 int fate
= more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
));
22109 /* Equally specialized, move to next function. If there
22110 is no next function, nothing's most specialized. */
22111 fn
= TREE_CHAIN (fn
);
22119 /* Now verify that champ is better than everything earlier in the
22120 instantiation list. */
22121 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
)) {
22122 if (more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
)) != 1)
22129 processing_template_decl
--;
22132 return error_mark_node
;
22137 /* If DECL is a specialization of some template, return the most
22138 general such template. Otherwise, returns NULL_TREE.
22140 For example, given:
22142 template <class T> struct S { template <class U> void f(U); };
22144 if TMPL is `template <class U> void S<int>::f(U)' this will return
22145 the full template. This function will not trace past partial
22146 specializations, however. For example, given in addition:
22148 template <class T> struct S<T*> { template <class U> void f(U); };
22150 if TMPL is `template <class U> void S<int*>::f(U)' this will return
22151 `template <class T> template <class U> S<T*>::f(U)'. */
22154 most_general_template (tree decl
)
22156 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
22158 if (tree tinfo
= get_template_info (decl
))
22159 decl
= TI_TEMPLATE (tinfo
);
22160 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
22161 template friend, or a FIELD_DECL for a capture pack. */
22162 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
22166 /* Look for more and more general templates. */
22167 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
22169 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
22170 (See cp-tree.h for details.) */
22171 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
22174 if (CLASS_TYPE_P (TREE_TYPE (decl
))
22175 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
22176 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
22179 /* Stop if we run into an explicitly specialized class template. */
22180 if (!DECL_NAMESPACE_SCOPE_P (decl
)
22181 && DECL_CONTEXT (decl
)
22182 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
22185 decl
= DECL_TI_TEMPLATE (decl
);
22191 /* Return the most specialized of the template partial specializations
22192 which can produce TARGET, a specialization of some class or variable
22193 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
22194 a TEMPLATE_DECL node corresponding to the partial specialization, while
22195 the TREE_PURPOSE is the set of template arguments that must be
22196 substituted into the template pattern in order to generate TARGET.
22198 If the choice of partial specialization is ambiguous, a diagnostic
22199 is issued, and the error_mark_node is returned. If there are no
22200 partial specializations matching TARGET, then NULL_TREE is
22201 returned, indicating that the primary template should be used. */
22204 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
22206 tree list
= NULL_TREE
;
22211 tree outer_args
= NULL_TREE
;
22214 if (TYPE_P (target
))
22216 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
22217 tmpl
= TI_TEMPLATE (tinfo
);
22218 args
= TI_ARGS (tinfo
);
22220 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
22222 tmpl
= TREE_OPERAND (target
, 0);
22223 args
= TREE_OPERAND (target
, 1);
22225 else if (VAR_P (target
))
22227 tree tinfo
= DECL_TEMPLATE_INFO (target
);
22228 tmpl
= TI_TEMPLATE (tinfo
);
22229 args
= TI_ARGS (tinfo
);
22232 gcc_unreachable ();
22234 tree main_tmpl
= most_general_template (tmpl
);
22236 /* For determining which partial specialization to use, only the
22237 innermost args are interesting. */
22238 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
22240 outer_args
= strip_innermost_template_args (args
, 1);
22241 args
= INNERMOST_TEMPLATE_ARGS (args
);
22244 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
22247 tree spec_tmpl
= TREE_VALUE (t
);
22251 /* Substitute in the template args from the enclosing class. */
22252 ++processing_template_decl
;
22253 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
22254 --processing_template_decl
;
22257 if (spec_tmpl
== error_mark_node
)
22258 return error_mark_node
;
22260 spec_args
= get_partial_spec_bindings (tmpl
, spec_tmpl
, args
);
22264 spec_args
= add_to_template_args (outer_args
, spec_args
);
22266 /* Keep the candidate only if the constraints are satisfied,
22267 or if we're not compiling with concepts. */
22269 || constraints_satisfied_p (spec_tmpl
, spec_args
))
22271 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
22272 TREE_TYPE (list
) = TREE_TYPE (t
);
22280 ambiguous_p
= false;
22283 t
= TREE_CHAIN (t
);
22284 for (; t
; t
= TREE_CHAIN (t
))
22286 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
22293 t
= TREE_CHAIN (t
);
22296 ambiguous_p
= true;
22305 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
22307 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
22310 ambiguous_p
= true;
22318 char *spaces
= NULL
;
22319 if (!(complain
& tf_error
))
22320 return error_mark_node
;
22321 if (TYPE_P (target
))
22322 error ("ambiguous template instantiation for %q#T", target
);
22324 error ("ambiguous template instantiation for %q#D", target
);
22325 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
22326 for (t
= list
; t
; t
= TREE_CHAIN (t
))
22328 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
22329 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
22330 "%s %#qS", spaces
? spaces
: str
, subst
);
22331 spaces
= spaces
? spaces
: get_spaces (str
);
22334 return error_mark_node
;
22340 /* Explicitly instantiate DECL. */
22343 do_decl_instantiation (tree decl
, tree storage
)
22345 tree result
= NULL_TREE
;
22348 if (!decl
|| decl
== error_mark_node
)
22349 /* An error occurred, for which grokdeclarator has already issued
22350 an appropriate message. */
22352 else if (! DECL_LANG_SPECIFIC (decl
))
22354 error ("explicit instantiation of non-template %q#D", decl
);
22358 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
22359 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
22361 if (VAR_P (decl
) && !var_templ
)
22363 /* There is an asymmetry here in the way VAR_DECLs and
22364 FUNCTION_DECLs are handled by grokdeclarator. In the case of
22365 the latter, the DECL we get back will be marked as a
22366 template instantiation, and the appropriate
22367 DECL_TEMPLATE_INFO will be set up. This does not happen for
22368 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
22369 should handle VAR_DECLs as it currently handles
22371 if (!DECL_CLASS_SCOPE_P (decl
))
22373 error ("%qD is not a static data member of a class template", decl
);
22376 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
22377 if (!result
|| !VAR_P (result
))
22379 error ("no matching template for %qD found", decl
);
22382 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
22384 error ("type %qT for explicit instantiation %qD does not match "
22385 "declared type %qT", TREE_TYPE (result
), decl
,
22390 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
22392 error ("explicit instantiation of %q#D", decl
);
22398 /* Check for various error cases. Note that if the explicit
22399 instantiation is valid the RESULT will currently be marked as an
22400 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
22401 until we get here. */
22403 if (DECL_TEMPLATE_SPECIALIZATION (result
))
22405 /* DR 259 [temp.spec].
22407 Both an explicit instantiation and a declaration of an explicit
22408 specialization shall not appear in a program unless the explicit
22409 instantiation follows a declaration of the explicit specialization.
22411 For a given set of template parameters, if an explicit
22412 instantiation of a template appears after a declaration of an
22413 explicit specialization for that template, the explicit
22414 instantiation has no effect. */
22417 else if (DECL_EXPLICIT_INSTANTIATION (result
))
22421 No program shall explicitly instantiate any template more
22424 We check DECL_NOT_REALLY_EXTERN so as not to complain when
22425 the first instantiation was `extern' and the second is not,
22426 and EXTERN_P for the opposite case. */
22427 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
22428 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
22429 /* If an "extern" explicit instantiation follows an ordinary
22430 explicit instantiation, the template is instantiated. */
22434 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
22436 error ("no matching template for %qD found", result
);
22439 else if (!DECL_TEMPLATE_INFO (result
))
22441 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
22445 if (storage
== NULL_TREE
)
22447 else if (storage
== ridpointers
[(int) RID_EXTERN
])
22449 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
22450 pedwarn (input_location
, OPT_Wpedantic
,
22451 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
22456 error ("storage class %qD applied to template instantiation", storage
);
22458 check_explicit_instantiation_namespace (result
);
22459 mark_decl_instantiated (result
, extern_p
);
22461 instantiate_decl (result
, /*defer_ok=*/true,
22462 /*expl_inst_class_mem_p=*/false);
22466 mark_class_instantiated (tree t
, int extern_p
)
22468 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
22469 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
22470 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
22471 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
22474 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
22475 rest_of_type_compilation (t
, 1);
22479 /* Called from do_type_instantiation through binding_table_foreach to
22480 do recursive instantiation for the type bound in ENTRY. */
22482 bt_instantiate_type_proc (binding_entry entry
, void *data
)
22484 tree storage
= *(tree
*) data
;
22486 if (MAYBE_CLASS_TYPE_P (entry
->type
)
22487 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
22488 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
22491 /* Perform an explicit instantiation of template class T. STORAGE, if
22492 non-null, is the RID for extern, inline or static. COMPLAIN is
22493 nonzero if this is called from the parser, zero if called recursively,
22494 since the standard is unclear (as detailed below). */
22497 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
22502 int previous_instantiation_extern_p
= 0;
22504 if (TREE_CODE (t
) == TYPE_DECL
)
22507 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
22510 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
22512 error ("explicit instantiation of non-class template %qD", tmpl
);
22514 error ("explicit instantiation of non-template type %qT", t
);
22520 if (!COMPLETE_TYPE_P (t
))
22522 if (complain
& tf_error
)
22523 error ("explicit instantiation of %q#T before definition of template",
22528 if (storage
!= NULL_TREE
)
22530 if (!in_system_header_at (input_location
))
22532 if (storage
== ridpointers
[(int) RID_EXTERN
])
22534 if (cxx_dialect
== cxx98
)
22535 pedwarn (input_location
, OPT_Wpedantic
,
22536 "ISO C++ 1998 forbids the use of %<extern%> on "
22537 "explicit instantiations");
22540 pedwarn (input_location
, OPT_Wpedantic
,
22541 "ISO C++ forbids the use of %qE"
22542 " on explicit instantiations", storage
);
22545 if (storage
== ridpointers
[(int) RID_INLINE
])
22547 else if (storage
== ridpointers
[(int) RID_EXTERN
])
22549 else if (storage
== ridpointers
[(int) RID_STATIC
])
22553 error ("storage class %qD applied to template instantiation",
22559 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
22561 /* DR 259 [temp.spec].
22563 Both an explicit instantiation and a declaration of an explicit
22564 specialization shall not appear in a program unless the explicit
22565 instantiation follows a declaration of the explicit specialization.
22567 For a given set of template parameters, if an explicit
22568 instantiation of a template appears after a declaration of an
22569 explicit specialization for that template, the explicit
22570 instantiation has no effect. */
22573 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
22577 No program shall explicitly instantiate any template more
22580 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
22581 instantiation was `extern'. If EXTERN_P then the second is.
22582 These cases are OK. */
22583 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
22585 if (!previous_instantiation_extern_p
&& !extern_p
22586 && (complain
& tf_error
))
22587 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
22589 /* If we've already instantiated the template, just return now. */
22590 if (!CLASSTYPE_INTERFACE_ONLY (t
))
22594 check_explicit_instantiation_namespace (TYPE_NAME (t
));
22595 mark_class_instantiated (t
, extern_p
);
22600 /* In contrast to implicit instantiation, where only the
22601 declarations, and not the definitions, of members are
22602 instantiated, we have here:
22606 The explicit instantiation of a class template specialization
22607 implies the instantiation of all of its members not
22608 previously explicitly specialized in the translation unit
22609 containing the explicit instantiation.
22611 Of course, we can't instantiate member template classes, since we
22612 don't have any arguments for them. Note that the standard is
22613 unclear on whether the instantiation of the members are
22614 *explicit* instantiations or not. However, the most natural
22615 interpretation is that it should be an explicit
22617 for (tree fld
= TYPE_FIELDS (t
); fld
; fld
= DECL_CHAIN (fld
))
22619 || (TREE_CODE (fld
) == FUNCTION_DECL
22621 && user_provided_p (fld
)))
22622 && DECL_TEMPLATE_INSTANTIATION (fld
))
22624 mark_decl_instantiated (fld
, extern_p
);
22626 instantiate_decl (fld
, /*defer_ok=*/true,
22627 /*expl_inst_class_mem_p=*/true);
22630 if (CLASSTYPE_NESTED_UTDS (t
))
22631 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
22632 bt_instantiate_type_proc
, &storage
);
22635 /* Given a function DECL, which is a specialization of TMPL, modify
22636 DECL to be a re-instantiation of TMPL with the same template
22637 arguments. TMPL should be the template into which tsubst'ing
22638 should occur for DECL, not the most general template.
22640 One reason for doing this is a scenario like this:
22643 void f(const T&, int i);
22645 void g() { f(3, 7); }
22648 void f(const T& t, const int i) { }
22650 Note that when the template is first instantiated, with
22651 instantiate_template, the resulting DECL will have no name for the
22652 first parameter, and the wrong type for the second. So, when we go
22653 to instantiate the DECL, we regenerate it. */
22656 regenerate_decl_from_template (tree decl
, tree tmpl
, tree args
)
22658 /* The arguments used to instantiate DECL, from the most general
22662 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
22664 /* Make sure that we can see identifiers, and compute access
22666 push_access_scope (decl
);
22668 if (TREE_CODE (decl
) == FUNCTION_DECL
)
22676 args_depth
= TMPL_ARGS_DEPTH (args
);
22677 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
22678 if (args_depth
> parms_depth
)
22679 args
= get_innermost_template_args (args
, parms_depth
);
22681 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
22682 args
, tf_error
, NULL_TREE
,
22683 /*defer_ok*/false);
22684 if (specs
&& specs
!= error_mark_node
)
22685 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
22688 /* Merge parameter declarations. */
22689 decl_parm
= skip_artificial_parms_for (decl
,
22690 DECL_ARGUMENTS (decl
));
22692 = skip_artificial_parms_for (code_pattern
,
22693 DECL_ARGUMENTS (code_pattern
));
22694 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
22699 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
22700 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
22701 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
22703 parm_type
= type_decays_to (parm_type
);
22704 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
22705 TREE_TYPE (decl_parm
) = parm_type
;
22706 attributes
= DECL_ATTRIBUTES (pattern_parm
);
22707 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
22709 DECL_ATTRIBUTES (decl_parm
) = attributes
;
22710 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
22712 decl_parm
= DECL_CHAIN (decl_parm
);
22713 pattern_parm
= DECL_CHAIN (pattern_parm
);
22715 /* Merge any parameters that match with the function parameter
22717 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
22720 tree expanded_types
;
22721 /* Expand the TYPE_PACK_EXPANSION that provides the types for
22722 the parameters in this function parameter pack. */
22723 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
22724 args
, tf_error
, NULL_TREE
);
22725 len
= TREE_VEC_LENGTH (expanded_types
);
22726 for (i
= 0; i
< len
; i
++)
22731 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
22732 /* Rename the parameter to include the index. */
22733 DECL_NAME (decl_parm
) =
22734 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
22735 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
22736 parm_type
= type_decays_to (parm_type
);
22737 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
22738 TREE_TYPE (decl_parm
) = parm_type
;
22739 attributes
= DECL_ATTRIBUTES (pattern_parm
);
22740 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
22742 DECL_ATTRIBUTES (decl_parm
) = attributes
;
22743 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
22745 decl_parm
= DECL_CHAIN (decl_parm
);
22748 /* Merge additional specifiers from the CODE_PATTERN. */
22749 if (DECL_DECLARED_INLINE_P (code_pattern
)
22750 && !DECL_DECLARED_INLINE_P (decl
))
22751 DECL_DECLARED_INLINE_P (decl
) = 1;
22753 else if (VAR_P (decl
))
22755 start_lambda_scope (decl
);
22756 DECL_INITIAL (decl
) =
22757 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
22758 tf_error
, DECL_TI_TEMPLATE (decl
),
22759 /*integral_constant_expression_p=*/false);
22760 finish_lambda_scope ();
22761 if (VAR_HAD_UNKNOWN_BOUND (decl
))
22762 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
22763 tf_error
, DECL_TI_TEMPLATE (decl
));
22766 gcc_unreachable ();
22768 pop_access_scope (decl
);
22771 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
22772 substituted to get DECL. */
22775 template_for_substitution (tree decl
)
22777 tree tmpl
= DECL_TI_TEMPLATE (decl
);
22779 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
22780 for the instantiation. This is not always the most general
22781 template. Consider, for example:
22784 struct S { template <class U> void f();
22785 template <> void f<int>(); };
22787 and an instantiation of S<double>::f<int>. We want TD to be the
22788 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
22789 while (/* An instantiation cannot have a definition, so we need a
22790 more general template. */
22791 DECL_TEMPLATE_INSTANTIATION (tmpl
)
22792 /* We must also deal with friend templates. Given:
22794 template <class T> struct S {
22795 template <class U> friend void f() {};
22798 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
22799 so far as the language is concerned, but that's still
22800 where we get the pattern for the instantiation from. On
22801 other hand, if the definition comes outside the class, say:
22803 template <class T> struct S {
22804 template <class U> friend void f();
22806 template <class U> friend void f() {}
22808 we don't need to look any further. That's what the check for
22809 DECL_INITIAL is for. */
22810 || (TREE_CODE (decl
) == FUNCTION_DECL
22811 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
22812 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
22814 /* The present template, TD, should not be a definition. If it
22815 were a definition, we should be using it! Note that we
22816 cannot restructure the loop to just keep going until we find
22817 a template with a definition, since that might go too far if
22818 a specialization was declared, but not defined. */
22820 /* Fetch the more general template. */
22821 tmpl
= DECL_TI_TEMPLATE (tmpl
);
22827 /* Returns true if we need to instantiate this template instance even if we
22828 know we aren't going to emit it. */
22831 always_instantiate_p (tree decl
)
22833 /* We always instantiate inline functions so that we can inline them. An
22834 explicit instantiation declaration prohibits implicit instantiation of
22835 non-inline functions. With high levels of optimization, we would
22836 normally inline non-inline functions -- but we're not allowed to do
22837 that for "extern template" functions. Therefore, we check
22838 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
22839 return ((TREE_CODE (decl
) == FUNCTION_DECL
22840 && (DECL_DECLARED_INLINE_P (decl
)
22841 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
22842 /* And we need to instantiate static data members so that
22843 their initializers are available in integral constant
22846 && decl_maybe_constant_var_p (decl
)));
22849 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
22850 instantiate it now, modifying TREE_TYPE (fn). Returns false on
22851 error, true otherwise. */
22854 maybe_instantiate_noexcept (tree fn
, tsubst_flags_t complain
)
22856 tree fntype
, spec
, noex
, clone
;
22858 /* Don't instantiate a noexcept-specification from template context. */
22859 if (processing_template_decl
)
22862 if (DECL_CLONED_FUNCTION_P (fn
))
22863 fn
= DECL_CLONED_FUNCTION (fn
);
22864 fntype
= TREE_TYPE (fn
);
22865 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
22867 if (!spec
|| !TREE_PURPOSE (spec
))
22870 noex
= TREE_PURPOSE (spec
);
22872 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
22874 static hash_set
<tree
>* fns
= new hash_set
<tree
>;
22875 bool added
= false;
22876 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
22877 spec
= get_defaulted_eh_spec (fn
, complain
);
22878 else if (!(added
= !fns
->add (fn
)))
22880 /* If hash_set::add returns true, the element was already there. */
22881 location_t loc
= EXPR_LOC_OR_LOC (DEFERRED_NOEXCEPT_PATTERN (noex
),
22882 DECL_SOURCE_LOCATION (fn
));
22884 "exception specification of %qD depends on itself",
22886 spec
= noexcept_false_spec
;
22888 else if (push_tinst_level (fn
))
22890 push_access_scope (fn
);
22891 push_deferring_access_checks (dk_no_deferred
);
22892 input_location
= DECL_SOURCE_LOCATION (fn
);
22893 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
22894 DEFERRED_NOEXCEPT_ARGS (noex
),
22895 tf_warning_or_error
, fn
,
22896 /*function_p=*/false,
22897 /*integral_constant_expression_p=*/true);
22898 pop_deferring_access_checks ();
22899 pop_access_scope (fn
);
22900 pop_tinst_level ();
22901 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
22902 if (spec
== error_mark_node
)
22903 spec
= noexcept_false_spec
;
22906 spec
= noexcept_false_spec
;
22911 if (spec
== error_mark_node
)
22914 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
22917 FOR_EACH_CLONE (clone
, fn
)
22919 if (TREE_TYPE (clone
) == fntype
)
22920 TREE_TYPE (clone
) = TREE_TYPE (fn
);
22922 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
22928 /* We're starting to process the function INST, an instantiation of PATTERN;
22929 add their parameters to local_specializations. */
22932 register_parameter_specializations (tree pattern
, tree inst
)
22934 tree tmpl_parm
= DECL_ARGUMENTS (pattern
);
22935 tree spec_parm
= DECL_ARGUMENTS (inst
);
22936 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (inst
))
22938 register_local_specialization (spec_parm
, tmpl_parm
);
22939 spec_parm
= skip_artificial_parms_for (inst
, spec_parm
);
22940 tmpl_parm
= skip_artificial_parms_for (pattern
, tmpl_parm
);
22942 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
22944 if (!DECL_PACK_P (tmpl_parm
))
22946 register_local_specialization (spec_parm
, tmpl_parm
);
22947 spec_parm
= DECL_CHAIN (spec_parm
);
22951 /* Register the (value) argument pack as a specialization of
22952 TMPL_PARM, then move on. */
22953 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
22954 register_local_specialization (argpack
, tmpl_parm
);
22957 gcc_assert (!spec_parm
);
22960 /* Produce the definition of D, a _DECL generated from a template. If
22961 DEFER_OK is true, then we don't have to actually do the
22962 instantiation now; we just have to do it sometime. Normally it is
22963 an error if this is an explicit instantiation but D is undefined.
22964 EXPL_INST_CLASS_MEM_P is true iff D is a member of an explicitly
22965 instantiated class template. */
22968 instantiate_decl (tree d
, bool defer_ok
, bool expl_inst_class_mem_p
)
22970 tree tmpl
= DECL_TI_TEMPLATE (d
);
22977 bool pattern_defined
;
22978 location_t saved_loc
= input_location
;
22979 int saved_unevaluated_operand
= cp_unevaluated_operand
;
22980 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
22984 /* This function should only be used to instantiate templates for
22985 functions and static member variables. */
22986 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
22988 /* A concept is never instantiated. */
22989 gcc_assert (!DECL_DECLARED_CONCEPT_P (d
));
22991 /* Variables are never deferred; if instantiation is required, they
22992 are instantiated right away. That allows for better code in the
22993 case that an expression refers to the value of the variable --
22994 if the variable has a constant value the referring expression can
22995 take advantage of that fact. */
22999 /* Don't instantiate cloned functions. Instead, instantiate the
23000 functions they cloned. */
23001 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
23002 d
= DECL_CLONED_FUNCTION (d
);
23004 if (DECL_TEMPLATE_INSTANTIATED (d
)
23005 || (TREE_CODE (d
) == FUNCTION_DECL
23006 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
23007 || DECL_TEMPLATE_SPECIALIZATION (d
))
23008 /* D has already been instantiated or explicitly specialized, so
23009 there's nothing for us to do here.
23011 It might seem reasonable to check whether or not D is an explicit
23012 instantiation, and, if so, stop here. But when an explicit
23013 instantiation is deferred until the end of the compilation,
23014 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
23015 the instantiation. */
23018 /* Check to see whether we know that this template will be
23019 instantiated in some other file, as with "extern template"
23021 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
23023 /* In general, we do not instantiate such templates. */
23024 if (external_p
&& !always_instantiate_p (d
))
23027 gen_tmpl
= most_general_template (tmpl
);
23028 gen_args
= DECL_TI_ARGS (d
);
23030 if (tmpl
!= gen_tmpl
)
23031 /* We should already have the extra args. */
23032 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
23033 == TMPL_ARGS_DEPTH (gen_args
));
23034 /* And what's in the hash table should match D. */
23035 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
23036 || spec
== NULL_TREE
);
23038 /* This needs to happen before any tsubsting. */
23039 if (! push_tinst_level (d
))
23042 timevar_push (TV_TEMPLATE_INST
);
23044 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
23045 for the instantiation. */
23046 td
= template_for_substitution (d
);
23051 /* Look up an explicit specialization, if any. */
23052 tree tid
= lookup_template_variable (gen_tmpl
, gen_args
);
23053 tree elt
= most_specialized_partial_spec (tid
, tf_warning_or_error
);
23054 if (elt
&& elt
!= error_mark_node
)
23056 td
= TREE_VALUE (elt
);
23057 args
= TREE_PURPOSE (elt
);
23061 code_pattern
= DECL_TEMPLATE_RESULT (td
);
23063 /* We should never be trying to instantiate a member of a class
23064 template or partial specialization. */
23065 gcc_assert (d
!= code_pattern
);
23067 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
23068 || DECL_TEMPLATE_SPECIALIZATION (td
))
23069 /* In the case of a friend template whose definition is provided
23070 outside the class, we may have too many arguments. Drop the
23071 ones we don't need. The same is true for specializations. */
23072 args
= get_innermost_template_args
23073 (args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
23075 if (TREE_CODE (d
) == FUNCTION_DECL
)
23077 deleted_p
= DECL_DELETED_FN (code_pattern
);
23078 pattern_defined
= ((DECL_SAVED_TREE (code_pattern
) != NULL_TREE
23079 && DECL_INITIAL (code_pattern
) != error_mark_node
)
23080 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
23086 if (DECL_CLASS_SCOPE_P (code_pattern
))
23087 pattern_defined
= (! DECL_IN_AGGR_P (code_pattern
)
23088 || DECL_INLINE_VAR_P (code_pattern
));
23090 pattern_defined
= ! DECL_EXTERNAL (code_pattern
);
23093 /* We may be in the middle of deferred access check. Disable it now. */
23094 push_deferring_access_checks (dk_no_deferred
);
23096 /* Unless an explicit instantiation directive has already determined
23097 the linkage of D, remember that a definition is available for
23099 if (pattern_defined
23100 && !DECL_INTERFACE_KNOWN (d
)
23101 && !DECL_NOT_REALLY_EXTERN (d
))
23102 mark_definable (d
);
23104 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
23105 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
23106 input_location
= DECL_SOURCE_LOCATION (d
);
23108 /* If D is a member of an explicitly instantiated class template,
23109 and no definition is available, treat it like an implicit
23111 if (!pattern_defined
&& expl_inst_class_mem_p
23112 && DECL_EXPLICIT_INSTANTIATION (d
))
23114 /* Leave linkage flags alone on instantiations with anonymous
23116 if (TREE_PUBLIC (d
))
23118 DECL_NOT_REALLY_EXTERN (d
) = 0;
23119 DECL_INTERFACE_KNOWN (d
) = 0;
23121 SET_DECL_IMPLICIT_INSTANTIATION (d
);
23124 /* Defer all other templates, unless we have been explicitly
23125 forbidden from doing so. */
23126 if (/* If there is no definition, we cannot instantiate the
23129 /* If it's OK to postpone instantiation, do so. */
23131 /* If this is a static data member that will be defined
23132 elsewhere, we don't want to instantiate the entire data
23133 member, but we do want to instantiate the initializer so that
23134 we can substitute that elsewhere. */
23135 || (external_p
&& VAR_P (d
))
23136 /* Handle here a deleted function too, avoid generating
23137 its body (c++/61080). */
23140 /* The definition of the static data member is now required so
23141 we must substitute the initializer. */
23143 && !DECL_INITIAL (d
)
23144 && DECL_INITIAL (code_pattern
))
23148 bool const_init
= false;
23149 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
23151 ns
= decl_namespace_context (d
);
23152 push_nested_namespace (ns
);
23154 push_nested_class (DECL_CONTEXT (d
));
23155 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
23157 tf_warning_or_error
, NULL_TREE
,
23158 /*integral_constant_expression_p=*/false);
23159 /* If instantiating the initializer involved instantiating this
23160 again, don't call cp_finish_decl twice. */
23161 if (!DECL_INITIAL (d
))
23163 /* Make sure the initializer is still constant, in case of
23164 circular dependency (template/instantiate6.C). */
23166 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
23167 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
23168 /*asmspec_tree=*/NULL_TREE
,
23169 LOOKUP_ONLYCONVERTING
);
23172 pop_nested_class ();
23173 pop_nested_namespace (ns
);
23176 /* We restore the source position here because it's used by
23177 add_pending_template. */
23178 input_location
= saved_loc
;
23180 if (at_eof
&& !pattern_defined
23181 && DECL_EXPLICIT_INSTANTIATION (d
)
23182 && DECL_NOT_REALLY_EXTERN (d
))
23185 The definition of a non-exported function template, a
23186 non-exported member function template, or a non-exported
23187 member function or static data member of a class template
23188 shall be present in every translation unit in which it is
23189 explicitly instantiated. */
23190 permerror (input_location
, "explicit instantiation of %qD "
23191 "but no definition available", d
);
23193 /* If we're in unevaluated context, we just wanted to get the
23194 constant value; this isn't an odr use, so don't queue
23195 a full instantiation. */
23196 if (cp_unevaluated_operand
!= 0)
23198 /* ??? Historically, we have instantiated inline functions, even
23199 when marked as "extern template". */
23200 if (!(external_p
&& VAR_P (d
)))
23201 add_pending_template (d
);
23204 /* Tell the repository that D is available in this translation unit
23205 -- and see if it is supposed to be instantiated here. */
23206 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
23208 /* In a PCH file, despite the fact that the repository hasn't
23209 requested instantiation in the PCH it is still possible that
23210 an instantiation will be required in a file that includes the
23213 add_pending_template (d
);
23214 /* Instantiate inline functions so that the inliner can do its
23215 job, even though we'll not be emitting a copy of this
23217 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
23221 bool push_to_top
, nested
;
23223 fn_context
= decl_function_context (d
);
23224 nested
= current_function_decl
!= NULL_TREE
;
23225 push_to_top
= !(nested
&& fn_context
== current_function_decl
);
23227 vec
<tree
> omp_privatization_save
;
23229 save_omp_privatization_clauses (omp_privatization_save
);
23232 push_to_top_level ();
23235 push_function_context ();
23236 cp_unevaluated_operand
= 0;
23237 c_inhibit_evaluation_warnings
= 0;
23240 /* Mark D as instantiated so that recursive calls to
23241 instantiate_decl do not try to instantiate it again. */
23242 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
23244 /* Regenerate the declaration in case the template has been modified
23245 by a subsequent redeclaration. */
23246 regenerate_decl_from_template (d
, td
, args
);
23248 /* We already set the file and line above. Reset them now in case
23249 they changed as a result of calling regenerate_decl_from_template. */
23250 input_location
= DECL_SOURCE_LOCATION (d
);
23255 bool const_init
= false;
23257 /* Clear out DECL_RTL; whatever was there before may not be right
23258 since we've reset the type of the declaration. */
23259 SET_DECL_RTL (d
, NULL
);
23260 DECL_IN_AGGR_P (d
) = 0;
23262 /* The initializer is placed in DECL_INITIAL by
23263 regenerate_decl_from_template so we don't need to
23264 push/pop_access_scope again here. Pull it out so that
23265 cp_finish_decl can process it. */
23266 init
= DECL_INITIAL (d
);
23267 DECL_INITIAL (d
) = NULL_TREE
;
23268 DECL_INITIALIZED_P (d
) = 0;
23270 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
23271 initializer. That function will defer actual emission until
23272 we have a chance to determine linkage. */
23273 DECL_EXTERNAL (d
) = 0;
23275 /* Enter the scope of D so that access-checking works correctly. */
23276 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
23278 push_nested_class (DECL_CONTEXT (d
));
23280 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
23281 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
23284 pop_nested_class ();
23286 if (variable_template_p (gen_tmpl
))
23287 note_variable_template_instantiation (d
);
23289 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
23290 synthesize_method (d
);
23291 else if (TREE_CODE (d
) == FUNCTION_DECL
)
23293 /* Set up the list of local specializations. */
23294 local_specialization_stack
lss (push_to_top
? lss_blank
: lss_copy
);
23295 tree block
= NULL_TREE
;
23297 /* Set up context. */
23298 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
23299 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
23300 block
= push_stmt_list ();
23302 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
23304 /* Some typedefs referenced from within the template code need to be
23305 access checked at template instantiation time, i.e now. These
23306 types were added to the template at parsing time. Let's get those
23307 and perform the access checks then. */
23308 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (td
),
23311 /* Create substitution entries for the parameters. */
23312 register_parameter_specializations (code_pattern
, d
);
23314 /* Substitute into the body of the function. */
23315 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
23316 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
23317 tf_warning_or_error
, tmpl
);
23320 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
23321 tf_warning_or_error
, tmpl
,
23322 /*integral_constant_expression_p=*/false);
23324 /* Set the current input_location to the end of the function
23325 so that finish_function knows where we are. */
23327 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
23329 /* Remember if we saw an infinite loop in the template. */
23330 current_function_infinite_loop
23331 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
23334 /* Finish the function. */
23335 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
23336 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
23337 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
23340 d
= finish_function (/*inline_p=*/false);
23341 expand_or_defer_fn (d
);
23344 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
23345 cp_check_omp_declare_reduction (d
);
23348 /* We're not deferring instantiation any more. */
23349 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
23352 pop_from_top_level ();
23354 pop_function_context ();
23357 restore_omp_privatization_clauses (omp_privatization_save
);
23360 pop_deferring_access_checks ();
23361 timevar_pop (TV_TEMPLATE_INST
);
23362 pop_tinst_level ();
23363 input_location
= saved_loc
;
23364 cp_unevaluated_operand
= saved_unevaluated_operand
;
23365 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
23370 /* Run through the list of templates that we wish we could
23371 instantiate, and instantiate any we can. RETRIES is the
23372 number of times we retry pending template instantiation. */
23375 instantiate_pending_templates (int retries
)
23378 location_t saved_loc
= input_location
;
23380 /* Instantiating templates may trigger vtable generation. This in turn
23381 may require further template instantiations. We place a limit here
23382 to avoid infinite loop. */
23383 if (pending_templates
&& retries
>= max_tinst_depth
)
23385 tree decl
= pending_templates
->tinst
->decl
;
23387 fatal_error (input_location
,
23388 "template instantiation depth exceeds maximum of %d"
23389 " instantiating %q+D, possibly from virtual table generation"
23390 " (use -ftemplate-depth= to increase the maximum)",
23391 max_tinst_depth
, decl
);
23392 if (TREE_CODE (decl
) == FUNCTION_DECL
)
23393 /* Pretend that we defined it. */
23394 DECL_INITIAL (decl
) = error_mark_node
;
23400 struct pending_template
**t
= &pending_templates
;
23401 struct pending_template
*last
= NULL
;
23405 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
23406 bool complete
= false;
23408 if (TYPE_P (instantiation
))
23410 if (!COMPLETE_TYPE_P (instantiation
))
23412 instantiate_class_template (instantiation
);
23413 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
23414 for (tree fld
= TYPE_FIELDS (instantiation
);
23415 fld
; fld
= TREE_CHAIN (fld
))
23417 || (TREE_CODE (fld
) == FUNCTION_DECL
23418 && !DECL_ARTIFICIAL (fld
)))
23419 && DECL_TEMPLATE_INSTANTIATION (fld
))
23420 instantiate_decl (fld
,
23421 /*defer_ok=*/false,
23422 /*expl_inst_class_mem_p=*/false);
23424 if (COMPLETE_TYPE_P (instantiation
))
23428 complete
= COMPLETE_TYPE_P (instantiation
);
23432 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
23433 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
23436 = instantiate_decl (instantiation
,
23437 /*defer_ok=*/false,
23438 /*expl_inst_class_mem_p=*/false);
23439 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
23443 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
23444 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
23448 /* If INSTANTIATION has been instantiated, then we don't
23449 need to consider it again in the future. */
23457 current_tinst_level
= NULL
;
23459 last_pending_template
= last
;
23461 while (reconsider
);
23463 input_location
= saved_loc
;
23466 /* Substitute ARGVEC into T, which is a list of initializers for
23467 either base class or a non-static data member. The TREE_PURPOSEs
23468 are DECLs, and the TREE_VALUEs are the initializer values. Used by
23469 instantiate_decl. */
23472 tsubst_initializer_list (tree t
, tree argvec
)
23474 tree inits
= NULL_TREE
;
23476 for (; t
; t
= TREE_CHAIN (t
))
23480 tree expanded_bases
= NULL_TREE
;
23481 tree expanded_arguments
= NULL_TREE
;
23484 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
23489 /* Expand the base class expansion type into separate base
23491 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
23492 tf_warning_or_error
,
23494 if (expanded_bases
== error_mark_node
)
23497 /* We'll be building separate TREE_LISTs of arguments for
23499 len
= TREE_VEC_LENGTH (expanded_bases
);
23500 expanded_arguments
= make_tree_vec (len
);
23501 for (i
= 0; i
< len
; i
++)
23502 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
23504 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
23505 expand each argument in the TREE_VALUE of t. */
23506 expr
= make_node (EXPR_PACK_EXPANSION
);
23507 PACK_EXPANSION_LOCAL_P (expr
) = true;
23508 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
23509 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
23511 if (TREE_VALUE (t
) == void_type_node
)
23512 /* VOID_TYPE_NODE is used to indicate
23513 value-initialization. */
23515 for (i
= 0; i
< len
; i
++)
23516 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
23520 /* Substitute parameter packs into each argument in the
23522 in_base_initializer
= 1;
23523 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
23525 tree expanded_exprs
;
23527 /* Expand the argument. */
23528 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
23530 = tsubst_pack_expansion (expr
, argvec
,
23531 tf_warning_or_error
,
23533 if (expanded_exprs
== error_mark_node
)
23536 /* Prepend each of the expanded expressions to the
23537 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
23538 for (i
= 0; i
< len
; i
++)
23540 TREE_VEC_ELT (expanded_arguments
, i
) =
23541 tree_cons (NULL_TREE
,
23542 TREE_VEC_ELT (expanded_exprs
, i
),
23543 TREE_VEC_ELT (expanded_arguments
, i
));
23546 in_base_initializer
= 0;
23548 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
23549 since we built them backwards. */
23550 for (i
= 0; i
< len
; i
++)
23552 TREE_VEC_ELT (expanded_arguments
, i
) =
23553 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
23558 for (i
= 0; i
< len
; ++i
)
23560 if (expanded_bases
)
23562 decl
= TREE_VEC_ELT (expanded_bases
, i
);
23563 decl
= expand_member_init (decl
);
23564 init
= TREE_VEC_ELT (expanded_arguments
, i
);
23569 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
23570 tf_warning_or_error
, NULL_TREE
);
23572 decl
= expand_member_init (decl
);
23573 if (decl
&& !DECL_P (decl
))
23574 in_base_initializer
= 1;
23576 init
= TREE_VALUE (t
);
23578 if (init
!= void_type_node
)
23579 init
= tsubst_expr (init
, argvec
,
23580 tf_warning_or_error
, NULL_TREE
,
23581 /*integral_constant_expression_p=*/false);
23582 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
23583 /* If we had an initializer but it instantiated to nothing,
23584 value-initialize the object. This will only occur when
23585 the initializer was a pack expansion where the parameter
23586 packs used in that expansion were of length zero. */
23587 init
= void_type_node
;
23588 in_base_initializer
= 0;
23593 init
= build_tree_list (decl
, init
);
23594 TREE_CHAIN (init
) = inits
;
23602 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
23605 set_current_access_from_decl (tree decl
)
23607 if (TREE_PRIVATE (decl
))
23608 current_access_specifier
= access_private_node
;
23609 else if (TREE_PROTECTED (decl
))
23610 current_access_specifier
= access_protected_node
;
23612 current_access_specifier
= access_public_node
;
23615 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
23616 is the instantiation (which should have been created with
23617 start_enum) and ARGS are the template arguments to use. */
23620 tsubst_enum (tree tag
, tree newtag
, tree args
)
23624 if (SCOPED_ENUM_P (newtag
))
23625 begin_scope (sk_scoped_enum
, newtag
);
23627 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
23632 decl
= TREE_VALUE (e
);
23633 /* Note that in a template enum, the TREE_VALUE is the
23634 CONST_DECL, not the corresponding INTEGER_CST. */
23635 value
= tsubst_expr (DECL_INITIAL (decl
),
23636 args
, tf_warning_or_error
, NULL_TREE
,
23637 /*integral_constant_expression_p=*/true);
23639 /* Give this enumeration constant the correct access. */
23640 set_current_access_from_decl (decl
);
23642 /* Actually build the enumerator itself. Here we're assuming that
23643 enumerators can't have dependent attributes. */
23644 build_enumerator (DECL_NAME (decl
), value
, newtag
,
23645 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
23648 if (SCOPED_ENUM_P (newtag
))
23651 finish_enum_value_list (newtag
);
23652 finish_enum (newtag
);
23654 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
23655 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
23658 /* DECL is a FUNCTION_DECL that is a template specialization. Return
23659 its type -- but without substituting the innermost set of template
23660 arguments. So, innermost set of template parameters will appear in
23664 get_mostly_instantiated_function_type (tree decl
)
23666 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
23667 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
23670 /* Return truthvalue if we're processing a template different from
23671 the last one involved in diagnostics. */
23673 problematic_instantiation_changed (void)
23675 return current_tinst_level
!= last_error_tinst_level
;
23678 /* Remember current template involved in diagnostics. */
23680 record_last_problematic_instantiation (void)
23682 last_error_tinst_level
= current_tinst_level
;
23685 struct tinst_level
*
23686 current_instantiation (void)
23688 return current_tinst_level
;
23691 /* Return TRUE if current_function_decl is being instantiated, false
23695 instantiating_current_function_p (void)
23697 return (current_instantiation ()
23698 && current_instantiation ()->decl
== current_function_decl
);
23701 /* [temp.param] Check that template non-type parm TYPE is of an allowable
23702 type. Return false for ok, true for disallowed. Issue error and
23703 inform messages under control of COMPLAIN. */
23706 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
23708 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
23710 else if (POINTER_TYPE_P (type
))
23712 else if (TYPE_PTRMEM_P (type
))
23714 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
23716 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
23718 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
23720 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
23722 /* A bound template template parm could later be instantiated to have a valid
23723 nontype parm type via an alias template. */
23724 else if (cxx_dialect
>= cxx11
23725 && TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
23728 if (complain
& tf_error
)
23730 if (type
== error_mark_node
)
23731 inform (input_location
, "invalid template non-type parameter");
23733 error ("%q#T is not a valid type for a template non-type parameter",
23739 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
23740 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
23743 dependent_type_p_r (tree type
)
23749 A type is dependent if it is:
23751 -- a template parameter. Template template parameters are types
23752 for us (since TYPE_P holds true for them) so we handle
23754 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
23755 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
23757 /* -- a qualified-id with a nested-name-specifier which contains a
23758 class-name that names a dependent type or whose unqualified-id
23759 names a dependent type. */
23760 if (TREE_CODE (type
) == TYPENAME_TYPE
)
23763 /* An alias template specialization can be dependent even if the
23764 resulting type is not. */
23765 if (dependent_alias_template_spec_p (type
))
23768 /* -- a cv-qualified type where the cv-unqualified type is
23770 No code is necessary for this bullet; the code below handles
23771 cv-qualified types, and we don't want to strip aliases with
23772 TYPE_MAIN_VARIANT because of DR 1558. */
23773 /* -- a compound type constructed from any dependent type. */
23774 if (TYPE_PTRMEM_P (type
))
23775 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
23776 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
23778 else if (TYPE_PTR_P (type
)
23779 || TREE_CODE (type
) == REFERENCE_TYPE
)
23780 return dependent_type_p (TREE_TYPE (type
));
23781 else if (TREE_CODE (type
) == FUNCTION_TYPE
23782 || TREE_CODE (type
) == METHOD_TYPE
)
23786 if (dependent_type_p (TREE_TYPE (type
)))
23788 for (arg_type
= TYPE_ARG_TYPES (type
);
23790 arg_type
= TREE_CHAIN (arg_type
))
23791 if (dependent_type_p (TREE_VALUE (arg_type
)))
23793 if (cxx_dialect
>= cxx17
)
23794 /* A value-dependent noexcept-specifier makes the type dependent. */
23795 if (tree spec
= TYPE_RAISES_EXCEPTIONS (type
))
23796 if (tree noex
= TREE_PURPOSE (spec
))
23797 /* Treat DEFERRED_NOEXCEPT as non-dependent, since it doesn't
23798 affect overload resolution and treating it as dependent breaks
23800 if (TREE_CODE (noex
) != DEFERRED_NOEXCEPT
23801 && value_dependent_expression_p (noex
))
23805 /* -- an array type constructed from any dependent type or whose
23806 size is specified by a constant expression that is
23809 We checked for type- and value-dependence of the bounds in
23810 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
23811 if (TREE_CODE (type
) == ARRAY_TYPE
)
23813 if (TYPE_DOMAIN (type
)
23814 && dependent_type_p (TYPE_DOMAIN (type
)))
23816 return dependent_type_p (TREE_TYPE (type
));
23819 /* -- a template-id in which either the template name is a template
23821 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
23823 /* ... or any of the template arguments is a dependent type or
23824 an expression that is type-dependent or value-dependent. */
23825 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
23826 && (any_dependent_template_arguments_p
23827 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
23830 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
23831 dependent; if the argument of the `typeof' expression is not
23832 type-dependent, then it should already been have resolved. */
23833 if (TREE_CODE (type
) == TYPEOF_TYPE
23834 || TREE_CODE (type
) == DECLTYPE_TYPE
23835 || TREE_CODE (type
) == UNDERLYING_TYPE
)
23838 /* A template argument pack is dependent if any of its packed
23840 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
23842 tree args
= ARGUMENT_PACK_ARGS (type
);
23843 int i
, len
= TREE_VEC_LENGTH (args
);
23844 for (i
= 0; i
< len
; ++i
)
23845 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
23849 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
23850 be template parameters. */
23851 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
23854 if (any_dependent_type_attributes_p (TYPE_ATTRIBUTES (type
)))
23857 /* The standard does not specifically mention types that are local
23858 to template functions or local classes, but they should be
23859 considered dependent too. For example:
23861 template <int I> void f() {
23866 The size of `E' cannot be known until the value of `I' has been
23867 determined. Therefore, `E' must be considered dependent. */
23868 scope
= TYPE_CONTEXT (type
);
23869 if (scope
&& TYPE_P (scope
))
23870 return dependent_type_p (scope
);
23871 /* Don't use type_dependent_expression_p here, as it can lead
23872 to infinite recursion trying to determine whether a lambda
23873 nested in a lambda is dependent (c++/47687). */
23874 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
23875 && DECL_LANG_SPECIFIC (scope
)
23876 && DECL_TEMPLATE_INFO (scope
)
23877 && (any_dependent_template_arguments_p
23878 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
23881 /* Other types are non-dependent. */
23885 /* Returns TRUE if TYPE is dependent, in the sense of
23886 [temp.dep.type]. Note that a NULL type is considered dependent. */
23889 dependent_type_p (tree type
)
23891 /* If there are no template parameters in scope, then there can't be
23892 any dependent types. */
23893 if (!processing_template_decl
)
23895 /* If we are not processing a template, then nobody should be
23896 providing us with a dependent type. */
23898 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
23902 /* If the type is NULL, we have not computed a type for the entity
23903 in question; in that case, the type is dependent. */
23907 /* Erroneous types can be considered non-dependent. */
23908 if (type
== error_mark_node
)
23911 /* Getting here with global_type_node means we improperly called this
23912 function on the TREE_TYPE of an IDENTIFIER_NODE. */
23913 gcc_checking_assert (type
!= global_type_node
);
23915 /* If we have not already computed the appropriate value for TYPE,
23917 if (!TYPE_DEPENDENT_P_VALID (type
))
23919 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
23920 TYPE_DEPENDENT_P_VALID (type
) = 1;
23923 return TYPE_DEPENDENT_P (type
);
23926 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
23927 lookup. In other words, a dependent type that is not the current
23931 dependent_scope_p (tree scope
)
23933 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
23934 && !currently_open_class (scope
));
23937 /* T is a SCOPE_REF; return whether we need to consider it
23938 instantiation-dependent so that we can check access at instantiation
23939 time even though we know which member it resolves to. */
23942 instantiation_dependent_scope_ref_p (tree t
)
23944 if (DECL_P (TREE_OPERAND (t
, 1))
23945 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
23946 && accessible_in_template_p (TREE_OPERAND (t
, 0),
23947 TREE_OPERAND (t
, 1)))
23953 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
23954 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
23957 /* Note that this predicate is not appropriate for general expressions;
23958 only constant expressions (that satisfy potential_constant_expression)
23959 can be tested for value dependence. */
23962 value_dependent_expression_p (tree expression
)
23964 if (!processing_template_decl
|| expression
== NULL_TREE
)
23967 /* A type-dependent expression is also value-dependent. */
23968 if (type_dependent_expression_p (expression
))
23971 switch (TREE_CODE (expression
))
23974 /* A dependent member function of the current instantiation. */
23975 return dependent_type_p (BINFO_TYPE (BASELINK_BINFO (expression
)));
23977 case FUNCTION_DECL
:
23978 /* A dependent member function of the current instantiation. */
23979 if (DECL_CLASS_SCOPE_P (expression
)
23980 && dependent_type_p (DECL_CONTEXT (expression
)))
23984 case IDENTIFIER_NODE
:
23985 /* A name that has not been looked up -- must be dependent. */
23988 case TEMPLATE_PARM_INDEX
:
23989 /* A non-type template parm. */
23993 /* A non-type template parm. */
23994 if (DECL_TEMPLATE_PARM_P (expression
))
23996 return value_dependent_expression_p (DECL_INITIAL (expression
));
23999 /* A constant with literal type and is initialized
24000 with an expression that is value-dependent. */
24001 if (DECL_DEPENDENT_INIT_P (expression
)
24002 /* FIXME cp_finish_decl doesn't fold reference initializers. */
24003 || TREE_CODE (TREE_TYPE (expression
)) == REFERENCE_TYPE
)
24005 if (DECL_HAS_VALUE_EXPR_P (expression
))
24007 tree value_expr
= DECL_VALUE_EXPR (expression
);
24008 if (value_dependent_expression_p (value_expr
))
24013 case DYNAMIC_CAST_EXPR
:
24014 case STATIC_CAST_EXPR
:
24015 case CONST_CAST_EXPR
:
24016 case REINTERPRET_CAST_EXPR
:
24018 case IMPLICIT_CONV_EXPR
:
24019 /* These expressions are value-dependent if the type to which
24020 the cast occurs is dependent or the expression being casted
24021 is value-dependent. */
24023 tree type
= TREE_TYPE (expression
);
24025 if (dependent_type_p (type
))
24028 /* A functional cast has a list of operands. */
24029 expression
= TREE_OPERAND (expression
, 0);
24032 /* If there are no operands, it must be an expression such
24033 as "int()". This should not happen for aggregate types
24034 because it would form non-constant expressions. */
24035 gcc_assert (cxx_dialect
>= cxx11
24036 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
24041 if (TREE_CODE (expression
) == TREE_LIST
)
24042 return any_value_dependent_elements_p (expression
);
24044 return value_dependent_expression_p (expression
);
24048 if (SIZEOF_EXPR_TYPE_P (expression
))
24049 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
24053 /* A `sizeof' expression is value-dependent if the operand is
24054 type-dependent or is a pack expansion. */
24055 expression
= TREE_OPERAND (expression
, 0);
24056 if (PACK_EXPANSION_P (expression
))
24058 else if (TYPE_P (expression
))
24059 return dependent_type_p (expression
);
24060 return instantiation_dependent_uneval_expression_p (expression
);
24062 case AT_ENCODE_EXPR
:
24063 /* An 'encode' expression is value-dependent if the operand is
24065 expression
= TREE_OPERAND (expression
, 0);
24066 return dependent_type_p (expression
);
24068 case NOEXCEPT_EXPR
:
24069 expression
= TREE_OPERAND (expression
, 0);
24070 return instantiation_dependent_uneval_expression_p (expression
);
24073 /* All instantiation-dependent expressions should also be considered
24074 value-dependent. */
24075 return instantiation_dependent_scope_ref_p (expression
);
24077 case COMPONENT_REF
:
24078 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
24079 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
24081 case NONTYPE_ARGUMENT_PACK
:
24082 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
24083 is value-dependent. */
24085 tree values
= ARGUMENT_PACK_ARGS (expression
);
24086 int i
, len
= TREE_VEC_LENGTH (values
);
24088 for (i
= 0; i
< len
; ++i
)
24089 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
24097 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
24099 if (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
)))
24105 if (TREE_CODE (type2
) != TREE_LIST
)
24106 return dependent_type_p (type2
);
24108 for (; type2
; type2
= TREE_CHAIN (type2
))
24109 if (dependent_type_p (TREE_VALUE (type2
)))
24116 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
24117 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
24120 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
24121 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
24125 tree op
= TREE_OPERAND (expression
, 0);
24126 return (value_dependent_expression_p (op
)
24127 || has_value_dependent_address (op
));
24130 case REQUIRES_EXPR
:
24131 /* Treat all requires-expressions as value-dependent so
24132 we don't try to fold them. */
24136 return dependent_type_p (TREE_OPERAND (expression
, 0));
24140 if (value_dependent_expression_p (CALL_EXPR_FN (expression
)))
24142 tree fn
= get_callee_fndecl (expression
);
24144 nargs
= call_expr_nargs (expression
);
24145 for (i
= 0; i
< nargs
; ++i
)
24147 tree op
= CALL_EXPR_ARG (expression
, i
);
24148 /* In a call to a constexpr member function, look through the
24149 implicit ADDR_EXPR on the object argument so that it doesn't
24150 cause the call to be considered value-dependent. We also
24151 look through it in potential_constant_expression. */
24152 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
24153 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
24154 && TREE_CODE (op
) == ADDR_EXPR
)
24155 op
= TREE_OPERAND (op
, 0);
24156 if (value_dependent_expression_p (op
))
24162 case TEMPLATE_ID_EXPR
:
24163 return variable_concept_p (TREE_OPERAND (expression
, 0));
24169 if (dependent_type_p (TREE_TYPE (expression
)))
24171 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
24172 if (value_dependent_expression_p (val
))
24178 /* Treat a GNU statement expression as dependent to avoid crashing
24179 under instantiate_non_dependent_expr; it can't be constant. */
24183 /* A constant expression is value-dependent if any subexpression is
24184 value-dependent. */
24185 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
24187 case tcc_reference
:
24189 case tcc_comparison
:
24191 case tcc_expression
:
24194 int i
, len
= cp_tree_operand_length (expression
);
24196 for (i
= 0; i
< len
; i
++)
24198 tree t
= TREE_OPERAND (expression
, i
);
24200 /* In some cases, some of the operands may be missing.
24201 (For example, in the case of PREDECREMENT_EXPR, the
24202 amount to increment by may be missing.) That doesn't
24203 make the expression dependent. */
24204 if (t
&& value_dependent_expression_p (t
))
24215 /* The expression is not value-dependent. */
24219 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
24220 [temp.dep.expr]. Note that an expression with no type is
24221 considered dependent. Other parts of the compiler arrange for an
24222 expression with type-dependent subexpressions to have no type, so
24223 this function doesn't have to be fully recursive. */
24226 type_dependent_expression_p (tree expression
)
24228 if (!processing_template_decl
)
24231 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
24234 /* An unresolved name is always dependent. */
24235 if (identifier_p (expression
)
24236 || TREE_CODE (expression
) == USING_DECL
24237 || TREE_CODE (expression
) == WILDCARD_DECL
)
24240 /* A fold expression is type-dependent. */
24241 if (TREE_CODE (expression
) == UNARY_LEFT_FOLD_EXPR
24242 || TREE_CODE (expression
) == UNARY_RIGHT_FOLD_EXPR
24243 || TREE_CODE (expression
) == BINARY_LEFT_FOLD_EXPR
24244 || TREE_CODE (expression
) == BINARY_RIGHT_FOLD_EXPR
)
24247 /* Some expression forms are never type-dependent. */
24248 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
24249 || TREE_CODE (expression
) == SIZEOF_EXPR
24250 || TREE_CODE (expression
) == ALIGNOF_EXPR
24251 || TREE_CODE (expression
) == AT_ENCODE_EXPR
24252 || TREE_CODE (expression
) == NOEXCEPT_EXPR
24253 || TREE_CODE (expression
) == TRAIT_EXPR
24254 || TREE_CODE (expression
) == TYPEID_EXPR
24255 || TREE_CODE (expression
) == DELETE_EXPR
24256 || TREE_CODE (expression
) == VEC_DELETE_EXPR
24257 || TREE_CODE (expression
) == THROW_EXPR
24258 || TREE_CODE (expression
) == REQUIRES_EXPR
)
24261 /* The types of these expressions depends only on the type to which
24262 the cast occurs. */
24263 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
24264 || TREE_CODE (expression
) == STATIC_CAST_EXPR
24265 || TREE_CODE (expression
) == CONST_CAST_EXPR
24266 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
24267 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
24268 || TREE_CODE (expression
) == CAST_EXPR
)
24269 return dependent_type_p (TREE_TYPE (expression
));
24271 /* The types of these expressions depends only on the type created
24272 by the expression. */
24273 if (TREE_CODE (expression
) == NEW_EXPR
24274 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
24276 /* For NEW_EXPR tree nodes created inside a template, either
24277 the object type itself or a TREE_LIST may appear as the
24279 tree type
= TREE_OPERAND (expression
, 1);
24280 if (TREE_CODE (type
) == TREE_LIST
)
24281 /* This is an array type. We need to check array dimensions
24283 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
24284 || value_dependent_expression_p
24285 (TREE_OPERAND (TREE_VALUE (type
), 1));
24287 return dependent_type_p (type
);
24290 if (TREE_CODE (expression
) == SCOPE_REF
)
24292 tree scope
= TREE_OPERAND (expression
, 0);
24293 tree name
= TREE_OPERAND (expression
, 1);
24295 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
24296 contains an identifier associated by name lookup with one or more
24297 declarations declared with a dependent type, or...a
24298 nested-name-specifier or qualified-id that names a member of an
24299 unknown specialization. */
24300 return (type_dependent_expression_p (name
)
24301 || dependent_scope_p (scope
));
24304 if (TREE_CODE (expression
) == TEMPLATE_DECL
24305 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
24306 return uses_outer_template_parms (expression
);
24308 if (TREE_CODE (expression
) == STMT_EXPR
)
24309 expression
= stmt_expr_value_expr (expression
);
24311 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
24316 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
24318 if (type_dependent_expression_p (elt
))
24324 /* A static data member of the current instantiation with incomplete
24325 array type is type-dependent, as the definition and specializations
24326 can have different bounds. */
24327 if (VAR_P (expression
)
24328 && DECL_CLASS_SCOPE_P (expression
)
24329 && dependent_type_p (DECL_CONTEXT (expression
))
24330 && VAR_HAD_UNKNOWN_BOUND (expression
))
24333 /* An array of unknown bound depending on a variadic parameter, eg:
24335 template<typename... Args>
24336 void foo (Args... args)
24338 int arr[] = { args... };
24341 template<int... vals>
24344 int arr[] = { vals... };
24347 If the array has no length and has an initializer, it must be that
24348 we couldn't determine its length in cp_complete_array_type because
24349 it is dependent. */
24350 if (VAR_P (expression
)
24351 && TREE_TYPE (expression
) != NULL_TREE
24352 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
24353 && !TYPE_DOMAIN (TREE_TYPE (expression
))
24354 && DECL_INITIAL (expression
))
24357 /* A function or variable template-id is type-dependent if it has any
24358 dependent template arguments. */
24359 if (VAR_OR_FUNCTION_DECL_P (expression
)
24360 && DECL_LANG_SPECIFIC (expression
)
24361 && DECL_TEMPLATE_INFO (expression
))
24363 /* Consider the innermost template arguments, since those are the ones
24364 that come from the template-id; the template arguments for the
24365 enclosing class do not make it type-dependent unless they are used in
24366 the type of the decl. */
24367 if (PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (expression
))
24368 && (any_dependent_template_arguments_p
24369 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
24373 /* Otherwise, if the function decl isn't from a dependent scope, it can't be
24374 type-dependent. Checking this is important for functions with auto return
24375 type, which looks like a dependent type. */
24376 if (TREE_CODE (expression
) == FUNCTION_DECL
24377 && !(DECL_CLASS_SCOPE_P (expression
)
24378 && dependent_type_p (DECL_CONTEXT (expression
)))
24379 && !(DECL_FRIEND_P (expression
)
24380 && (!DECL_FRIEND_CONTEXT (expression
)
24381 || dependent_type_p (DECL_FRIEND_CONTEXT (expression
))))
24382 && !DECL_LOCAL_FUNCTION_P (expression
))
24384 gcc_assert (!dependent_type_p (TREE_TYPE (expression
))
24385 || undeduced_auto_decl (expression
));
24389 /* Always dependent, on the number of arguments if nothing else. */
24390 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
24393 if (TREE_TYPE (expression
) == unknown_type_node
)
24395 if (TREE_CODE (expression
) == ADDR_EXPR
)
24396 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
24397 if (TREE_CODE (expression
) == COMPONENT_REF
24398 || TREE_CODE (expression
) == OFFSET_REF
)
24400 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
24402 expression
= TREE_OPERAND (expression
, 1);
24403 if (identifier_p (expression
))
24406 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
24407 if (TREE_CODE (expression
) == SCOPE_REF
)
24410 if (BASELINK_P (expression
))
24412 if (BASELINK_OPTYPE (expression
)
24413 && dependent_type_p (BASELINK_OPTYPE (expression
)))
24415 expression
= BASELINK_FUNCTIONS (expression
);
24418 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
24420 if (any_dependent_template_arguments_p
24421 (TREE_OPERAND (expression
, 1)))
24423 expression
= TREE_OPERAND (expression
, 0);
24424 if (identifier_p (expression
))
24428 gcc_assert (TREE_CODE (expression
) == OVERLOAD
24429 || TREE_CODE (expression
) == FUNCTION_DECL
);
24431 for (lkp_iterator
iter (expression
); iter
; ++iter
)
24432 if (type_dependent_expression_p (*iter
))
24438 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
24440 /* Dependent type attributes might not have made it from the decl to
24442 if (DECL_P (expression
)
24443 && any_dependent_type_attributes_p (DECL_ATTRIBUTES (expression
)))
24446 return (dependent_type_p (TREE_TYPE (expression
)));
24449 /* [temp.dep.expr]/5: A class member access expression (5.2.5) is
24450 type-dependent if the expression refers to a member of the current
24451 instantiation and the type of the referenced member is dependent, or the
24452 class member access expression refers to a member of an unknown
24455 This function returns true if the OBJECT in such a class member access
24456 expression is of an unknown specialization. */
24459 type_dependent_object_expression_p (tree object
)
24461 /* An IDENTIFIER_NODE can sometimes have a TREE_TYPE, but it's still
24463 if (TREE_CODE (object
) == IDENTIFIER_NODE
)
24465 tree scope
= TREE_TYPE (object
);
24466 return (!scope
|| dependent_scope_p (scope
));
24469 /* walk_tree callback function for instantiation_dependent_expression_p,
24470 below. Returns non-zero if a dependent subexpression is found. */
24473 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
24478 /* We don't have to worry about decltype currently because decltype
24479 of an instantiation-dependent expr is a dependent type. This
24480 might change depending on the resolution of DR 1172. */
24481 *walk_subtrees
= false;
24484 enum tree_code code
= TREE_CODE (*tp
);
24487 /* Don't treat an argument list as dependent just because it has no
24493 case TEMPLATE_PARM_INDEX
:
24496 /* Handle expressions with type operands. */
24500 case AT_ENCODE_EXPR
:
24502 tree op
= TREE_OPERAND (*tp
, 0);
24503 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
24504 op
= TREE_TYPE (op
);
24507 if (dependent_type_p (op
))
24511 *walk_subtrees
= false;
24518 case COMPONENT_REF
:
24519 if (identifier_p (TREE_OPERAND (*tp
, 1)))
24520 /* In a template, finish_class_member_access_expr creates a
24521 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
24522 type-dependent, so that we can check access control at
24523 instantiation time (PR 42277). See also Core issue 1273. */
24528 if (instantiation_dependent_scope_ref_p (*tp
))
24533 /* Treat statement-expressions as dependent. */
24537 /* Treat requires-expressions as dependent. */
24538 case REQUIRES_EXPR
:
24542 /* Treat calls to function concepts as dependent. */
24543 if (function_concept_check_p (*tp
))
24547 case TEMPLATE_ID_EXPR
:
24548 /* And variable concepts. */
24549 if (variable_concept_p (TREE_OPERAND (*tp
, 0)))
24557 if (type_dependent_expression_p (*tp
))
24563 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
24564 sense defined by the ABI:
24566 "An expression is instantiation-dependent if it is type-dependent
24567 or value-dependent, or it has a subexpression that is type-dependent
24568 or value-dependent."
24570 Except don't actually check value-dependence for unevaluated expressions,
24571 because in sizeof(i) we don't care about the value of i. Checking
24572 type-dependence will in turn check value-dependence of array bounds/template
24573 arguments as needed. */
24576 instantiation_dependent_uneval_expression_p (tree expression
)
24580 if (!processing_template_decl
)
24583 if (expression
== error_mark_node
)
24586 result
= cp_walk_tree_without_duplicates (&expression
,
24587 instantiation_dependent_r
, NULL
);
24588 return result
!= NULL_TREE
;
24591 /* As above, but also check value-dependence of the expression as a whole. */
24594 instantiation_dependent_expression_p (tree expression
)
24596 return (instantiation_dependent_uneval_expression_p (expression
)
24597 || value_dependent_expression_p (expression
));
24600 /* Like type_dependent_expression_p, but it also works while not processing
24601 a template definition, i.e. during substitution or mangling. */
24604 type_dependent_expression_p_push (tree expr
)
24607 ++processing_template_decl
;
24608 b
= type_dependent_expression_p (expr
);
24609 --processing_template_decl
;
24613 /* Returns TRUE if ARGS contains a type-dependent expression. */
24616 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
24621 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
24623 if (type_dependent_expression_p (arg
))
24629 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
24630 expressions) contains any type-dependent expressions. */
24633 any_type_dependent_elements_p (const_tree list
)
24635 for (; list
; list
= TREE_CHAIN (list
))
24636 if (type_dependent_expression_p (TREE_VALUE (list
)))
24642 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
24643 expressions) contains any value-dependent expressions. */
24646 any_value_dependent_elements_p (const_tree list
)
24648 for (; list
; list
= TREE_CHAIN (list
))
24649 if (value_dependent_expression_p (TREE_VALUE (list
)))
24655 /* Returns TRUE if the ARG (a template argument) is dependent. */
24658 dependent_template_arg_p (tree arg
)
24660 if (!processing_template_decl
)
24663 /* Assume a template argument that was wrongly written by the user
24664 is dependent. This is consistent with what
24665 any_dependent_template_arguments_p [that calls this function]
24667 if (!arg
|| arg
== error_mark_node
)
24670 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
24671 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
24673 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
24675 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
24677 if (DECL_TEMPLATE_PARM_P (arg
))
24679 /* A member template of a dependent class is not necessarily
24680 type-dependent, but it is a dependent template argument because it
24681 will be a member of an unknown specialization to that template. */
24682 tree scope
= CP_DECL_CONTEXT (arg
);
24683 return TYPE_P (scope
) && dependent_type_p (scope
);
24685 else if (ARGUMENT_PACK_P (arg
))
24687 tree args
= ARGUMENT_PACK_ARGS (arg
);
24688 int i
, len
= TREE_VEC_LENGTH (args
);
24689 for (i
= 0; i
< len
; ++i
)
24691 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
24697 else if (TYPE_P (arg
))
24698 return dependent_type_p (arg
);
24700 return (type_dependent_expression_p (arg
)
24701 || value_dependent_expression_p (arg
));
24704 /* Returns true if ARGS (a collection of template arguments) contains
24705 any types that require structural equality testing. */
24708 any_template_arguments_need_structural_equality_p (tree args
)
24715 if (args
== error_mark_node
)
24718 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
24720 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
24721 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
24723 tree arg
= TREE_VEC_ELT (level
, j
);
24724 tree packed_args
= NULL_TREE
;
24727 if (ARGUMENT_PACK_P (arg
))
24729 /* Look inside the argument pack. */
24730 packed_args
= ARGUMENT_PACK_ARGS (arg
);
24731 len
= TREE_VEC_LENGTH (packed_args
);
24734 for (k
= 0; k
< len
; ++k
)
24737 arg
= TREE_VEC_ELT (packed_args
, k
);
24739 if (error_operand_p (arg
))
24741 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
24743 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
24745 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
24746 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
24755 /* Returns true if ARGS (a collection of template arguments) contains
24756 any dependent arguments. */
24759 any_dependent_template_arguments_p (const_tree args
)
24766 if (args
== error_mark_node
)
24769 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
24771 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
24772 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
24773 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
24780 /* Returns TRUE if the template TMPL is type-dependent. */
24783 dependent_template_p (tree tmpl
)
24785 if (TREE_CODE (tmpl
) == OVERLOAD
)
24787 for (lkp_iterator
iter (tmpl
); iter
; ++iter
)
24788 if (dependent_template_p (*iter
))
24793 /* Template template parameters are dependent. */
24794 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
24795 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
24797 /* So are names that have not been looked up. */
24798 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
24803 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
24806 dependent_template_id_p (tree tmpl
, tree args
)
24808 return (dependent_template_p (tmpl
)
24809 || any_dependent_template_arguments_p (args
));
24812 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
24816 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
24820 if (!processing_template_decl
)
24823 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
24825 tree decl
= TREE_VEC_ELT (declv
, i
);
24826 tree init
= TREE_VEC_ELT (initv
, i
);
24827 tree cond
= TREE_VEC_ELT (condv
, i
);
24828 tree incr
= TREE_VEC_ELT (incrv
, i
);
24830 if (type_dependent_expression_p (decl
)
24831 || TREE_CODE (decl
) == SCOPE_REF
)
24834 if (init
&& type_dependent_expression_p (init
))
24837 if (type_dependent_expression_p (cond
))
24840 if (COMPARISON_CLASS_P (cond
)
24841 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
24842 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
24845 if (TREE_CODE (incr
) == MODOP_EXPR
)
24847 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
24848 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
24851 else if (type_dependent_expression_p (incr
))
24853 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
24855 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
24857 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
24859 tree t
= TREE_OPERAND (incr
, 1);
24860 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
24861 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
24870 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
24871 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
24872 no such TYPE can be found. Note that this function peers inside
24873 uninstantiated templates and therefore should be used only in
24874 extremely limited situations. ONLY_CURRENT_P restricts this
24875 peering to the currently open classes hierarchy (which is required
24876 when comparing types). */
24879 resolve_typename_type (tree type
, bool only_current_p
)
24888 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
24890 scope
= TYPE_CONTEXT (type
);
24891 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
24892 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
24893 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
24894 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
24895 identifier of the TYPENAME_TYPE anymore.
24896 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
24897 TYPENAME_TYPE instead, we avoid messing up with a possible
24898 typedef variant case. */
24899 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
24901 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
24902 it first before we can figure out what NAME refers to. */
24903 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
24905 if (TYPENAME_IS_RESOLVING_P (scope
))
24906 /* Given a class template A with a dependent base with nested type C,
24907 typedef typename A::C::C C will land us here, as trying to resolve
24908 the initial A::C leads to the local C typedef, which leads back to
24909 A::C::C. So we break the recursion now. */
24912 scope
= resolve_typename_type (scope
, only_current_p
);
24914 /* If we don't know what SCOPE refers to, then we cannot resolve the
24916 if (!CLASS_TYPE_P (scope
))
24918 /* If this is a typedef, we don't want to look inside (c++/11987). */
24919 if (typedef_variant_p (type
))
24921 /* If SCOPE isn't the template itself, it will not have a valid
24922 TYPE_FIELDS list. */
24923 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
24924 /* scope is either the template itself or a compatible instantiation
24925 like X<T>, so look up the name in the original template. */
24926 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
24927 /* We shouldn't have built a TYPENAME_TYPE with a non-dependent scope. */
24928 gcc_checking_assert (uses_template_parms (scope
));
24929 /* If scope has no fields, it can't be a current instantiation. Check this
24930 before currently_open_class to avoid infinite recursion (71515). */
24931 if (!TYPE_FIELDS (scope
))
24933 /* If the SCOPE is not the current instantiation, there's no reason
24934 to look inside it. */
24935 if (only_current_p
&& !currently_open_class (scope
))
24937 /* Enter the SCOPE so that name lookup will be resolved as if we
24938 were in the class definition. In particular, SCOPE will no
24939 longer be considered a dependent type. */
24940 pushed_scope
= push_scope (scope
);
24941 /* Look up the declaration. */
24942 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
24943 tf_warning_or_error
);
24945 result
= NULL_TREE
;
24947 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
24948 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
24949 tree fullname
= TYPENAME_TYPE_FULLNAME (type
);
24952 else if (identifier_p (fullname
)
24953 && TREE_CODE (decl
) == TYPE_DECL
)
24955 result
= TREE_TYPE (decl
);
24956 if (result
== error_mark_node
)
24957 result
= NULL_TREE
;
24959 else if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
24960 && DECL_CLASS_TEMPLATE_P (decl
))
24962 /* Obtain the template and the arguments. */
24963 tree tmpl
= TREE_OPERAND (fullname
, 0);
24964 if (TREE_CODE (tmpl
) == IDENTIFIER_NODE
)
24966 /* We get here with a plain identifier because a previous tentative
24967 parse of the nested-name-specifier as part of a ptr-operator saw
24968 ::template X<A>. The use of ::template is necessary in a
24969 ptr-operator, but wrong in a declarator-id.
24971 [temp.names]: In a qualified-id of a declarator-id, the keyword
24972 template shall not appear at the top level. */
24973 pedwarn (EXPR_LOC_OR_LOC (fullname
, input_location
), OPT_Wpedantic
,
24974 "keyword %<template%> not allowed in declarator-id");
24977 tree args
= TREE_OPERAND (fullname
, 1);
24978 /* Instantiate the template. */
24979 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
24980 /*entering_scope=*/true,
24981 tf_error
| tf_user
);
24982 if (result
== error_mark_node
)
24983 result
= NULL_TREE
;
24986 /* Leave the SCOPE. */
24988 pop_scope (pushed_scope
);
24990 /* If we failed to resolve it, return the original typename. */
24994 /* If lookup found a typename type, resolve that too. */
24995 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
24997 /* Ill-formed programs can cause infinite recursion here, so we
24998 must catch that. */
24999 TYPENAME_IS_RESOLVING_P (result
) = 1;
25000 result
= resolve_typename_type (result
, only_current_p
);
25001 TYPENAME_IS_RESOLVING_P (result
) = 0;
25004 /* Qualify the resulting type. */
25005 quals
= cp_type_quals (type
);
25007 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
25012 /* EXPR is an expression which is not type-dependent. Return a proxy
25013 for EXPR that can be used to compute the types of larger
25014 expressions containing EXPR. */
25017 build_non_dependent_expr (tree expr
)
25021 /* When checking, try to get a constant value for all non-dependent
25022 expressions in order to expose bugs in *_dependent_expression_p
25023 and constexpr. This can affect code generation, see PR70704, so
25024 only do this for -fchecking=2. */
25025 if (flag_checking
> 1
25026 && cxx_dialect
>= cxx11
25027 /* Don't do this during nsdmi parsing as it can lead to
25028 unexpected recursive instantiations. */
25029 && !parsing_nsdmi ()
25030 /* Don't do this during concept expansion either and for
25031 the same reason. */
25032 && !expanding_concept ())
25033 fold_non_dependent_expr (expr
);
25035 /* Preserve OVERLOADs; the functions must be available to resolve
25038 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
25039 inner_expr
= stmt_expr_value_expr (inner_expr
);
25040 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
25041 inner_expr
= TREE_OPERAND (inner_expr
, 0);
25042 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
25043 inner_expr
= TREE_OPERAND (inner_expr
, 1);
25044 if (is_overloaded_fn (inner_expr
)
25045 || TREE_CODE (inner_expr
) == OFFSET_REF
)
25047 /* There is no need to return a proxy for a variable. */
25050 /* Preserve string constants; conversions from string constants to
25051 "char *" are allowed, even though normally a "const char *"
25052 cannot be used to initialize a "char *". */
25053 if (TREE_CODE (expr
) == STRING_CST
)
25055 /* Preserve void and arithmetic constants, as an optimization -- there is no
25056 reason to create a new node. */
25057 if (TREE_CODE (expr
) == VOID_CST
25058 || TREE_CODE (expr
) == INTEGER_CST
25059 || TREE_CODE (expr
) == REAL_CST
)
25061 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
25062 There is at least one place where we want to know that a
25063 particular expression is a throw-expression: when checking a ?:
25064 expression, there are special rules if the second or third
25065 argument is a throw-expression. */
25066 if (TREE_CODE (expr
) == THROW_EXPR
)
25069 /* Don't wrap an initializer list, we need to be able to look inside. */
25070 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
25073 /* Don't wrap a dummy object, we need to be able to test for it. */
25074 if (is_dummy_object (expr
))
25077 if (TREE_CODE (expr
) == COND_EXPR
)
25078 return build3 (COND_EXPR
,
25080 TREE_OPERAND (expr
, 0),
25081 (TREE_OPERAND (expr
, 1)
25082 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
25083 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
25084 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
25085 if (TREE_CODE (expr
) == COMPOUND_EXPR
25086 && !COMPOUND_EXPR_OVERLOADED (expr
))
25087 return build2 (COMPOUND_EXPR
,
25089 TREE_OPERAND (expr
, 0),
25090 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
25092 /* If the type is unknown, it can't really be non-dependent */
25093 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
25095 /* Otherwise, build a NON_DEPENDENT_EXPR. */
25096 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
25099 /* ARGS is a vector of expressions as arguments to a function call.
25100 Replace the arguments with equivalent non-dependent expressions.
25101 This modifies ARGS in place. */
25104 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
25109 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
25111 tree newarg
= build_non_dependent_expr (arg
);
25113 (*args
)[ix
] = newarg
;
25117 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
25118 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
25119 parms. If set_canonical is true, we set TYPE_CANONICAL on it. */
25122 make_auto_1 (tree name
, bool set_canonical
)
25124 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
25125 TYPE_NAME (au
) = build_decl (input_location
,
25126 TYPE_DECL
, name
, au
);
25127 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
25128 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
25129 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
25130 TYPE_NAME (au
), NULL_TREE
);
25132 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
25133 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
25134 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
25140 make_decltype_auto (void)
25142 return make_auto_1 (decltype_auto_identifier
, true);
25148 return make_auto_1 (auto_identifier
, true);
25151 /* Return a C++17 deduction placeholder for class template TMPL. */
25154 make_template_placeholder (tree tmpl
)
25156 tree t
= make_auto_1 (DECL_NAME (tmpl
), true);
25157 CLASS_PLACEHOLDER_TEMPLATE (t
) = tmpl
;
25161 /* True iff T is a C++17 class template deduction placeholder. */
25164 template_placeholder_p (tree t
)
25166 return is_auto (t
) && CLASS_PLACEHOLDER_TEMPLATE (t
);
25169 /* Make a "constrained auto" type-specifier. This is an
25170 auto type with constraints that must be associated after
25171 deduction. The constraint is formed from the given
25172 CONC and its optional sequence of arguments, which are
25173 non-null if written as partial-concept-id. */
25176 make_constrained_auto (tree con
, tree args
)
25178 tree type
= make_auto_1 (auto_identifier
, false);
25180 /* Build the constraint. */
25181 tree tmpl
= DECL_TI_TEMPLATE (con
);
25182 tree expr
= VAR_P (con
) ? tmpl
: ovl_make (tmpl
);
25183 expr
= build_concept_check (expr
, type
, args
);
25185 tree constr
= normalize_expression (expr
);
25186 PLACEHOLDER_TYPE_CONSTRAINTS (type
) = constr
;
25188 /* Our canonical type depends on the constraint. */
25189 TYPE_CANONICAL (type
) = canonical_type_parameter (type
);
25191 /* Attach the constraint to the type declaration. */
25192 tree decl
= TYPE_NAME (type
);
25196 /* Given type ARG, return std::initializer_list<ARG>. */
25201 tree std_init_list
= get_namespace_binding (std_node
, init_list_identifier
);
25203 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
25205 gcc_rich_location
richloc (input_location
);
25206 maybe_add_include_fixit (&richloc
, "<initializer_list>");
25207 error_at (&richloc
,
25208 "deducing from brace-enclosed initializer list"
25209 " requires %<#include <initializer_list>%>");
25211 return error_mark_node
;
25213 tree argvec
= make_tree_vec (1);
25214 TREE_VEC_ELT (argvec
, 0) = arg
;
25216 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
25217 NULL_TREE
, 0, tf_warning_or_error
);
25220 /* Replace auto in TYPE with std::initializer_list<auto>. */
25223 listify_autos (tree type
, tree auto_node
)
25225 tree init_auto
= listify (auto_node
);
25226 tree argvec
= make_tree_vec (1);
25227 TREE_VEC_ELT (argvec
, 0) = init_auto
;
25228 if (processing_template_decl
)
25229 argvec
= add_to_template_args (current_template_args (), argvec
);
25230 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
25233 /* Hash traits for hashing possibly constrained 'auto'
25234 TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
25236 struct auto_hash
: default_hash_traits
<tree
>
25238 static inline hashval_t
hash (tree
);
25239 static inline bool equal (tree
, tree
);
25242 /* Hash the 'auto' T. */
25245 auto_hash::hash (tree t
)
25247 if (tree c
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
25248 /* Matching constrained-type-specifiers denote the same template
25249 parameter, so hash the constraint. */
25250 return hash_placeholder_constraint (c
);
25252 /* But unconstrained autos are all separate, so just hash the pointer. */
25253 return iterative_hash_object (t
, 0);
25256 /* Compare two 'auto's. */
25259 auto_hash::equal (tree t1
, tree t2
)
25264 tree c1
= PLACEHOLDER_TYPE_CONSTRAINTS (t1
);
25265 tree c2
= PLACEHOLDER_TYPE_CONSTRAINTS (t2
);
25267 /* Two unconstrained autos are distinct. */
25271 return equivalent_placeholder_constraints (c1
, c2
);
25274 /* for_each_template_parm callback for extract_autos: if t is a (possibly
25275 constrained) auto, add it to the vector. */
25278 extract_autos_r (tree t
, void *data
)
25280 hash_table
<auto_hash
> &hash
= *(hash_table
<auto_hash
>*)data
;
25283 /* All the autos were built with index 0; fix that up now. */
25284 tree
*p
= hash
.find_slot (t
, INSERT
);
25287 /* If this is a repeated constrained-type-specifier, use the index we
25289 idx
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (*p
));
25292 /* Otherwise this is new, so use the current count. */
25294 idx
= hash
.elements () - 1;
25296 TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (t
)) = idx
;
25299 /* Always keep walking. */
25303 /* Return a TREE_VEC of the 'auto's used in type under the Concepts TS, which
25304 says they can appear anywhere in the type. */
25307 extract_autos (tree type
)
25309 hash_set
<tree
> visited
;
25310 hash_table
<auto_hash
> hash (2);
25312 for_each_template_parm (type
, extract_autos_r
, &hash
, &visited
, true);
25314 tree tree_vec
= make_tree_vec (hash
.elements());
25315 for (hash_table
<auto_hash
>::iterator iter
= hash
.begin();
25316 iter
!= hash
.end(); ++iter
)
25319 unsigned i
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (elt
));
25320 TREE_VEC_ELT (tree_vec
, i
)
25321 = build_tree_list (NULL_TREE
, TYPE_NAME (elt
));
25327 /* The stem for deduction guide names. */
25328 const char *const dguide_base
= "__dguide_";
25330 /* Return the name for a deduction guide for class template TMPL. */
25333 dguide_name (tree tmpl
)
25335 tree type
= (TYPE_P (tmpl
) ? tmpl
: TREE_TYPE (tmpl
));
25336 tree tname
= TYPE_IDENTIFIER (type
);
25337 char *buf
= (char *) alloca (1 + strlen (dguide_base
)
25338 + IDENTIFIER_LENGTH (tname
));
25339 memcpy (buf
, dguide_base
, strlen (dguide_base
));
25340 memcpy (buf
+ strlen (dguide_base
), IDENTIFIER_POINTER (tname
),
25341 IDENTIFIER_LENGTH (tname
) + 1);
25342 tree dname
= get_identifier (buf
);
25343 TREE_TYPE (dname
) = type
;
25347 /* True if NAME is the name of a deduction guide. */
25350 dguide_name_p (tree name
)
25352 return (TREE_TYPE (name
)
25353 && !strncmp (IDENTIFIER_POINTER (name
), dguide_base
,
25354 strlen (dguide_base
)));
25357 /* True if FN is a deduction guide. */
25360 deduction_guide_p (const_tree fn
)
25363 if (tree name
= DECL_NAME (fn
))
25364 return dguide_name_p (name
);
25368 /* True if FN is the copy deduction guide, i.e. A(A)->A. */
25371 copy_guide_p (const_tree fn
)
25373 gcc_assert (deduction_guide_p (fn
));
25374 if (!DECL_ARTIFICIAL (fn
))
25376 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (DECL_TI_TEMPLATE (fn
));
25377 return (TREE_CHAIN (parms
) == void_list_node
25378 && same_type_p (TREE_VALUE (parms
), TREE_TYPE (DECL_NAME (fn
))));
25381 /* True if FN is a guide generated from a constructor template. */
25384 template_guide_p (const_tree fn
)
25386 gcc_assert (deduction_guide_p (fn
));
25387 if (!DECL_ARTIFICIAL (fn
))
25389 tree tmpl
= DECL_TI_TEMPLATE (fn
);
25390 if (tree org
= DECL_ABSTRACT_ORIGIN (tmpl
))
25391 return PRIMARY_TEMPLATE_P (org
);
25395 /* OLDDECL is a _DECL for a template parameter. Return a similar parameter at
25396 LEVEL:INDEX, using tsubst_args and complain for substitution into non-type
25397 template parameter types. Note that the handling of template template
25398 parameters relies on current_template_parms being set appropriately for the
25402 rewrite_template_parm (tree olddecl
, unsigned index
, unsigned level
,
25403 tree tsubst_args
, tsubst_flags_t complain
)
25405 tree oldidx
= get_template_parm_index (olddecl
);
25408 if (TREE_CODE (olddecl
) == TYPE_DECL
25409 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
25411 tree oldtype
= TREE_TYPE (olddecl
);
25412 newtype
= cxx_make_type (TREE_CODE (oldtype
));
25413 TYPE_MAIN_VARIANT (newtype
) = newtype
;
25414 if (TREE_CODE (oldtype
) == TEMPLATE_TYPE_PARM
)
25415 TEMPLATE_TYPE_PARM_FOR_CLASS (newtype
)
25416 = TEMPLATE_TYPE_PARM_FOR_CLASS (oldtype
);
25419 newtype
= tsubst (TREE_TYPE (olddecl
), tsubst_args
,
25420 complain
, NULL_TREE
);
25423 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TREE_CODE (olddecl
),
25424 DECL_NAME (olddecl
), newtype
);
25425 SET_DECL_TEMPLATE_PARM_P (newdecl
);
25428 if (TREE_CODE (olddecl
) == TYPE_DECL
25429 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
25431 newidx
= TEMPLATE_TYPE_PARM_INDEX (newtype
)
25432 = build_template_parm_index (index
, level
, level
,
25434 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
25435 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
25436 TYPE_STUB_DECL (newtype
) = TYPE_NAME (newtype
) = newdecl
;
25437 TYPE_CANONICAL (newtype
) = canonical_type_parameter (newtype
);
25439 if (TREE_CODE (olddecl
) == TEMPLATE_DECL
)
25441 DECL_TEMPLATE_RESULT (newdecl
)
25442 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TYPE_DECL
,
25443 DECL_NAME (olddecl
), newtype
);
25444 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (newdecl
)) = true;
25445 // First create a copy (ttargs) of tsubst_args with an
25446 // additional level for the template template parameter's own
25447 // template parameters (ttparms).
25448 tree ttparms
= (INNERMOST_TEMPLATE_PARMS
25449 (DECL_TEMPLATE_PARMS (olddecl
)));
25450 const int depth
= TMPL_ARGS_DEPTH (tsubst_args
);
25451 tree ttargs
= make_tree_vec (depth
+ 1);
25452 for (int i
= 0; i
< depth
; ++i
)
25453 TREE_VEC_ELT (ttargs
, i
) = TREE_VEC_ELT (tsubst_args
, i
);
25454 TREE_VEC_ELT (ttargs
, depth
)
25455 = template_parms_level_to_args (ttparms
);
25456 // Substitute ttargs into ttparms to fix references to
25457 // other template parameters.
25458 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
25460 // Now substitute again with args based on tparms, to reduce
25461 // the level of the ttparms.
25462 ttargs
= current_template_args ();
25463 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
25465 // Finally, tack the adjusted parms onto tparms.
25466 ttparms
= tree_cons (size_int (depth
), ttparms
,
25467 current_template_parms
);
25468 DECL_TEMPLATE_PARMS (newdecl
) = ttparms
;
25473 tree oldconst
= TEMPLATE_PARM_DECL (oldidx
);
25475 = build_decl (DECL_SOURCE_LOCATION (oldconst
),
25476 TREE_CODE (oldconst
),
25477 DECL_NAME (oldconst
), newtype
);
25478 TREE_CONSTANT (newconst
) = TREE_CONSTANT (newdecl
)
25479 = TREE_READONLY (newconst
) = TREE_READONLY (newdecl
) = true;
25480 SET_DECL_TEMPLATE_PARM_P (newconst
);
25481 newidx
= build_template_parm_index (index
, level
, level
,
25482 newconst
, newtype
);
25483 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
25484 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
25485 DECL_INITIAL (newdecl
) = DECL_INITIAL (newconst
) = newidx
;
25491 /* Returns a C++17 class deduction guide template based on the constructor
25492 CTOR. As a special case, CTOR can be a RECORD_TYPE for an implicit default
25493 guide, or REFERENCE_TYPE for an implicit copy/move guide. */
25496 build_deduction_guide (tree ctor
, tree outer_args
, tsubst_flags_t complain
)
25498 tree type
, tparms
, targs
, fparms
, fargs
, ci
;
25499 bool memtmpl
= false;
25502 tree fn_tmpl
= NULL_TREE
;
25507 bool copy_p
= TREE_CODE (type
) == REFERENCE_TYPE
;
25510 type
= TREE_TYPE (type
);
25511 fparms
= tree_cons (NULL_TREE
, type
, void_list_node
);
25514 fparms
= void_list_node
;
25516 tree ctmpl
= CLASSTYPE_TI_TEMPLATE (type
);
25517 tparms
= DECL_TEMPLATE_PARMS (ctmpl
);
25518 targs
= CLASSTYPE_TI_ARGS (type
);
25521 loc
= DECL_SOURCE_LOCATION (ctmpl
);
25522 explicit_p
= false;
25526 ++processing_template_decl
;
25529 = (TREE_CODE (ctor
) == TEMPLATE_DECL
? ctor
25530 : DECL_TI_TEMPLATE (ctor
));
25532 fn_tmpl
= tsubst (fn_tmpl
, outer_args
, complain
, ctor
);
25533 ctor
= DECL_TEMPLATE_RESULT (fn_tmpl
);
25535 type
= DECL_CONTEXT (ctor
);
25537 tparms
= DECL_TEMPLATE_PARMS (fn_tmpl
);
25538 /* If type is a member class template, DECL_TI_ARGS (ctor) will have
25539 fully specialized args for the enclosing class. Strip those off, as
25540 the deduction guide won't have those template parameters. */
25541 targs
= get_innermost_template_args (DECL_TI_ARGS (ctor
),
25542 TMPL_PARMS_DEPTH (tparms
));
25543 /* Discard the 'this' parameter. */
25544 fparms
= FUNCTION_ARG_CHAIN (ctor
);
25545 fargs
= TREE_CHAIN (DECL_ARGUMENTS (ctor
));
25546 ci
= get_constraints (ctor
);
25547 loc
= DECL_SOURCE_LOCATION (ctor
);
25548 explicit_p
= DECL_NONCONVERTING_P (ctor
);
25550 if (PRIMARY_TEMPLATE_P (fn_tmpl
))
25554 /* For a member template constructor, we need to flatten the two
25555 template parameter lists into one, and then adjust the function
25556 signature accordingly. This gets...complicated. */
25557 tree save_parms
= current_template_parms
;
25559 /* For a member template we should have two levels of parms/args, one
25560 for the class and one for the constructor. We stripped
25561 specialized args for further enclosing classes above. */
25562 const int depth
= 2;
25563 gcc_assert (TMPL_ARGS_DEPTH (targs
) == depth
);
25565 /* Template args for translating references to the two-level template
25566 parameters into references to the one-level template parameters we
25568 tree tsubst_args
= copy_node (targs
);
25569 TMPL_ARGS_LEVEL (tsubst_args
, depth
)
25570 = copy_node (TMPL_ARGS_LEVEL (tsubst_args
, depth
));
25572 /* Template parms for the constructor template. */
25573 tree ftparms
= TREE_VALUE (tparms
);
25574 unsigned flen
= TREE_VEC_LENGTH (ftparms
);
25575 /* Template parms for the class template. */
25576 tparms
= TREE_CHAIN (tparms
);
25577 tree ctparms
= TREE_VALUE (tparms
);
25578 unsigned clen
= TREE_VEC_LENGTH (ctparms
);
25579 /* Template parms for the deduction guide start as a copy of the
25580 template parms for the class. We set current_template_parms for
25581 lookup_template_class_1. */
25582 current_template_parms
= tparms
= copy_node (tparms
);
25583 tree new_vec
= TREE_VALUE (tparms
) = make_tree_vec (flen
+ clen
);
25584 for (unsigned i
= 0; i
< clen
; ++i
)
25585 TREE_VEC_ELT (new_vec
, i
) = TREE_VEC_ELT (ctparms
, i
);
25587 /* Now we need to rewrite the constructor parms to append them to the
25589 for (unsigned i
= 0; i
< flen
; ++i
)
25591 unsigned index
= i
+ clen
;
25592 unsigned level
= 1;
25593 tree oldelt
= TREE_VEC_ELT (ftparms
, i
);
25594 tree olddecl
= TREE_VALUE (oldelt
);
25595 tree newdecl
= rewrite_template_parm (olddecl
, index
, level
,
25596 tsubst_args
, complain
);
25597 tree newdef
= tsubst_template_arg (TREE_PURPOSE (oldelt
),
25598 tsubst_args
, complain
, ctor
);
25599 tree list
= build_tree_list (newdef
, newdecl
);
25600 TEMPLATE_PARM_CONSTRAINTS (list
)
25601 = tsubst_constraint_info (TEMPLATE_PARM_CONSTRAINTS (oldelt
),
25602 tsubst_args
, complain
, ctor
);
25603 TREE_VEC_ELT (new_vec
, index
) = list
;
25604 TMPL_ARG (tsubst_args
, depth
, i
) = template_parm_to_arg (list
);
25607 /* Now we have a final set of template parms to substitute into the
25608 function signature. */
25609 targs
= template_parms_to_args (tparms
);
25610 fparms
= tsubst_arg_types (fparms
, tsubst_args
, NULL_TREE
,
25612 fargs
= tsubst (fargs
, tsubst_args
, complain
, ctor
);
25614 ci
= tsubst_constraint_info (ci
, tsubst_args
, complain
, ctor
);
25616 current_template_parms
= save_parms
;
25618 --processing_template_decl
;
25623 /* Copy the parms so we can set DECL_PRIMARY_TEMPLATE. */
25624 tparms
= copy_node (tparms
);
25625 INNERMOST_TEMPLATE_PARMS (tparms
)
25626 = copy_node (INNERMOST_TEMPLATE_PARMS (tparms
));
25629 tree fntype
= build_function_type (type
, fparms
);
25630 tree ded_fn
= build_lang_decl_loc (loc
,
25632 dguide_name (type
), fntype
);
25633 DECL_ARGUMENTS (ded_fn
) = fargs
;
25634 DECL_ARTIFICIAL (ded_fn
) = true;
25635 DECL_NONCONVERTING_P (ded_fn
) = explicit_p
;
25636 tree ded_tmpl
= build_template_decl (ded_fn
, tparms
, /*member*/false);
25637 DECL_ARTIFICIAL (ded_tmpl
) = true;
25638 DECL_TEMPLATE_RESULT (ded_tmpl
) = ded_fn
;
25639 TREE_TYPE (ded_tmpl
) = TREE_TYPE (ded_fn
);
25640 DECL_TEMPLATE_INFO (ded_fn
) = build_template_info (ded_tmpl
, targs
);
25641 DECL_PRIMARY_TEMPLATE (ded_tmpl
) = ded_tmpl
;
25643 DECL_ABSTRACT_ORIGIN (ded_tmpl
) = fn_tmpl
;
25645 set_constraints (ded_tmpl
, ci
);
25650 /* Deduce template arguments for the class template placeholder PTYPE for
25651 template TMPL based on the initializer INIT, and return the resulting
25655 do_class_deduction (tree ptype
, tree tmpl
, tree init
, int flags
,
25656 tsubst_flags_t complain
)
25658 if (!DECL_CLASS_TEMPLATE_P (tmpl
))
25660 /* We should have handled this in the caller. */
25661 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
))
25663 if (complain
& tf_error
)
25664 error ("non-class template %qT used without template arguments", tmpl
);
25665 return error_mark_node
;
25668 tree type
= TREE_TYPE (tmpl
);
25670 bool try_list_ctor
= false;
25672 vec
<tree
,va_gc
> *args
;
25673 if (init
== NULL_TREE
25674 || TREE_CODE (init
) == TREE_LIST
)
25675 args
= make_tree_vector_from_list (init
);
25676 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
25678 try_list_ctor
= TYPE_HAS_LIST_CTOR (type
);
25679 if (try_list_ctor
&& CONSTRUCTOR_NELTS (init
) == 1)
25681 /* As an exception, the first phase in 16.3.1.7 (considering the
25682 initializer list as a single argument) is omitted if the
25683 initializer list consists of a single expression of type cv U,
25684 where U is a specialization of C or a class derived from a
25685 specialization of C. */
25686 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
25687 tree etype
= TREE_TYPE (elt
);
25689 tree tparms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
25690 tree targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
25691 int err
= unify (tparms
, targs
, type
, etype
,
25692 UNIFY_ALLOW_DERIVED
, /*explain*/false);
25694 try_list_ctor
= false;
25697 if (try_list_ctor
|| is_std_init_list (type
))
25698 args
= make_tree_vector_single (init
);
25700 args
= make_tree_vector_from_ctor (init
);
25703 args
= make_tree_vector_single (init
);
25705 tree dname
= dguide_name (tmpl
);
25706 tree cands
= lookup_qualified_name (CP_DECL_CONTEXT (tmpl
), dname
,
25707 /*type*/false, /*complain*/false,
25709 bool elided
= false;
25710 if (cands
== error_mark_node
)
25713 /* Prune explicit deduction guides in copy-initialization context. */
25714 if (flags
& LOOKUP_ONLYCONVERTING
)
25716 for (lkp_iterator
iter (cands
); !elided
&& iter
; ++iter
)
25717 if (DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
25722 /* Found a nonconverting guide, prune the candidates. */
25723 tree pruned
= NULL_TREE
;
25724 for (lkp_iterator
iter (cands
); iter
; ++iter
)
25725 if (!DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
25726 pruned
= lookup_add (*iter
, pruned
);
25732 tree outer_args
= NULL_TREE
;
25733 if (DECL_CLASS_SCOPE_P (tmpl
)
25734 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (tmpl
)))
25736 outer_args
= CLASSTYPE_TI_ARGS (DECL_CONTEXT (tmpl
));
25737 type
= TREE_TYPE (most_general_template (tmpl
));
25740 bool saw_ctor
= false;
25741 // FIXME cache artificial deduction guides
25742 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (type
)); iter
; ++iter
)
25744 tree guide
= build_deduction_guide (*iter
, outer_args
, complain
);
25745 if ((flags
& LOOKUP_ONLYCONVERTING
)
25746 && DECL_NONCONVERTING_P (STRIP_TEMPLATE (guide
)))
25749 cands
= lookup_add (guide
, cands
);
25754 tree call
= error_mark_node
;
25756 /* If this is list-initialization and the class has a list constructor, first
25757 try deducing from the list as a single argument, as [over.match.list]. */
25758 tree list_cands
= NULL_TREE
;
25759 if (try_list_ctor
&& cands
)
25760 for (lkp_iterator
iter (cands
); iter
; ++iter
)
25763 if (is_list_ctor (dg
))
25764 list_cands
= lookup_add (dg
, list_cands
);
25768 ++cp_unevaluated_operand
;
25769 call
= build_new_function_call (list_cands
, &args
, tf_decltype
);
25770 --cp_unevaluated_operand
;
25772 if (call
== error_mark_node
)
25774 /* That didn't work, now try treating the list as a sequence of
25776 release_tree_vector (args
);
25777 args
= make_tree_vector_from_ctor (init
);
25781 /* Maybe generate an implicit deduction guide. */
25782 if (call
== error_mark_node
&& args
->length () < 2)
25784 tree gtype
= NULL_TREE
;
25786 if (args
->length () == 1)
25787 /* Generate a copy guide. */
25788 gtype
= build_reference_type (type
);
25789 else if (!saw_ctor
)
25790 /* Generate a default guide. */
25795 tree guide
= build_deduction_guide (gtype
, outer_args
, complain
);
25796 cands
= lookup_add (guide
, cands
);
25800 if (elided
&& !cands
)
25802 error ("cannot deduce template arguments for copy-initialization"
25803 " of %qT, as it has no non-explicit deduction guides or "
25804 "user-declared constructors", type
);
25805 return error_mark_node
;
25807 else if (!cands
&& call
== error_mark_node
)
25809 error ("cannot deduce template arguments of %qT, as it has no viable "
25810 "deduction guides", type
);
25811 return error_mark_node
;
25814 if (call
== error_mark_node
)
25816 ++cp_unevaluated_operand
;
25817 call
= build_new_function_call (cands
, &args
, tf_decltype
);
25818 --cp_unevaluated_operand
;
25821 if (call
== error_mark_node
&& (complain
& tf_warning_or_error
))
25823 error ("class template argument deduction failed:");
25825 ++cp_unevaluated_operand
;
25826 call
= build_new_function_call (cands
, &args
, complain
| tf_decltype
);
25827 --cp_unevaluated_operand
;
25830 inform (input_location
, "explicit deduction guides not considered "
25831 "for copy-initialization");
25834 release_tree_vector (args
);
25836 return cp_build_qualified_type (TREE_TYPE (call
), cp_type_quals (ptype
));
25839 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
25840 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
25843 do_auto_deduction (tree type
, tree init
, tree auto_node
)
25845 return do_auto_deduction (type
, init
, auto_node
,
25846 tf_warning_or_error
,
25850 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
25851 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
25852 The CONTEXT determines the context in which auto deduction is performed
25853 and is used to control error diagnostics. FLAGS are the LOOKUP_* flags.
25854 OUTER_TARGS are used during template argument deduction
25855 (context == adc_unify) to properly substitute the result, and is ignored
25858 For partial-concept-ids, extra args may be appended to the list of deduced
25859 template arguments prior to determining constraint satisfaction. */
25862 do_auto_deduction (tree type
, tree init
, tree auto_node
,
25863 tsubst_flags_t complain
, auto_deduction_context context
,
25864 tree outer_targs
, int flags
)
25868 if (init
== error_mark_node
)
25869 return error_mark_node
;
25871 if (init
&& type_dependent_expression_p (init
)
25872 && context
!= adc_unify
)
25873 /* Defining a subset of type-dependent expressions that we can deduce
25874 from ahead of time isn't worth the trouble. */
25877 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
25878 /* C++17 class template argument deduction. */
25879 return do_class_deduction (type
, tmpl
, init
, flags
, complain
);
25881 if (TREE_TYPE (init
) == NULL_TREE
)
25882 /* Nothing we can do with this, even in deduction context. */
25885 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
25886 with either a new invented type template parameter U or, if the
25887 initializer is a braced-init-list (8.5.4), with
25888 std::initializer_list<U>. */
25889 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
25891 if (!DIRECT_LIST_INIT_P (init
))
25892 type
= listify_autos (type
, auto_node
);
25893 else if (CONSTRUCTOR_NELTS (init
) == 1)
25894 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
25897 if (complain
& tf_warning_or_error
)
25899 if (permerror (input_location
, "direct-list-initialization of "
25900 "%<auto%> requires exactly one element"))
25901 inform (input_location
,
25902 "for deduction to %<std::initializer_list%>, use copy-"
25903 "list-initialization (i.e. add %<=%> before the %<{%>)");
25905 type
= listify_autos (type
, auto_node
);
25909 if (type
== error_mark_node
)
25910 return error_mark_node
;
25912 init
= resolve_nondeduced_context (init
, complain
);
25914 if (context
== adc_decomp_type
25915 && auto_node
== type
25916 && init
!= error_mark_node
25917 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
25918 /* [dcl.decomp]/1 - if decomposition declaration has no ref-qualifiers
25919 and initializer has array type, deduce cv-qualified array type. */
25920 return cp_build_qualified_type_real (TREE_TYPE (init
), TYPE_QUALS (type
),
25922 else if (AUTO_IS_DECLTYPE (auto_node
))
25924 bool id
= (DECL_P (init
)
25925 || ((TREE_CODE (init
) == COMPONENT_REF
25926 || TREE_CODE (init
) == SCOPE_REF
)
25927 && !REF_PARENTHESIZED_P (init
)));
25928 targs
= make_tree_vec (1);
25929 TREE_VEC_ELT (targs
, 0)
25930 = finish_decltype_type (init
, id
, tf_warning_or_error
);
25931 if (type
!= auto_node
)
25933 if (complain
& tf_error
)
25934 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
25935 return error_mark_node
;
25940 tree parms
= build_tree_list (NULL_TREE
, type
);
25944 tparms
= extract_autos (type
);
25947 tparms
= make_tree_vec (1);
25948 TREE_VEC_ELT (tparms
, 0)
25949 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
25952 targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
25953 int val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
25954 DEDUCE_CALL
, LOOKUP_NORMAL
,
25955 NULL
, /*explain_p=*/false);
25958 if (processing_template_decl
)
25959 /* Try again at instantiation time. */
25961 if (type
&& type
!= error_mark_node
25962 && (complain
& tf_error
))
25963 /* If type is error_mark_node a diagnostic must have been
25964 emitted by now. Also, having a mention to '<type error>'
25965 in the diagnostic is not really useful to the user. */
25967 if (cfun
&& auto_node
== current_function_auto_return_pattern
25968 && LAMBDA_FUNCTION_P (current_function_decl
))
25969 error ("unable to deduce lambda return type from %qE", init
);
25971 error ("unable to deduce %qT from %qE", type
, init
);
25972 type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
25973 DEDUCE_CALL
, LOOKUP_NORMAL
,
25974 NULL
, /*explain_p=*/true);
25976 return error_mark_node
;
25980 /* Check any placeholder constraints against the deduced type. */
25981 if (flag_concepts
&& !processing_template_decl
)
25982 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (auto_node
))
25984 /* Use the deduced type to check the associated constraints. If we
25985 have a partial-concept-id, rebuild the argument list so that
25986 we check using the extra arguments. */
25987 gcc_assert (TREE_CODE (constr
) == CHECK_CONSTR
);
25988 tree cargs
= CHECK_CONSTR_ARGS (constr
);
25989 if (TREE_VEC_LENGTH (cargs
) > 1)
25991 cargs
= copy_node (cargs
);
25992 TREE_VEC_ELT (cargs
, 0) = TREE_VEC_ELT (targs
, 0);
25996 if (!constraints_satisfied_p (constr
, cargs
))
25998 if (complain
& tf_warning_or_error
)
26002 case adc_unspecified
:
26004 error("placeholder constraints not satisfied");
26006 case adc_variable_type
:
26007 case adc_decomp_type
:
26008 error ("deduced initializer does not satisfy "
26009 "placeholder constraints");
26011 case adc_return_type
:
26012 error ("deduced return type does not satisfy "
26013 "placeholder constraints");
26015 case adc_requirement
:
26016 error ("deduced expression type does not satisfy "
26017 "placeholder constraints");
26020 diagnose_constraints (input_location
, constr
, targs
);
26022 return error_mark_node
;
26026 if (processing_template_decl
&& context
!= adc_unify
)
26027 outer_targs
= current_template_args ();
26028 targs
= add_to_template_args (outer_targs
, targs
);
26029 return tsubst (type
, targs
, complain
, NULL_TREE
);
26032 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
26036 splice_late_return_type (tree type
, tree late_return_type
)
26038 if (is_auto (type
))
26040 if (late_return_type
)
26041 return late_return_type
;
26043 tree idx
= get_template_parm_index (type
);
26044 if (TEMPLATE_PARM_LEVEL (idx
) <= processing_template_decl
)
26045 /* In an abbreviated function template we didn't know we were dealing
26046 with a function template when we saw the auto return type, so update
26047 it to have the correct level. */
26048 return make_auto_1 (TYPE_IDENTIFIER (type
), true);
26053 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
26054 'decltype(auto)' or a deduced class template. */
26057 is_auto (const_tree type
)
26059 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
26060 && (TYPE_IDENTIFIER (type
) == auto_identifier
26061 || TYPE_IDENTIFIER (type
) == decltype_auto_identifier
26062 || CLASS_PLACEHOLDER_TEMPLATE (type
)))
26068 /* for_each_template_parm callback for type_uses_auto. */
26071 is_auto_r (tree tp
, void */
*data*/
)
26073 return is_auto (tp
);
26076 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
26077 a use of `auto'. Returns NULL_TREE otherwise. */
26080 type_uses_auto (tree type
)
26082 if (type
== NULL_TREE
)
26084 else if (flag_concepts
)
26086 /* The Concepts TS allows multiple autos in one type-specifier; just
26087 return the first one we find, do_auto_deduction will collect all of
26089 if (uses_template_parms (type
))
26090 return for_each_template_parm (type
, is_auto_r
, /*data*/NULL
,
26091 /*visited*/NULL
, /*nondeduced*/true);
26096 return find_type_usage (type
, is_auto
);
26099 /* For a given template T, return the vector of typedefs referenced
26100 in T for which access check is needed at T instantiation time.
26101 T is either a FUNCTION_DECL or a RECORD_TYPE.
26102 Those typedefs were added to T by the function
26103 append_type_to_template_for_access_check. */
26105 vec
<qualified_typedef_usage_t
, va_gc
> *
26106 get_types_needing_access_check (tree t
)
26109 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
26111 if (!t
|| t
== error_mark_node
)
26114 if (!(ti
= get_template_info (t
)))
26117 if (CLASS_TYPE_P (t
)
26118 || TREE_CODE (t
) == FUNCTION_DECL
)
26120 if (!TI_TEMPLATE (ti
))
26123 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
26129 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
26130 tied to T. That list of typedefs will be access checked at
26131 T instantiation time.
26132 T is either a FUNCTION_DECL or a RECORD_TYPE.
26133 TYPE_DECL is a TYPE_DECL node representing a typedef.
26134 SCOPE is the scope through which TYPE_DECL is accessed.
26135 LOCATION is the location of the usage point of TYPE_DECL.
26137 This function is a subroutine of
26138 append_type_to_template_for_access_check. */
26141 append_type_to_template_for_access_check_1 (tree t
,
26144 location_t location
)
26146 qualified_typedef_usage_t typedef_usage
;
26149 if (!t
|| t
== error_mark_node
)
26152 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
26153 || CLASS_TYPE_P (t
))
26155 && TREE_CODE (type_decl
) == TYPE_DECL
26158 if (!(ti
= get_template_info (t
)))
26161 gcc_assert (TI_TEMPLATE (ti
));
26163 typedef_usage
.typedef_decl
= type_decl
;
26164 typedef_usage
.context
= scope
;
26165 typedef_usage
.locus
= location
;
26167 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
26170 /* Append TYPE_DECL to the template TEMPL.
26171 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
26172 At TEMPL instanciation time, TYPE_DECL will be checked to see
26173 if it can be accessed through SCOPE.
26174 LOCATION is the location of the usage point of TYPE_DECL.
26176 e.g. consider the following code snippet:
26183 template<class U> struct S
26185 C::myint mi; // <-- usage point of the typedef C::myint
26190 At S<char> instantiation time, we need to check the access of C::myint
26191 In other words, we need to check the access of the myint typedef through
26192 the C scope. For that purpose, this function will add the myint typedef
26193 and the scope C through which its being accessed to a list of typedefs
26194 tied to the template S. That list will be walked at template instantiation
26195 time and access check performed on each typedefs it contains.
26196 Note that this particular code snippet should yield an error because
26197 myint is private to C. */
26200 append_type_to_template_for_access_check (tree templ
,
26203 location_t location
)
26205 qualified_typedef_usage_t
*iter
;
26208 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
26210 /* Make sure we don't append the type to the template twice. */
26211 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
26212 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
26215 append_type_to_template_for_access_check_1 (templ
, type_decl
,
26219 /* Convert the generic type parameters in PARM that match the types given in the
26220 range [START_IDX, END_IDX) from the current_template_parms into generic type
26224 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
26226 tree current
= current_template_parms
;
26227 int depth
= TMPL_PARMS_DEPTH (current
);
26228 current
= INNERMOST_TEMPLATE_PARMS (current
);
26229 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
26231 for (int i
= 0; i
< start_idx
; ++i
)
26232 TREE_VEC_ELT (replacement
, i
)
26233 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
26235 for (int i
= start_idx
; i
< end_idx
; ++i
)
26237 /* Create a distinct parameter pack type from the current parm and add it
26238 to the replacement args to tsubst below into the generic function
26241 tree o
= TREE_TYPE (TREE_VALUE
26242 (TREE_VEC_ELT (current
, i
)));
26243 tree t
= copy_type (o
);
26244 TEMPLATE_TYPE_PARM_INDEX (t
)
26245 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
26247 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
26248 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
26249 TYPE_MAIN_VARIANT (t
) = t
;
26250 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
26251 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
26252 TREE_VEC_ELT (replacement
, i
) = t
;
26253 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
26256 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
26257 TREE_VEC_ELT (replacement
, i
)
26258 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
26260 /* If there are more levels then build up the replacement with the outer
26263 replacement
= add_to_template_args (template_parms_to_args
26264 (TREE_CHAIN (current_template_parms
)),
26267 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
26270 /* Entries in the decl_constraint hash table. */
26271 struct GTY((for_user
)) constr_entry
26277 /* Hashing function and equality for constraint entries. */
26278 struct constr_hasher
: ggc_ptr_hash
<constr_entry
>
26280 static hashval_t
hash (constr_entry
*e
)
26282 return (hashval_t
)DECL_UID (e
->decl
);
26285 static bool equal (constr_entry
*e1
, constr_entry
*e2
)
26287 return e1
->decl
== e2
->decl
;
26291 /* A mapping from declarations to constraint information. Note that
26292 both templates and their underlying declarations are mapped to the
26293 same constraint information.
26295 FIXME: This is defined in pt.c because garbage collection
26296 code is not being generated for constraint.cc. */
26298 static GTY (()) hash_table
<constr_hasher
> *decl_constraints
;
26300 /* Returns the template constraints of declaration T. If T is not
26301 constrained, return NULL_TREE. Note that T must be non-null. */
26304 get_constraints (tree t
)
26306 if (!flag_concepts
)
26309 gcc_assert (DECL_P (t
));
26310 if (TREE_CODE (t
) == TEMPLATE_DECL
)
26311 t
= DECL_TEMPLATE_RESULT (t
);
26312 constr_entry elt
= { t
, NULL_TREE
};
26313 constr_entry
* found
= decl_constraints
->find (&elt
);
26320 /* Associate the given constraint information CI with the declaration
26321 T. If T is a template, then the constraints are associated with
26322 its underlying declaration. Don't build associations if CI is
26326 set_constraints (tree t
, tree ci
)
26330 gcc_assert (t
&& flag_concepts
);
26331 if (TREE_CODE (t
) == TEMPLATE_DECL
)
26332 t
= DECL_TEMPLATE_RESULT (t
);
26333 gcc_assert (!get_constraints (t
));
26334 constr_entry elt
= {t
, ci
};
26335 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, INSERT
);
26336 constr_entry
* entry
= ggc_alloc
<constr_entry
> ();
26341 /* Remove the associated constraints of the declaration T. */
26344 remove_constraints (tree t
)
26346 gcc_assert (DECL_P (t
));
26347 if (TREE_CODE (t
) == TEMPLATE_DECL
)
26348 t
= DECL_TEMPLATE_RESULT (t
);
26350 constr_entry elt
= {t
, NULL_TREE
};
26351 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, NO_INSERT
);
26353 decl_constraints
->clear_slot (slot
);
26356 /* Memoized satisfaction results for declarations. This
26357 maps the pair (constraint_info, arguments) to the result computed
26358 by constraints_satisfied_p. */
26360 struct GTY((for_user
)) constraint_sat_entry
26367 /* Hashing function and equality for constraint entries. */
26369 struct constraint_sat_hasher
: ggc_ptr_hash
<constraint_sat_entry
>
26371 static hashval_t
hash (constraint_sat_entry
*e
)
26373 hashval_t val
= iterative_hash_object(e
->ci
, 0);
26374 return iterative_hash_template_arg (e
->args
, val
);
26377 static bool equal (constraint_sat_entry
*e1
, constraint_sat_entry
*e2
)
26379 return e1
->ci
== e2
->ci
&& comp_template_args (e1
->args
, e2
->args
);
26383 /* Memoized satisfaction results for concept checks. */
26385 struct GTY((for_user
)) concept_spec_entry
26392 /* Hashing function and equality for constraint entries. */
26394 struct concept_spec_hasher
: ggc_ptr_hash
<concept_spec_entry
>
26396 static hashval_t
hash (concept_spec_entry
*e
)
26398 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
26401 static bool equal (concept_spec_entry
*e1
, concept_spec_entry
*e2
)
26403 ++comparing_specializations
;
26404 bool eq
= e1
->tmpl
== e2
->tmpl
&& comp_template_args (e1
->args
, e2
->args
);
26405 --comparing_specializations
;
26410 static GTY (()) hash_table
<constraint_sat_hasher
> *constraint_memos
;
26411 static GTY (()) hash_table
<concept_spec_hasher
> *concept_memos
;
26413 /* Search for a memoized satisfaction result. Returns one of the
26414 truth value nodes if previously memoized, or NULL_TREE otherwise. */
26417 lookup_constraint_satisfaction (tree ci
, tree args
)
26419 constraint_sat_entry elt
= { ci
, args
, NULL_TREE
};
26420 constraint_sat_entry
* found
= constraint_memos
->find (&elt
);
26422 return found
->result
;
26427 /* Memoize the result of a satisfication test. Returns the saved result. */
26430 memoize_constraint_satisfaction (tree ci
, tree args
, tree result
)
26432 constraint_sat_entry elt
= {ci
, args
, result
};
26433 constraint_sat_entry
** slot
= constraint_memos
->find_slot (&elt
, INSERT
);
26434 constraint_sat_entry
* entry
= ggc_alloc
<constraint_sat_entry
> ();
26440 /* Search for a memoized satisfaction result for a concept. */
26443 lookup_concept_satisfaction (tree tmpl
, tree args
)
26445 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
26446 concept_spec_entry
* found
= concept_memos
->find (&elt
);
26448 return found
->result
;
26453 /* Memoize the result of a concept check. Returns the saved result. */
26456 memoize_concept_satisfaction (tree tmpl
, tree args
, tree result
)
26458 concept_spec_entry elt
= {tmpl
, args
, result
};
26459 concept_spec_entry
** slot
= concept_memos
->find_slot (&elt
, INSERT
);
26460 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
26466 static GTY (()) hash_table
<concept_spec_hasher
> *concept_expansions
;
26468 /* Returns a prior concept specialization. This returns the substituted
26469 and normalized constraints defined by the concept. */
26472 get_concept_expansion (tree tmpl
, tree args
)
26474 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
26475 concept_spec_entry
* found
= concept_expansions
->find (&elt
);
26477 return found
->result
;
26482 /* Save a concept expansion for later. */
26485 save_concept_expansion (tree tmpl
, tree args
, tree def
)
26487 concept_spec_entry elt
= {tmpl
, args
, def
};
26488 concept_spec_entry
** slot
= concept_expansions
->find_slot (&elt
, INSERT
);
26489 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
26496 hash_subsumption_args (tree t1
, tree t2
)
26498 gcc_assert (TREE_CODE (t1
) == CHECK_CONSTR
);
26499 gcc_assert (TREE_CODE (t2
) == CHECK_CONSTR
);
26501 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t1
), val
);
26502 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t1
), val
);
26503 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t2
), val
);
26504 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t2
), val
);
26508 /* Compare the constraints of two subsumption entries. The LEFT1 and
26509 LEFT2 arguments comprise the first subsumption pair and the RIGHT1
26510 and RIGHT2 arguments comprise the second. These are all CHECK_CONSTRs. */
26513 comp_subsumption_args (tree left1
, tree left2
, tree right1
, tree right2
)
26515 if (CHECK_CONSTR_CONCEPT (left1
) == CHECK_CONSTR_CONCEPT (right1
))
26516 if (CHECK_CONSTR_CONCEPT (left2
) == CHECK_CONSTR_CONCEPT (right2
))
26517 if (comp_template_args (CHECK_CONSTR_ARGS (left1
),
26518 CHECK_CONSTR_ARGS (right1
)))
26519 return comp_template_args (CHECK_CONSTR_ARGS (left2
),
26520 CHECK_CONSTR_ARGS (right2
));
26524 /* Key/value pair for learning and memoizing subsumption results. This
26525 associates a pair of check constraints (including arguments) with
26526 a boolean value indicating the result. */
26528 struct GTY((for_user
)) subsumption_entry
26535 /* Hashing function and equality for constraint entries. */
26537 struct subsumption_hasher
: ggc_ptr_hash
<subsumption_entry
>
26539 static hashval_t
hash (subsumption_entry
*e
)
26541 return hash_subsumption_args (e
->t1
, e
->t2
);
26544 static bool equal (subsumption_entry
*e1
, subsumption_entry
*e2
)
26546 ++comparing_specializations
;
26547 bool eq
= comp_subsumption_args(e1
->t1
, e1
->t2
, e2
->t1
, e2
->t2
);
26548 --comparing_specializations
;
26553 static GTY (()) hash_table
<subsumption_hasher
> *subsumption_table
;
26555 /* Search for a previously cached subsumption result. */
26558 lookup_subsumption_result (tree t1
, tree t2
)
26560 subsumption_entry elt
= { t1
, t2
, false };
26561 subsumption_entry
* found
= subsumption_table
->find (&elt
);
26563 return &found
->result
;
26568 /* Save a subsumption result. */
26571 save_subsumption_result (tree t1
, tree t2
, bool result
)
26573 subsumption_entry elt
= {t1
, t2
, result
};
26574 subsumption_entry
** slot
= subsumption_table
->find_slot (&elt
, INSERT
);
26575 subsumption_entry
* entry
= ggc_alloc
<subsumption_entry
> ();
26581 /* Set up the hash table for constraint association. */
26584 init_constraint_processing (void)
26586 if (!flag_concepts
)
26589 decl_constraints
= hash_table
<constr_hasher
>::create_ggc(37);
26590 constraint_memos
= hash_table
<constraint_sat_hasher
>::create_ggc(37);
26591 concept_memos
= hash_table
<concept_spec_hasher
>::create_ggc(37);
26592 concept_expansions
= hash_table
<concept_spec_hasher
>::create_ggc(37);
26593 subsumption_table
= hash_table
<subsumption_hasher
>::create_ggc(37);
26596 /* __integer_pack(N) in a pack expansion expands to a sequence of numbers from
26600 declare_integer_pack (void)
26602 tree ipfn
= push_library_fn (get_identifier ("__integer_pack"),
26603 build_function_type_list (integer_type_node
,
26606 NULL_TREE
, ECF_CONST
);
26607 DECL_DECLARED_CONSTEXPR_P (ipfn
) = true;
26608 DECL_BUILT_IN_CLASS (ipfn
) = BUILT_IN_FRONTEND
;
26611 /* Set up the hash tables for template instantiations. */
26614 init_template_processing (void)
26616 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
26617 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
26619 if (cxx_dialect
>= cxx11
)
26620 declare_integer_pack ();
26623 /* Print stats about the template hash tables for -fstats. */
26626 print_template_statistics (void)
26628 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
26629 "%f collisions\n", (long) decl_specializations
->size (),
26630 (long) decl_specializations
->elements (),
26631 decl_specializations
->collisions ());
26632 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
26633 "%f collisions\n", (long) type_specializations
->size (),
26634 (long) type_specializations
->elements (),
26635 type_specializations
->collisions ());
26638 #include "gt-cp-pt.h"