1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2018 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Known bugs or deficiencies include:
24 all methods must be provided in header files; can't use a source
25 file that contains only the method templates and "just win". */
29 #include "coretypes.h"
32 #include "stringpool.h"
35 #include "stor-layout.h"
37 #include "c-family/c-objc.h"
38 #include "cp-objcp-common.h"
40 #include "tree-iterator.h"
41 #include "type-utils.h"
43 #include "gcc-rich-location.h"
46 /* The type of functions taking a tree, and some additional data, and
48 typedef int (*tree_fn_t
) (tree
, void*);
50 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
51 instantiations have been deferred, either because their definitions
52 were not yet available, or because we were putting off doing the work. */
53 struct GTY ((chain_next ("%h.next"))) pending_template
55 struct pending_template
*next
;
56 struct tinst_level
*tinst
;
59 static GTY(()) struct pending_template
*pending_templates
;
60 static GTY(()) struct pending_template
*last_pending_template
;
62 int processing_template_parmlist
;
63 static int template_header_count
;
65 static GTY(()) tree saved_trees
;
66 static vec
<int> inline_parm_levels
;
68 static GTY(()) struct tinst_level
*current_tinst_level
;
70 static GTY(()) tree saved_access_scope
;
72 /* Live only within one (recursive) call to tsubst_expr. We use
73 this to pass the statement expression node from the STMT_EXPR
74 to the EXPR_STMT that is its result. */
75 static tree cur_stmt_expr
;
77 // -------------------------------------------------------------------------- //
78 // Local Specialization Stack
80 // Implementation of the RAII helper for creating new local
82 local_specialization_stack::local_specialization_stack (lss_policy policy
)
83 : saved (local_specializations
)
85 if (policy
== lss_blank
|| !saved
)
86 local_specializations
= new hash_map
<tree
, tree
>;
88 local_specializations
= new hash_map
<tree
, tree
>(*saved
);
91 local_specialization_stack::~local_specialization_stack ()
93 delete local_specializations
;
94 local_specializations
= saved
;
97 /* True if we've recursed into fn_type_unification too many times. */
98 static bool excessive_deduction_depth
;
100 struct GTY((for_user
)) spec_entry
107 struct spec_hasher
: ggc_ptr_hash
<spec_entry
>
109 static hashval_t
hash (spec_entry
*);
110 static bool equal (spec_entry
*, spec_entry
*);
113 static GTY (()) hash_table
<spec_hasher
> *decl_specializations
;
115 static GTY (()) hash_table
<spec_hasher
> *type_specializations
;
117 /* Contains canonical template parameter types. The vector is indexed by
118 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
119 TREE_LIST, whose TREE_VALUEs contain the canonical template
120 parameters of various types and levels. */
121 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
123 #define UNIFY_ALLOW_NONE 0
124 #define UNIFY_ALLOW_MORE_CV_QUAL 1
125 #define UNIFY_ALLOW_LESS_CV_QUAL 2
126 #define UNIFY_ALLOW_DERIVED 4
127 #define UNIFY_ALLOW_INTEGER 8
128 #define UNIFY_ALLOW_OUTER_LEVEL 16
129 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
130 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
132 enum template_base_result
{
134 tbr_ambiguous_baseclass
,
138 static void push_access_scope (tree
);
139 static void pop_access_scope (tree
);
140 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
141 unification_kind_t
, int,
143 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
144 unification_kind_t
, int, bool, bool);
145 static int unify (tree
, tree
, tree
, tree
, int, bool);
146 static void add_pending_template (tree
);
147 static tree
reopen_tinst_level (struct tinst_level
*);
148 static tree
tsubst_initializer_list (tree
, tree
);
149 static tree
get_partial_spec_bindings (tree
, tree
, tree
);
150 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
152 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
154 static void tsubst_enum (tree
, tree
, tree
);
155 static tree
add_to_template_args (tree
, tree
);
156 static tree
add_outermost_template_args (tree
, tree
);
157 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
158 static int check_non_deducible_conversion (tree
, tree
, int, int,
159 struct conversion
**, bool);
160 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
162 static int type_unification_real (tree
, tree
, tree
, const tree
*,
163 unsigned int, int, unification_kind_t
,
164 vec
<deferred_access_check
, va_gc
> **,
166 static void note_template_header (int);
167 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
168 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
169 static tree
convert_template_argument (tree
, tree
, tree
,
170 tsubst_flags_t
, int, tree
);
171 static tree
for_each_template_parm (tree
, tree_fn_t
, void*,
172 hash_set
<tree
> *, bool, tree_fn_t
= NULL
);
173 static tree
expand_template_argument_pack (tree
);
174 static tree
build_template_parm_index (int, int, int, tree
, tree
);
175 static bool inline_needs_template_parms (tree
, bool);
176 static void push_inline_template_parms_recursive (tree
, int);
177 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
178 static int mark_template_parm (tree
, void *);
179 static int template_parm_this_level_p (tree
, void *);
180 static tree
tsubst_friend_function (tree
, tree
);
181 static tree
tsubst_friend_class (tree
, tree
);
182 static int can_complete_type_without_circularity (tree
);
183 static tree
get_bindings (tree
, tree
, tree
, bool);
184 static int template_decl_level (tree
);
185 static int check_cv_quals_for_unify (int, tree
, tree
);
186 static void template_parm_level_and_index (tree
, int*, int*);
187 static int unify_pack_expansion (tree
, tree
, tree
,
188 tree
, unification_kind_t
, bool, bool);
189 static tree
copy_template_args (tree
);
190 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
191 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
192 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
193 static tree
most_specialized_partial_spec (tree
, tsubst_flags_t
);
194 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
195 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
196 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
197 static bool check_specialization_scope (void);
198 static tree
process_partial_specialization (tree
);
199 static void set_current_access_from_decl (tree
);
200 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
202 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
203 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
205 static bool template_template_parm_bindings_ok_p (tree
, tree
);
206 static void tsubst_default_arguments (tree
, tsubst_flags_t
);
207 static tree
for_each_template_parm_r (tree
*, int *, void *);
208 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
209 static void copy_default_args_to_explicit_spec (tree
);
210 static bool invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
211 static bool dependent_template_arg_p (tree
);
212 static bool any_template_arguments_need_structural_equality_p (tree
);
213 static bool dependent_type_p_r (tree
);
214 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
215 static tree
tsubst_decl (tree
, tree
, tsubst_flags_t
);
216 static void perform_typedefs_access_check (tree tmpl
, tree targs
);
217 static void append_type_to_template_for_access_check_1 (tree
, tree
, tree
,
219 static tree
listify (tree
);
220 static tree
listify_autos (tree
, tree
);
221 static tree
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
222 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
223 static bool complex_alias_template_p (const_tree tmpl
);
224 static tree
tsubst_attributes (tree
, tree
, tsubst_flags_t
, tree
);
225 static tree
canonicalize_expr_argument (tree
, tsubst_flags_t
);
226 static tree
make_argument_pack (tree
);
227 static void register_parameter_specializations (tree
, tree
);
228 static tree
enclosing_instantiation_of (tree tctx
);
230 /* Make the current scope suitable for access checking when we are
231 processing T. T can be FUNCTION_DECL for instantiated function
232 template, VAR_DECL for static member variable, or TYPE_DECL for
233 alias template (needed by instantiate_decl). */
236 push_access_scope (tree t
)
238 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
239 || TREE_CODE (t
) == TYPE_DECL
);
241 if (DECL_FRIEND_CONTEXT (t
))
242 push_nested_class (DECL_FRIEND_CONTEXT (t
));
243 else if (DECL_CLASS_SCOPE_P (t
))
244 push_nested_class (DECL_CONTEXT (t
));
246 push_to_top_level ();
248 if (TREE_CODE (t
) == FUNCTION_DECL
)
250 saved_access_scope
= tree_cons
251 (NULL_TREE
, current_function_decl
, saved_access_scope
);
252 current_function_decl
= t
;
256 /* Restore the scope set up by push_access_scope. T is the node we
260 pop_access_scope (tree t
)
262 if (TREE_CODE (t
) == FUNCTION_DECL
)
264 current_function_decl
= TREE_VALUE (saved_access_scope
);
265 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
268 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
271 pop_from_top_level ();
274 /* Do any processing required when DECL (a member template
275 declaration) is finished. Returns the TEMPLATE_DECL corresponding
276 to DECL, unless it is a specialization, in which case the DECL
277 itself is returned. */
280 finish_member_template_decl (tree decl
)
282 if (decl
== error_mark_node
)
283 return error_mark_node
;
285 gcc_assert (DECL_P (decl
));
287 if (TREE_CODE (decl
) == TYPE_DECL
)
291 type
= TREE_TYPE (decl
);
292 if (type
== error_mark_node
)
293 return error_mark_node
;
294 if (MAYBE_CLASS_TYPE_P (type
)
295 && CLASSTYPE_TEMPLATE_INFO (type
)
296 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
298 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
299 check_member_template (tmpl
);
304 else if (TREE_CODE (decl
) == FIELD_DECL
)
305 error ("data member %qD cannot be a member template", decl
);
306 else if (DECL_TEMPLATE_INFO (decl
))
308 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
310 check_member_template (DECL_TI_TEMPLATE (decl
));
311 return DECL_TI_TEMPLATE (decl
);
317 error ("invalid member template declaration %qD", decl
);
319 return error_mark_node
;
322 /* Create a template info node. */
325 build_template_info (tree template_decl
, tree template_args
)
327 tree result
= make_node (TEMPLATE_INFO
);
328 TI_TEMPLATE (result
) = template_decl
;
329 TI_ARGS (result
) = template_args
;
333 /* Return the template info node corresponding to T, whatever T is. */
336 get_template_info (const_tree t
)
338 tree tinfo
= NULL_TREE
;
340 if (!t
|| t
== error_mark_node
)
343 if (TREE_CODE (t
) == NAMESPACE_DECL
344 || TREE_CODE (t
) == PARM_DECL
)
347 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
348 tinfo
= DECL_TEMPLATE_INFO (t
);
350 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
353 if (OVERLOAD_TYPE_P (t
))
354 tinfo
= TYPE_TEMPLATE_INFO (t
);
355 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
356 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
361 /* Returns the template nesting level of the indicated class TYPE.
371 A<T>::B<U> has depth two, while A<T> has depth one.
372 Both A<T>::B<int> and A<int>::B<U> have depth one, if
373 they are instantiations, not specializations.
375 This function is guaranteed to return 0 if passed NULL_TREE so
376 that, for example, `template_class_depth (current_class_type)' is
380 template_class_depth (tree type
)
384 for (depth
= 0; type
&& TREE_CODE (type
) != NAMESPACE_DECL
; )
386 tree tinfo
= get_template_info (type
);
388 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
389 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
393 type
= CP_DECL_CONTEXT (type
);
394 else if (LAMBDA_TYPE_P (type
))
395 type
= LAMBDA_TYPE_EXTRA_SCOPE (type
);
397 type
= CP_TYPE_CONTEXT (type
);
403 /* Subroutine of maybe_begin_member_template_processing.
404 Returns true if processing DECL needs us to push template parms. */
407 inline_needs_template_parms (tree decl
, bool nsdmi
)
409 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
412 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
413 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
416 /* Subroutine of maybe_begin_member_template_processing.
417 Push the template parms in PARMS, starting from LEVELS steps into the
418 chain, and ending at the beginning, since template parms are listed
422 push_inline_template_parms_recursive (tree parmlist
, int levels
)
424 tree parms
= TREE_VALUE (parmlist
);
428 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
430 ++processing_template_decl
;
431 current_template_parms
432 = tree_cons (size_int (processing_template_decl
),
433 parms
, current_template_parms
);
434 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
436 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
438 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
440 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
442 if (error_operand_p (parm
))
445 gcc_assert (DECL_P (parm
));
447 switch (TREE_CODE (parm
))
455 /* Push the CONST_DECL. */
456 pushdecl (TEMPLATE_PARM_DECL (DECL_INITIAL (parm
)));
465 /* Restore the template parameter context for a member template, a
466 friend template defined in a class definition, or a non-template
467 member of template class. */
470 maybe_begin_member_template_processing (tree decl
)
474 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
478 tree ctx
= DECL_CONTEXT (decl
);
479 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
480 /* Disregard full specializations (c++/60999). */
481 && uses_template_parms (ctx
)
482 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
485 if (inline_needs_template_parms (decl
, nsdmi
))
487 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
488 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
490 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
493 parms
= TREE_CHAIN (parms
);
496 push_inline_template_parms_recursive (parms
, levels
);
499 /* Remember how many levels of template parameters we pushed so that
500 we can pop them later. */
501 inline_parm_levels
.safe_push (levels
);
504 /* Undo the effects of maybe_begin_member_template_processing. */
507 maybe_end_member_template_processing (void)
512 if (inline_parm_levels
.length () == 0)
515 last
= inline_parm_levels
.pop ();
516 for (i
= 0; i
< last
; ++i
)
518 --processing_template_decl
;
519 current_template_parms
= TREE_CHAIN (current_template_parms
);
524 /* Return a new template argument vector which contains all of ARGS,
525 but has as its innermost set of arguments the EXTRA_ARGS. */
528 add_to_template_args (tree args
, tree extra_args
)
535 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
538 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
539 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
541 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
542 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
544 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
545 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
550 /* Like add_to_template_args, but only the outermost ARGS are added to
551 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
552 (EXTRA_ARGS) levels are added. This function is used to combine
553 the template arguments from a partial instantiation with the
554 template arguments used to attain the full instantiation from the
555 partial instantiation. */
558 add_outermost_template_args (tree args
, tree extra_args
)
562 /* If there are more levels of EXTRA_ARGS than there are ARGS,
563 something very fishy is going on. */
564 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
566 /* If *all* the new arguments will be the EXTRA_ARGS, just return
568 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
571 /* For the moment, we make ARGS look like it contains fewer levels. */
572 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
574 new_args
= add_to_template_args (args
, extra_args
);
576 /* Now, we restore ARGS to its full dimensions. */
577 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
582 /* Return the N levels of innermost template arguments from the ARGS. */
585 get_innermost_template_args (tree args
, int n
)
593 /* If N is 1, just return the innermost set of template arguments. */
595 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
597 /* If we're not removing anything, just return the arguments we were
599 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
600 gcc_assert (extra_levels
>= 0);
601 if (extra_levels
== 0)
604 /* Make a new set of arguments, not containing the outer arguments. */
605 new_args
= make_tree_vec (n
);
606 for (i
= 1; i
<= n
; ++i
)
607 SET_TMPL_ARGS_LEVEL (new_args
, i
,
608 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
613 /* The inverse of get_innermost_template_args: Return all but the innermost
614 EXTRA_LEVELS levels of template arguments from the ARGS. */
617 strip_innermost_template_args (tree args
, int extra_levels
)
620 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
625 /* If N is 1, just return the outermost set of template arguments. */
627 return TMPL_ARGS_LEVEL (args
, 1);
629 /* If we're not removing anything, just return the arguments we were
631 gcc_assert (extra_levels
>= 0);
632 if (extra_levels
== 0)
635 /* Make a new set of arguments, not containing the inner arguments. */
636 new_args
= make_tree_vec (n
);
637 for (i
= 1; i
<= n
; ++i
)
638 SET_TMPL_ARGS_LEVEL (new_args
, i
,
639 TMPL_ARGS_LEVEL (args
, i
));
644 /* We've got a template header coming up; push to a new level for storing
648 begin_template_parm_list (void)
650 /* We use a non-tag-transparent scope here, which causes pushtag to
651 put tags in this scope, rather than in the enclosing class or
652 namespace scope. This is the right thing, since we want
653 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
654 global template class, push_template_decl handles putting the
655 TEMPLATE_DECL into top-level scope. For a nested template class,
658 template <class T> struct S1 {
659 template <class T> struct S2 {};
662 pushtag contains special code to insert the TEMPLATE_DECL for S2
663 at the right scope. */
664 begin_scope (sk_template_parms
, NULL
);
665 ++processing_template_decl
;
666 ++processing_template_parmlist
;
667 note_template_header (0);
669 /* Add a dummy parameter level while we process the parameter list. */
670 current_template_parms
671 = tree_cons (size_int (processing_template_decl
),
673 current_template_parms
);
676 /* This routine is called when a specialization is declared. If it is
677 invalid to declare a specialization here, an error is reported and
678 false is returned, otherwise this routine will return true. */
681 check_specialization_scope (void)
683 tree scope
= current_scope ();
687 An explicit specialization shall be declared in the namespace of
688 which the template is a member, or, for member templates, in the
689 namespace of which the enclosing class or enclosing class
690 template is a member. An explicit specialization of a member
691 function, member class or static data member of a class template
692 shall be declared in the namespace of which the class template
694 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
696 error ("explicit specialization in non-namespace scope %qD", scope
);
702 In an explicit specialization declaration for a member of a class
703 template or a member template that appears in namespace scope,
704 the member template and some of its enclosing class templates may
705 remain unspecialized, except that the declaration shall not
706 explicitly specialize a class member template if its enclosing
707 class templates are not explicitly specialized as well. */
708 if (current_template_parms
)
710 error ("enclosing class templates are not explicitly specialized");
717 /* We've just seen template <>. */
720 begin_specialization (void)
722 begin_scope (sk_template_spec
, NULL
);
723 note_template_header (1);
724 return check_specialization_scope ();
727 /* Called at then end of processing a declaration preceded by
731 end_specialization (void)
734 reset_specialization ();
737 /* Any template <>'s that we have seen thus far are not referring to a
738 function specialization. */
741 reset_specialization (void)
743 processing_specialization
= 0;
744 template_header_count
= 0;
747 /* We've just seen a template header. If SPECIALIZATION is nonzero,
748 it was of the form template <>. */
751 note_template_header (int specialization
)
753 processing_specialization
= specialization
;
754 template_header_count
++;
757 /* We're beginning an explicit instantiation. */
760 begin_explicit_instantiation (void)
762 gcc_assert (!processing_explicit_instantiation
);
763 processing_explicit_instantiation
= true;
768 end_explicit_instantiation (void)
770 gcc_assert (processing_explicit_instantiation
);
771 processing_explicit_instantiation
= false;
774 /* An explicit specialization or partial specialization of TMPL is being
775 declared. Check that the namespace in which the specialization is
776 occurring is permissible. Returns false iff it is invalid to
777 specialize TMPL in the current namespace. */
780 check_specialization_namespace (tree tmpl
)
782 tree tpl_ns
= decl_namespace_context (tmpl
);
786 An explicit specialization shall be declared in a namespace enclosing the
787 specialized template. An explicit specialization whose declarator-id is
788 not qualified shall be declared in the nearest enclosing namespace of the
789 template, or, if the namespace is inline (7.3.1), any namespace from its
790 enclosing namespace set. */
791 if (current_scope() != DECL_CONTEXT (tmpl
)
792 && !at_namespace_scope_p ())
794 error ("specialization of %qD must appear at namespace scope", tmpl
);
798 if (is_nested_namespace (current_namespace
, tpl_ns
, cxx_dialect
< cxx11
))
799 /* Same or enclosing namespace. */
803 permerror (input_location
,
804 "specialization of %qD in different namespace", tmpl
);
805 inform (DECL_SOURCE_LOCATION (tmpl
),
806 " from definition of %q#D", tmpl
);
811 /* SPEC is an explicit instantiation. Check that it is valid to
812 perform this explicit instantiation in the current namespace. */
815 check_explicit_instantiation_namespace (tree spec
)
819 /* DR 275: An explicit instantiation shall appear in an enclosing
820 namespace of its template. */
821 ns
= decl_namespace_context (spec
);
822 if (!is_nested_namespace (current_namespace
, ns
))
823 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
824 "(which does not enclose namespace %qD)",
825 spec
, current_namespace
, ns
);
828 // Returns the type of a template specialization only if that
829 // specialization needs to be defined. Otherwise (e.g., if the type has
830 // already been defined), the function returns NULL_TREE.
832 maybe_new_partial_specialization (tree type
)
834 // An implicit instantiation of an incomplete type implies
835 // the definition of a new class template.
837 // template<typename T>
840 // template<typename T>
843 // Here, S<T*> is an implicit instantiation of S whose type
845 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
) && !COMPLETE_TYPE_P (type
))
848 // It can also be the case that TYPE is a completed specialization.
849 // Continuing the previous example, suppose we also declare:
851 // template<typename T>
852 // requires Integral<T>
855 // Here, S<T*> refers to the specialization S<T*> defined
856 // above. However, we need to differentiate definitions because
857 // we intend to define a new partial specialization. In this case,
858 // we rely on the fact that the constraints are different for
859 // this declaration than that above.
861 // Note that we also get here for injected class names and
862 // late-parsed template definitions. We must ensure that we
863 // do not create new type declarations for those cases.
864 if (flag_concepts
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
866 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
867 tree args
= CLASSTYPE_TI_ARGS (type
);
869 // If there are no template parameters, this cannot be a new
870 // partial template specializtion?
871 if (!current_template_parms
)
874 // The injected-class-name is not a new partial specialization.
875 if (DECL_SELF_REFERENCE_P (TYPE_NAME (type
)))
878 // If the constraints are not the same as those of the primary
879 // then, we can probably create a new specialization.
880 tree type_constr
= current_template_constraints ();
882 if (type
== TREE_TYPE (tmpl
))
884 tree main_constr
= get_constraints (tmpl
);
885 if (equivalent_constraints (type_constr
, main_constr
))
889 // Also, if there's a pre-existing specialization with matching
890 // constraints, then this also isn't new.
891 tree specs
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
894 tree spec_tmpl
= TREE_VALUE (specs
);
895 tree spec_args
= TREE_PURPOSE (specs
);
896 tree spec_constr
= get_constraints (spec_tmpl
);
897 if (comp_template_args (args
, spec_args
)
898 && equivalent_constraints (type_constr
, spec_constr
))
900 specs
= TREE_CHAIN (specs
);
903 // Create a new type node (and corresponding type decl)
904 // for the newly declared specialization.
905 tree t
= make_class_type (TREE_CODE (type
));
906 CLASSTYPE_DECLARED_CLASS (t
) = CLASSTYPE_DECLARED_CLASS (type
);
907 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (tmpl
, args
));
909 /* We only need a separate type node for storing the definition of this
910 partial specialization; uses of S<T*> are unconstrained, so all are
911 equivalent. So keep TYPE_CANONICAL the same. */
912 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
914 // Build the corresponding type decl.
915 tree d
= create_implicit_typedef (DECL_NAME (tmpl
), t
);
916 DECL_CONTEXT (d
) = TYPE_CONTEXT (t
);
917 DECL_SOURCE_LOCATION (d
) = input_location
;
925 /* The TYPE is being declared. If it is a template type, that means it
926 is a partial specialization. Do appropriate error-checking. */
929 maybe_process_partial_specialization (tree type
)
933 if (type
== error_mark_node
)
934 return error_mark_node
;
936 /* A lambda that appears in specialization context is not itself a
938 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
941 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
943 error ("name of class shadows template template parameter %qD",
945 return error_mark_node
;
948 context
= TYPE_CONTEXT (type
);
950 if (TYPE_ALIAS_P (type
))
952 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (type
);
954 if (tinfo
&& DECL_ALIAS_TEMPLATE_P (TI_TEMPLATE (tinfo
)))
955 error ("specialization of alias template %qD",
956 TI_TEMPLATE (tinfo
));
958 error ("explicit specialization of non-template %qT", type
);
959 return error_mark_node
;
961 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
963 /* This is for ordinary explicit specialization and partial
964 specialization of a template class such as:
966 template <> class C<int>;
970 template <class T> class C<T*>;
972 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
974 if (tree t
= maybe_new_partial_specialization (type
))
976 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (t
))
977 && !at_namespace_scope_p ())
978 return error_mark_node
;
979 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t
);
980 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (t
)) = input_location
;
981 if (processing_template_decl
)
983 tree decl
= push_template_decl (TYPE_MAIN_DECL (t
));
984 if (decl
== error_mark_node
)
985 return error_mark_node
;
986 return TREE_TYPE (decl
);
989 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
990 error ("specialization of %qT after instantiation", type
);
991 else if (errorcount
&& !processing_specialization
992 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
993 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
994 /* Trying to define a specialization either without a template<> header
995 or in an inappropriate place. We've already given an error, so just
996 bail now so we don't actually define the specialization. */
997 return error_mark_node
;
999 else if (CLASS_TYPE_P (type
)
1000 && !CLASSTYPE_USE_TEMPLATE (type
)
1001 && CLASSTYPE_TEMPLATE_INFO (type
)
1002 && context
&& CLASS_TYPE_P (context
)
1003 && CLASSTYPE_TEMPLATE_INFO (context
))
1005 /* This is for an explicit specialization of member class
1006 template according to [temp.expl.spec/18]:
1008 template <> template <class U> class C<int>::D;
1010 The context `C<int>' must be an implicit instantiation.
1011 Otherwise this is just a member class template declared
1014 template <> class C<int> { template <class U> class D; };
1015 template <> template <class U> class C<int>::D;
1017 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1018 while in the second case, `C<int>::D' is a primary template
1019 and `C<T>::D' may not exist. */
1021 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
1022 && !COMPLETE_TYPE_P (type
))
1025 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1027 if (current_namespace
1028 != decl_namespace_context (tmpl
))
1030 permerror (input_location
,
1031 "specializing %q#T in different namespace", type
);
1032 permerror (DECL_SOURCE_LOCATION (tmpl
),
1033 " from definition of %q#D", tmpl
);
1036 /* Check for invalid specialization after instantiation:
1038 template <> template <> class C<int>::D<int>;
1039 template <> template <class U> class C<int>::D; */
1041 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
1042 t
; t
= TREE_CHAIN (t
))
1044 tree inst
= TREE_VALUE (t
);
1045 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
1046 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
1048 /* We already have a full specialization of this partial
1049 instantiation, or a full specialization has been
1050 looked up but not instantiated. Reassign it to the
1051 new member specialization template. */
1055 elt
.tmpl
= most_general_template (tmpl
);
1056 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
1059 type_specializations
->remove_elt (&elt
);
1062 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
1065 = type_specializations
->find_slot (&elt
, INSERT
);
1066 entry
= ggc_alloc
<spec_entry
> ();
1071 /* But if we've had an implicit instantiation, that's a
1072 problem ([temp.expl.spec]/6). */
1073 error ("specialization %qT after instantiation %qT",
1077 /* Mark TYPE as a specialization. And as a result, we only
1078 have one level of template argument for the innermost
1080 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
1081 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
1082 CLASSTYPE_TI_ARGS (type
)
1083 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
1086 else if (processing_specialization
)
1088 /* Someday C++0x may allow for enum template specialization. */
1089 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
1090 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
1091 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
1092 "of %qD not allowed by ISO C++", type
);
1095 error ("explicit specialization of non-template %qT", type
);
1096 return error_mark_node
;
1103 /* Returns nonzero if we can optimize the retrieval of specializations
1104 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1105 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1108 optimize_specialization_lookup_p (tree tmpl
)
1110 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
1111 && DECL_CLASS_SCOPE_P (tmpl
)
1112 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1114 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
1115 /* The optimized lookup depends on the fact that the
1116 template arguments for the member function template apply
1117 purely to the containing class, which is not true if the
1118 containing class is an explicit or partial
1120 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1121 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1122 && !DECL_CONV_FN_P (tmpl
)
1123 /* It is possible to have a template that is not a member
1124 template and is not a member of a template class:
1126 template <typename T>
1127 struct S { friend A::f(); };
1129 Here, the friend function is a template, but the context does
1130 not have template information. The optimized lookup relies
1131 on having ARGS be the template arguments for both the class
1132 and the function template. */
1133 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1136 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1137 gone through coerce_template_parms by now. */
1140 verify_unstripped_args_1 (tree inner
)
1142 for (int i
= 0; i
< TREE_VEC_LENGTH (inner
); ++i
)
1144 tree arg
= TREE_VEC_ELT (inner
, i
);
1145 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1147 else if (TYPE_P (arg
))
1148 gcc_assert (strip_typedefs (arg
, NULL
) == arg
);
1149 else if (ARGUMENT_PACK_P (arg
))
1150 verify_unstripped_args_1 (ARGUMENT_PACK_ARGS (arg
));
1151 else if (strip_typedefs (TREE_TYPE (arg
), NULL
) != TREE_TYPE (arg
))
1152 /* Allow typedefs on the type of a non-type argument, since a
1153 parameter can have them. */;
1155 gcc_assert (strip_typedefs_expr (arg
, NULL
) == arg
);
1160 verify_unstripped_args (tree args
)
1162 ++processing_template_decl
;
1163 if (!any_dependent_template_arguments_p (args
))
1164 verify_unstripped_args_1 (INNERMOST_TEMPLATE_ARGS (args
));
1165 --processing_template_decl
;
1168 /* Retrieve the specialization (in the sense of [temp.spec] - a
1169 specialization is either an instantiation or an explicit
1170 specialization) of TMPL for the given template ARGS. If there is
1171 no such specialization, return NULL_TREE. The ARGS are a vector of
1172 arguments, or a vector of vectors of arguments, in the case of
1173 templates with more than one level of parameters.
1175 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1176 then we search for a partial specialization matching ARGS. This
1177 parameter is ignored if TMPL is not a class template.
1179 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1180 result is a NONTYPE_ARGUMENT_PACK. */
1183 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1185 if (tmpl
== NULL_TREE
)
1188 if (args
== error_mark_node
)
1191 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1192 || TREE_CODE (tmpl
) == FIELD_DECL
);
1194 /* There should be as many levels of arguments as there are
1195 levels of parameters. */
1196 gcc_assert (TMPL_ARGS_DEPTH (args
)
1197 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1198 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1199 : template_class_depth (DECL_CONTEXT (tmpl
))));
1202 verify_unstripped_args (args
);
1204 /* Lambda functions in templates aren't instantiated normally, but through
1205 tsubst_lambda_expr. */
1206 if (lambda_fn_in_template_p (tmpl
))
1209 if (optimize_specialization_lookup_p (tmpl
))
1211 /* The template arguments actually apply to the containing
1212 class. Find the class specialization with those
1214 tree class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1215 tree class_specialization
1216 = retrieve_specialization (class_template
, args
, 0);
1217 if (!class_specialization
)
1220 /* Find the instance of TMPL. */
1221 tree fns
= get_class_binding (class_specialization
, DECL_NAME (tmpl
));
1222 for (ovl_iterator
iter (fns
); iter
; ++iter
)
1225 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1226 /* using-declarations can add base methods to the method vec,
1227 and we don't want those here. */
1228 && DECL_CONTEXT (fn
) == class_specialization
)
1237 hash_table
<spec_hasher
> *specializations
;
1241 elt
.spec
= NULL_TREE
;
1243 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1244 specializations
= type_specializations
;
1246 specializations
= decl_specializations
;
1249 hash
= spec_hasher::hash (&elt
);
1250 found
= specializations
->find_with_hash (&elt
, hash
);
1258 /* Like retrieve_specialization, but for local declarations. */
1261 retrieve_local_specialization (tree tmpl
)
1263 if (local_specializations
== NULL
)
1266 tree
*slot
= local_specializations
->get (tmpl
);
1267 return slot
? *slot
: NULL_TREE
;
1270 /* Returns nonzero iff DECL is a specialization of TMPL. */
1273 is_specialization_of (tree decl
, tree tmpl
)
1277 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1281 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1287 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1289 for (t
= TREE_TYPE (decl
);
1291 t
= CLASSTYPE_USE_TEMPLATE (t
)
1292 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1293 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1300 /* Returns nonzero iff DECL is a specialization of friend declaration
1301 FRIEND_DECL according to [temp.friend]. */
1304 is_specialization_of_friend (tree decl
, tree friend_decl
)
1306 bool need_template
= true;
1309 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1310 || TREE_CODE (decl
) == TYPE_DECL
);
1312 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1313 of a template class, we want to check if DECL is a specialization
1315 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1316 && DECL_TEMPLATE_INFO (friend_decl
)
1317 && !DECL_USE_TEMPLATE (friend_decl
))
1319 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1320 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1321 need_template
= false;
1323 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1324 && !PRIMARY_TEMPLATE_P (friend_decl
))
1325 need_template
= false;
1327 /* There is nothing to do if this is not a template friend. */
1328 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1331 if (is_specialization_of (decl
, friend_decl
))
1335 A member of a class template may be declared to be a friend of a
1336 non-template class. In this case, the corresponding member of
1337 every specialization of the class template is a friend of the
1338 class granting friendship.
1340 For example, given a template friend declaration
1342 template <class T> friend void A<T>::f();
1344 the member function below is considered a friend
1346 template <> struct A<int> {
1350 For this type of template friend, TEMPLATE_DEPTH below will be
1351 nonzero. To determine if DECL is a friend of FRIEND, we first
1352 check if the enclosing class is a specialization of another. */
1354 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1356 && DECL_CLASS_SCOPE_P (decl
)
1357 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1358 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1360 /* Next, we check the members themselves. In order to handle
1361 a few tricky cases, such as when FRIEND_DECL's are
1363 template <class T> friend void A<T>::g(T t);
1364 template <class T> template <T t> friend void A<T>::h();
1368 void A<int>::g(int);
1369 template <int> void A<int>::h();
1371 we need to figure out ARGS, the template arguments from
1372 the context of DECL. This is required for template substitution
1373 of `T' in the function parameter of `g' and template parameter
1374 of `h' in the above examples. Here ARGS corresponds to `int'. */
1376 tree context
= DECL_CONTEXT (decl
);
1377 tree args
= NULL_TREE
;
1378 int current_depth
= 0;
1380 while (current_depth
< template_depth
)
1382 if (CLASSTYPE_TEMPLATE_INFO (context
))
1384 if (current_depth
== 0)
1385 args
= TYPE_TI_ARGS (context
);
1387 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1390 context
= TYPE_CONTEXT (context
);
1393 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1398 tree friend_args_type
;
1399 tree decl_args_type
;
1401 /* Make sure that both DECL and FRIEND_DECL are templates or
1403 is_template
= DECL_TEMPLATE_INFO (decl
)
1404 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1405 if (need_template
^ is_template
)
1407 else if (is_template
)
1409 /* If both are templates, check template parameter list. */
1411 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1413 if (!comp_template_parms
1414 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1418 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1421 decl_type
= TREE_TYPE (decl
);
1423 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1424 tf_none
, NULL_TREE
);
1425 if (friend_type
== error_mark_node
)
1428 /* Check if return types match. */
1429 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1432 /* Check if function parameter types match, ignoring the
1433 `this' parameter. */
1434 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1435 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1436 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1437 friend_args_type
= TREE_CHAIN (friend_args_type
);
1438 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1439 decl_args_type
= TREE_CHAIN (decl_args_type
);
1441 return compparms (decl_args_type
, friend_args_type
);
1445 /* DECL is a TYPE_DECL */
1447 tree decl_type
= TREE_TYPE (decl
);
1449 /* Make sure that both DECL and FRIEND_DECL are templates or
1452 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1453 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1455 if (need_template
^ is_template
)
1457 else if (is_template
)
1460 /* If both are templates, check the name of the two
1461 TEMPLATE_DECL's first because is_friend didn't. */
1462 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1463 != DECL_NAME (friend_decl
))
1466 /* Now check template parameter list. */
1468 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1470 return comp_template_parms
1471 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1475 return (DECL_NAME (decl
)
1476 == DECL_NAME (friend_decl
));
1482 /* Register the specialization SPEC as a specialization of TMPL with
1483 the indicated ARGS. IS_FRIEND indicates whether the specialization
1484 is actually just a friend declaration. ATTRLIST is the list of
1485 attributes that the specialization is declared with or NULL when
1486 it isn't. Returns SPEC, or an equivalent prior declaration, if
1489 We also store instantiations of field packs in the hash table, even
1490 though they are not themselves templates, to make lookup easier. */
1493 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1497 spec_entry
**slot
= NULL
;
1500 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1501 || (TREE_CODE (tmpl
) == FIELD_DECL
1502 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1504 if (TREE_CODE (spec
) == FUNCTION_DECL
1505 && uses_template_parms (DECL_TI_ARGS (spec
)))
1506 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1507 register it; we want the corresponding TEMPLATE_DECL instead.
1508 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1509 the more obvious `uses_template_parms (spec)' to avoid problems
1510 with default function arguments. In particular, given
1511 something like this:
1513 template <class T> void f(T t1, T t = T())
1515 the default argument expression is not substituted for in an
1516 instantiation unless and until it is actually needed. */
1519 if (optimize_specialization_lookup_p (tmpl
))
1520 /* We don't put these specializations in the hash table, but we might
1521 want to give an error about a mismatch. */
1522 fn
= retrieve_specialization (tmpl
, args
, 0);
1530 hash
= spec_hasher::hash (&elt
);
1533 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1535 fn
= ((spec_entry
*) *slot
)->spec
;
1540 /* We can sometimes try to re-register a specialization that we've
1541 already got. In particular, regenerate_decl_from_template calls
1542 duplicate_decls which will update the specialization list. But,
1543 we'll still get called again here anyhow. It's more convenient
1544 to simply allow this than to try to prevent it. */
1547 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1549 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1551 if (DECL_ODR_USED (fn
)
1552 || DECL_EXPLICIT_INSTANTIATION (fn
))
1554 error ("specialization of %qD after instantiation",
1556 return error_mark_node
;
1561 /* This situation should occur only if the first
1562 specialization is an implicit instantiation, the
1563 second is an explicit specialization, and the
1564 implicit instantiation has not yet been used. That
1565 situation can occur if we have implicitly
1566 instantiated a member function and then specialized
1569 We can also wind up here if a friend declaration that
1570 looked like an instantiation turns out to be a
1573 template <class T> void foo(T);
1574 class S { friend void foo<>(int) };
1575 template <> void foo(int);
1577 We transform the existing DECL in place so that any
1578 pointers to it become pointers to the updated
1581 If there was a definition for the template, but not
1582 for the specialization, we want this to look as if
1583 there were no definition, and vice versa. */
1584 DECL_INITIAL (fn
) = NULL_TREE
;
1585 duplicate_decls (spec
, fn
, is_friend
);
1586 /* The call to duplicate_decls will have applied
1589 An explicit specialization of a function template
1590 is inline only if it is explicitly declared to be,
1591 and independently of whether its function template
1594 to the primary function; now copy the inline bits to
1595 the various clones. */
1596 FOR_EACH_CLONE (clone
, fn
)
1598 DECL_DECLARED_INLINE_P (clone
)
1599 = DECL_DECLARED_INLINE_P (fn
);
1600 DECL_SOURCE_LOCATION (clone
)
1601 = DECL_SOURCE_LOCATION (fn
);
1602 DECL_DELETED_FN (clone
)
1603 = DECL_DELETED_FN (fn
);
1605 check_specialization_namespace (tmpl
);
1610 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1612 tree dd
= duplicate_decls (spec
, fn
, is_friend
);
1613 if (dd
== error_mark_node
)
1614 /* We've already complained in duplicate_decls. */
1615 return error_mark_node
;
1617 if (dd
== NULL_TREE
&& DECL_INITIAL (spec
))
1618 /* Dup decl failed, but this is a new definition. Set the
1619 line number so any errors match this new
1621 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1627 return duplicate_decls (spec
, fn
, is_friend
);
1629 /* A specialization must be declared in the same namespace as the
1630 template it is specializing. */
1631 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1632 && !check_specialization_namespace (tmpl
))
1633 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1635 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1637 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1638 gcc_assert (tmpl
&& args
&& spec
);
1641 if ((TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1642 && PRIMARY_TEMPLATE_P (tmpl
)
1643 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1644 || variable_template_p (tmpl
))
1645 /* If TMPL is a forward declaration of a template function, keep a list
1646 of all specializations in case we need to reassign them to a friend
1647 template later in tsubst_friend_function.
1649 Also keep a list of all variable template instantiations so that
1650 process_partial_specialization can check whether a later partial
1651 specialization would have used it. */
1652 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1653 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1659 /* Returns true iff two spec_entry nodes are equivalent. */
1661 int comparing_specializations
;
1664 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1668 ++comparing_specializations
;
1669 equal
= (e1
->tmpl
== e2
->tmpl
1670 && comp_template_args (e1
->args
, e2
->args
));
1671 if (equal
&& flag_concepts
1672 /* tmpl could be a FIELD_DECL for a capture pack. */
1673 && TREE_CODE (e1
->tmpl
) == TEMPLATE_DECL
1674 && VAR_P (DECL_TEMPLATE_RESULT (e1
->tmpl
))
1675 && uses_template_parms (e1
->args
))
1677 /* Partial specializations of a variable template can be distinguished by
1679 tree c1
= e1
->spec
? get_constraints (e1
->spec
) : NULL_TREE
;
1680 tree c2
= e2
->spec
? get_constraints (e2
->spec
) : NULL_TREE
;
1681 equal
= equivalent_constraints (c1
, c2
);
1683 --comparing_specializations
;
1688 /* Returns a hash for a template TMPL and template arguments ARGS. */
1691 hash_tmpl_and_args (tree tmpl
, tree args
)
1693 hashval_t val
= iterative_hash_object (DECL_UID (tmpl
), 0);
1694 return iterative_hash_template_arg (args
, val
);
1697 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1701 spec_hasher::hash (spec_entry
*e
)
1703 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1706 /* Recursively calculate a hash value for a template argument ARG, for use
1707 in the hash tables of template specializations. */
1710 iterative_hash_template_arg (tree arg
, hashval_t val
)
1712 unsigned HOST_WIDE_INT i
;
1713 enum tree_code code
;
1716 if (arg
== NULL_TREE
)
1717 return iterative_hash_object (arg
, val
);
1722 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1725 code
= TREE_CODE (arg
);
1726 tclass
= TREE_CODE_CLASS (code
);
1728 val
= iterative_hash_object (code
, val
);
1735 case IDENTIFIER_NODE
:
1736 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1740 int i
, len
= TREE_VEC_LENGTH (arg
);
1741 for (i
= 0; i
< len
; ++i
)
1742 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1746 case TYPE_PACK_EXPANSION
:
1747 case EXPR_PACK_EXPANSION
:
1748 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1749 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1751 case TYPE_ARGUMENT_PACK
:
1752 case NONTYPE_ARGUMENT_PACK
:
1753 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1756 for (; arg
; arg
= TREE_CHAIN (arg
))
1757 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1761 for (lkp_iterator
iter (arg
); iter
; ++iter
)
1762 val
= iterative_hash_template_arg (*iter
, val
);
1768 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1769 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1771 val
= iterative_hash_template_arg (field
, val
);
1772 val
= iterative_hash_template_arg (value
, val
);
1778 if (!DECL_ARTIFICIAL (arg
))
1780 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1781 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1783 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1786 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1789 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1790 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1792 case TEMPLATE_PARM_INDEX
:
1793 val
= iterative_hash_template_arg
1794 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1795 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1796 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1799 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1800 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1801 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1804 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1806 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1810 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1811 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1812 val
= iterative_hash_object (code
, val
);
1813 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1816 /* A lambda can't appear in a template arg, but don't crash on
1818 gcc_assert (seen_error ());
1822 case IMPLICIT_CONV_EXPR
:
1823 case STATIC_CAST_EXPR
:
1824 case REINTERPRET_CAST_EXPR
:
1825 case CONST_CAST_EXPR
:
1826 case DYNAMIC_CAST_EXPR
:
1828 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1829 /* Now hash operands as usual. */
1839 if (alias_template_specialization_p (arg
))
1841 // We want an alias specialization that survived strip_typedefs
1842 // to hash differently from its TYPE_CANONICAL, to avoid hash
1843 // collisions that compare as different in template_args_equal.
1844 // These could be dependent specializations that strip_typedefs
1845 // left alone, or untouched specializations because
1846 // coerce_template_parms returns the unconverted template
1847 // arguments if it sees incomplete argument packs.
1848 tree ti
= TYPE_ALIAS_TEMPLATE_INFO (arg
);
1849 return hash_tmpl_and_args (TI_TEMPLATE (ti
), TI_ARGS (ti
));
1851 if (TYPE_CANONICAL (arg
))
1852 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1854 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1855 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1856 /* Otherwise just compare the types during lookup. */
1859 case tcc_declaration
:
1861 return iterative_hash_expr (arg
, val
);
1864 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1866 unsigned n
= cp_tree_operand_length (arg
);
1867 for (i
= 0; i
< n
; ++i
)
1868 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1876 /* Unregister the specialization SPEC as a specialization of TMPL.
1877 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1878 if the SPEC was listed as a specialization of TMPL.
1880 Note that SPEC has been ggc_freed, so we can't look inside it. */
1883 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1888 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1889 elt
.args
= TI_ARGS (tinfo
);
1890 elt
.spec
= NULL_TREE
;
1892 entry
= decl_specializations
->find (&elt
);
1895 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1896 gcc_assert (new_spec
!= NULL_TREE
);
1897 entry
->spec
= new_spec
;
1904 /* Like register_specialization, but for local declarations. We are
1905 registering SPEC, an instantiation of TMPL. */
1908 register_local_specialization (tree spec
, tree tmpl
)
1910 gcc_assert (tmpl
!= spec
);
1911 local_specializations
->put (tmpl
, spec
);
1914 /* TYPE is a class type. Returns true if TYPE is an explicitly
1915 specialized class. */
1918 explicit_class_specialization_p (tree type
)
1920 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1922 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1925 /* Print the list of functions at FNS, going through all the overloads
1926 for each element of the list. Alternatively, FNS can not be a
1927 TREE_LIST, in which case it will be printed together with all the
1930 MORE and *STR should respectively be FALSE and NULL when the function
1931 is called from the outside. They are used internally on recursive
1932 calls. print_candidates manages the two parameters and leaves NULL
1933 in *STR when it ends. */
1936 print_candidates_1 (tree fns
, char **str
, bool more
= false)
1938 if (TREE_CODE (fns
) == TREE_LIST
)
1939 for (; fns
; fns
= TREE_CHAIN (fns
))
1940 print_candidates_1 (TREE_VALUE (fns
), str
, more
|| TREE_CHAIN (fns
));
1942 for (lkp_iterator
iter (fns
); iter
;)
1947 const char *pfx
= *str
;
1951 pfx
= _("candidates are:");
1953 pfx
= _("candidate is:");
1954 *str
= get_spaces (pfx
);
1956 inform (DECL_SOURCE_LOCATION (cand
), "%s %#qD", pfx
, cand
);
1960 /* Print the list of candidate FNS in an error message. FNS can also
1961 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1964 print_candidates (tree fns
)
1967 print_candidates_1 (fns
, &str
);
1971 /* Get a (possibly) constrained template declaration for the
1972 purpose of ordering candidates. */
1974 get_template_for_ordering (tree list
)
1976 gcc_assert (TREE_CODE (list
) == TREE_LIST
);
1977 tree f
= TREE_VALUE (list
);
1978 if (tree ti
= DECL_TEMPLATE_INFO (f
))
1979 return TI_TEMPLATE (ti
);
1983 /* Among candidates having the same signature, return the
1984 most constrained or NULL_TREE if there is no best candidate.
1985 If the signatures of candidates vary (e.g., template
1986 specialization vs. member function), then there can be no
1989 Note that we don't compare constraints on the functions
1990 themselves, but rather those of their templates. */
1992 most_constrained_function (tree candidates
)
1994 // Try to find the best candidate in a first pass.
1995 tree champ
= candidates
;
1996 for (tree c
= TREE_CHAIN (champ
); c
; c
= TREE_CHAIN (c
))
1998 int winner
= more_constrained (get_template_for_ordering (champ
),
1999 get_template_for_ordering (c
));
2001 champ
= c
; // The candidate is more constrained
2002 else if (winner
== 0)
2003 return NULL_TREE
; // Neither is more constrained
2006 // Verify that the champ is better than previous candidates.
2007 for (tree c
= candidates
; c
!= champ
; c
= TREE_CHAIN (c
)) {
2008 if (!more_constrained (get_template_for_ordering (champ
),
2009 get_template_for_ordering (c
)))
2017 /* Returns the template (one of the functions given by TEMPLATE_ID)
2018 which can be specialized to match the indicated DECL with the
2019 explicit template args given in TEMPLATE_ID. The DECL may be
2020 NULL_TREE if none is available. In that case, the functions in
2021 TEMPLATE_ID are non-members.
2023 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2024 specialization of a member template.
2026 The TEMPLATE_COUNT is the number of references to qualifying
2027 template classes that appeared in the name of the function. See
2028 check_explicit_specialization for a more accurate description.
2030 TSK indicates what kind of template declaration (if any) is being
2031 declared. TSK_TEMPLATE indicates that the declaration given by
2032 DECL, though a FUNCTION_DECL, has template parameters, and is
2033 therefore a template function.
2035 The template args (those explicitly specified and those deduced)
2036 are output in a newly created vector *TARGS_OUT.
2038 If it is impossible to determine the result, an error message is
2039 issued. The error_mark_node is returned to indicate failure. */
2042 determine_specialization (tree template_id
,
2045 int need_member_template
,
2051 tree explicit_targs
;
2052 tree candidates
= NULL_TREE
;
2054 /* A TREE_LIST of templates of which DECL may be a specialization.
2055 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2056 corresponding TREE_PURPOSE is the set of template arguments that,
2057 when used to instantiate the template, would produce a function
2058 with the signature of DECL. */
2059 tree templates
= NULL_TREE
;
2061 cp_binding_level
*b
;
2063 *targs_out
= NULL_TREE
;
2065 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
2066 return error_mark_node
;
2068 /* We shouldn't be specializing a member template of an
2069 unspecialized class template; we already gave an error in
2070 check_specialization_scope, now avoid crashing. */
2072 && template_count
&& DECL_CLASS_SCOPE_P (decl
)
2073 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
2075 gcc_assert (errorcount
);
2076 return error_mark_node
;
2079 fns
= TREE_OPERAND (template_id
, 0);
2080 explicit_targs
= TREE_OPERAND (template_id
, 1);
2082 if (fns
== error_mark_node
)
2083 return error_mark_node
;
2085 /* Check for baselinks. */
2086 if (BASELINK_P (fns
))
2087 fns
= BASELINK_FUNCTIONS (fns
);
2089 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
2091 error ("%qD is not a function template", fns
);
2092 return error_mark_node
;
2094 else if (VAR_P (decl
) && !variable_template_p (fns
))
2096 error ("%qD is not a variable template", fns
);
2097 return error_mark_node
;
2100 /* Count the number of template headers specified for this
2103 for (b
= current_binding_level
;
2104 b
->kind
== sk_template_parms
;
2108 tree orig_fns
= fns
;
2110 if (variable_template_p (fns
))
2112 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns
));
2113 targs
= coerce_template_parms (parms
, explicit_targs
, fns
,
2114 tf_warning_or_error
,
2115 /*req_all*/true, /*use_defarg*/true);
2116 if (targs
!= error_mark_node
)
2117 templates
= tree_cons (targs
, fns
, templates
);
2119 else for (lkp_iterator
iter (fns
); iter
; ++iter
)
2123 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2125 tree decl_arg_types
;
2129 /* In case of explicit specialization, we need to check if
2130 the number of template headers appearing in the specialization
2131 is correct. This is usually done in check_explicit_specialization,
2132 but the check done there cannot be exhaustive when specializing
2133 member functions. Consider the following code:
2135 template <> void A<int>::f(int);
2136 template <> template <> void A<int>::f(int);
2138 Assuming that A<int> is not itself an explicit specialization
2139 already, the first line specializes "f" which is a non-template
2140 member function, whilst the second line specializes "f" which
2141 is a template member function. So both lines are syntactically
2142 correct, and check_explicit_specialization does not reject
2145 Here, we can do better, as we are matching the specialization
2146 against the declarations. We count the number of template
2147 headers, and we check if they match TEMPLATE_COUNT + 1
2148 (TEMPLATE_COUNT is the number of qualifying template classes,
2149 plus there must be another header for the member template
2152 Notice that if header_count is zero, this is not a
2153 specialization but rather a template instantiation, so there
2154 is no check we can perform here. */
2155 if (header_count
&& header_count
!= template_count
+ 1)
2158 /* Check that the number of template arguments at the
2159 innermost level for DECL is the same as for FN. */
2160 if (current_binding_level
->kind
== sk_template_parms
2161 && !current_binding_level
->explicit_spec_p
2162 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
2163 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
2164 (current_template_parms
))))
2167 /* DECL might be a specialization of FN. */
2168 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2169 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2171 /* For a non-static member function, we need to make sure
2172 that the const qualification is the same. Since
2173 get_bindings does not try to merge the "this" parameter,
2174 we must do the comparison explicitly. */
2175 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
2177 if (!same_type_p (TREE_VALUE (fn_arg_types
),
2178 TREE_VALUE (decl_arg_types
)))
2181 /* And the ref-qualification. */
2182 if (type_memfn_rqual (TREE_TYPE (decl
))
2183 != type_memfn_rqual (TREE_TYPE (fn
)))
2187 /* Skip the "this" parameter and, for constructors of
2188 classes with virtual bases, the VTT parameter. A
2189 full specialization of a constructor will have a VTT
2190 parameter, but a template never will. */
2192 = skip_artificial_parms_for (decl
, decl_arg_types
);
2194 = skip_artificial_parms_for (fn
, fn_arg_types
);
2196 /* Function templates cannot be specializations; there are
2197 no partial specializations of functions. Therefore, if
2198 the type of DECL does not match FN, there is no
2201 Note that it should never be the case that we have both
2202 candidates added here, and for regular member functions
2204 if (tsk
== tsk_template
)
2206 if (compparms (fn_arg_types
, decl_arg_types
))
2207 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2211 /* See whether this function might be a specialization of this
2212 template. Suppress access control because we might be trying
2213 to make this specialization a friend, and we have already done
2214 access control for the declaration of the specialization. */
2215 push_deferring_access_checks (dk_no_check
);
2216 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
2217 pop_deferring_access_checks ();
2220 /* We cannot deduce template arguments that when used to
2221 specialize TMPL will produce DECL. */
2224 if (uses_template_parms (targs
))
2225 /* We deduced something involving 'auto', which isn't a valid
2226 template argument. */
2229 /* Remove, from the set of candidates, all those functions
2230 whose constraints are not satisfied. */
2231 if (flag_concepts
&& !constraints_satisfied_p (fn
, targs
))
2234 // Then, try to form the new function type.
2235 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_fndecl_type
, NULL_TREE
);
2236 if (insttype
== error_mark_node
)
2239 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
2240 if (!compparms (fn_arg_types
, decl_arg_types
))
2243 /* Save this template, and the arguments deduced. */
2244 templates
= tree_cons (targs
, fn
, templates
);
2246 else if (need_member_template
)
2247 /* FN is an ordinary member function, and we need a
2248 specialization of a member template. */
2250 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2251 /* We can get IDENTIFIER_NODEs here in certain erroneous
2254 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2255 /* This is just an ordinary non-member function. Nothing can
2256 be a specialization of that. */
2258 else if (DECL_ARTIFICIAL (fn
))
2259 /* Cannot specialize functions that are created implicitly. */
2263 tree decl_arg_types
;
2265 /* This is an ordinary member function. However, since
2266 we're here, we can assume its enclosing class is a
2267 template class. For example,
2269 template <typename T> struct S { void f(); };
2270 template <> void S<int>::f() {}
2272 Here, S<int>::f is a non-template, but S<int> is a
2273 template class. If FN has the same type as DECL, we
2274 might be in business. */
2276 if (!DECL_TEMPLATE_INFO (fn
))
2277 /* Its enclosing class is an explicit specialization
2278 of a template class. This is not a candidate. */
2281 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2282 TREE_TYPE (TREE_TYPE (fn
))))
2283 /* The return types differ. */
2286 /* Adjust the type of DECL in case FN is a static member. */
2287 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2288 if (DECL_STATIC_FUNCTION_P (fn
)
2289 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2290 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2292 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2296 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2297 && (type_memfn_rqual (TREE_TYPE (decl
))
2298 != type_memfn_rqual (TREE_TYPE (fn
))))
2301 // If the deduced arguments do not satisfy the constraints,
2302 // this is not a candidate.
2303 if (flag_concepts
&& !constraints_satisfied_p (fn
))
2306 // Add the candidate.
2307 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2311 if (templates
&& TREE_CHAIN (templates
))
2317 It is possible for a specialization with a given function
2318 signature to be instantiated from more than one function
2319 template. In such cases, explicit specification of the
2320 template arguments must be used to uniquely identify the
2321 function template specialization being specialized.
2323 Note that here, there's no suggestion that we're supposed to
2324 determine which of the candidate templates is most
2325 specialized. However, we, also have:
2329 Partial ordering of overloaded function template
2330 declarations is used in the following contexts to select
2331 the function template to which a function template
2332 specialization refers:
2334 -- when an explicit specialization refers to a function
2337 So, we do use the partial ordering rules, at least for now.
2338 This extension can only serve to make invalid programs valid,
2339 so it's safe. And, there is strong anecdotal evidence that
2340 the committee intended the partial ordering rules to apply;
2341 the EDG front end has that behavior, and John Spicer claims
2342 that the committee simply forgot to delete the wording in
2343 [temp.expl.spec]. */
2344 tree tmpl
= most_specialized_instantiation (templates
);
2345 if (tmpl
!= error_mark_node
)
2348 TREE_CHAIN (templates
) = NULL_TREE
;
2352 // Concepts allows multiple declarations of member functions
2353 // with the same signature. Like above, we need to rely on
2354 // on the partial ordering of those candidates to determine which
2356 if (flag_concepts
&& candidates
&& TREE_CHAIN (candidates
))
2358 if (tree cand
= most_constrained_function (candidates
))
2361 TREE_CHAIN (cand
) = NULL_TREE
;
2365 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2367 error ("template-id %qD for %q+D does not match any template "
2368 "declaration", template_id
, decl
);
2369 if (header_count
&& header_count
!= template_count
+ 1)
2370 inform (input_location
, "saw %d %<template<>%>, need %d for "
2371 "specializing a member function template",
2372 header_count
, template_count
+ 1);
2374 print_candidates (orig_fns
);
2375 return error_mark_node
;
2377 else if ((templates
&& TREE_CHAIN (templates
))
2378 || (candidates
&& TREE_CHAIN (candidates
))
2379 || (templates
&& candidates
))
2381 error ("ambiguous template specialization %qD for %q+D",
2383 candidates
= chainon (candidates
, templates
);
2384 print_candidates (candidates
);
2385 return error_mark_node
;
2388 /* We have one, and exactly one, match. */
2391 tree fn
= TREE_VALUE (candidates
);
2392 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2394 // Propagate the candidate's constraints to the declaration.
2395 set_constraints (decl
, get_constraints (fn
));
2397 /* DECL is a re-declaration or partial instantiation of a template
2399 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2401 /* It was a specialization of an ordinary member function in a
2403 return DECL_TI_TEMPLATE (fn
);
2406 /* It was a specialization of a template. */
2407 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2408 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2410 *targs_out
= copy_node (targs
);
2411 SET_TMPL_ARGS_LEVEL (*targs_out
,
2412 TMPL_ARGS_DEPTH (*targs_out
),
2413 TREE_PURPOSE (templates
));
2416 *targs_out
= TREE_PURPOSE (templates
);
2417 return TREE_VALUE (templates
);
2420 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2421 but with the default argument values filled in from those in the
2425 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2428 tree new_spec_types
;
2433 if (spec_types
== void_list_node
)
2434 return void_list_node
;
2436 /* Substitute into the rest of the list. */
2438 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2439 TREE_CHAIN (tmpl_types
));
2441 /* Add the default argument for this parameter. */
2442 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2443 TREE_VALUE (spec_types
),
2447 /* DECL is an explicit specialization. Replicate default arguments
2448 from the template it specializes. (That way, code like:
2450 template <class T> void f(T = 3);
2451 template <> void f(double);
2454 works, as required.) An alternative approach would be to look up
2455 the correct default arguments at the call-site, but this approach
2456 is consistent with how implicit instantiations are handled. */
2459 copy_default_args_to_explicit_spec (tree decl
)
2464 tree new_spec_types
;
2468 tree object_type
= NULL_TREE
;
2469 tree in_charge
= NULL_TREE
;
2470 tree vtt
= NULL_TREE
;
2472 /* See if there's anything we need to do. */
2473 tmpl
= DECL_TI_TEMPLATE (decl
);
2474 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2475 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2476 if (TREE_PURPOSE (t
))
2481 old_type
= TREE_TYPE (decl
);
2482 spec_types
= TYPE_ARG_TYPES (old_type
);
2484 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2486 /* Remove the this pointer, but remember the object's type for
2488 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2489 spec_types
= TREE_CHAIN (spec_types
);
2490 tmpl_types
= TREE_CHAIN (tmpl_types
);
2492 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2494 /* DECL may contain more parameters than TMPL due to the extra
2495 in-charge parameter in constructors and destructors. */
2496 in_charge
= spec_types
;
2497 spec_types
= TREE_CHAIN (spec_types
);
2499 if (DECL_HAS_VTT_PARM_P (decl
))
2502 spec_types
= TREE_CHAIN (spec_types
);
2506 /* Compute the merged default arguments. */
2508 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2510 /* Compute the new FUNCTION_TYPE. */
2514 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2519 /* Put the in-charge parameter back. */
2520 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2521 TREE_VALUE (in_charge
),
2524 new_type
= build_method_type_directly (object_type
,
2525 TREE_TYPE (old_type
),
2529 new_type
= build_function_type (TREE_TYPE (old_type
),
2531 new_type
= cp_build_type_attribute_variant (new_type
,
2532 TYPE_ATTRIBUTES (old_type
));
2533 new_type
= cxx_copy_lang_qualifiers (new_type
, old_type
);
2535 TREE_TYPE (decl
) = new_type
;
2538 /* Return the number of template headers we expect to see for a definition
2539 or specialization of CTYPE or one of its non-template members. */
2542 num_template_headers_for_class (tree ctype
)
2544 int num_templates
= 0;
2546 while (ctype
&& CLASS_TYPE_P (ctype
))
2548 /* You're supposed to have one `template <...>' for every
2549 template class, but you don't need one for a full
2550 specialization. For example:
2552 template <class T> struct S{};
2553 template <> struct S<int> { void f(); };
2554 void S<int>::f () {}
2556 is correct; there shouldn't be a `template <>' for the
2557 definition of `S<int>::f'. */
2558 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2559 /* If CTYPE does not have template information of any
2560 kind, then it is not a template, nor is it nested
2561 within a template. */
2563 if (explicit_class_specialization_p (ctype
))
2565 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2568 ctype
= TYPE_CONTEXT (ctype
);
2571 return num_templates
;
2574 /* Do a simple sanity check on the template headers that precede the
2575 variable declaration DECL. */
2578 check_template_variable (tree decl
)
2580 tree ctx
= CP_DECL_CONTEXT (decl
);
2581 int wanted
= num_template_headers_for_class (ctx
);
2582 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2583 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2585 if (cxx_dialect
< cxx14
)
2586 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2587 "variable templates only available with "
2588 "-std=c++14 or -std=gnu++14");
2590 // Namespace-scope variable templates should have a template header.
2593 if (template_header_count
> wanted
)
2595 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2596 "too many template headers for %qD "
2599 if (warned
&& CLASS_TYPE_P (ctx
)
2600 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2601 inform (DECL_SOURCE_LOCATION (decl
),
2602 "members of an explicitly specialized class are defined "
2603 "without a template header");
2607 /* An explicit specialization whose declarator-id or class-head-name is not
2608 qualified shall be declared in the nearest enclosing namespace of the
2609 template, or, if the namespace is inline (7.3.1), any namespace from its
2610 enclosing namespace set.
2612 If the name declared in the explicit instantiation is an unqualified name,
2613 the explicit instantiation shall appear in the namespace where its template
2614 is declared or, if that namespace is inline (7.3.1), any namespace from its
2615 enclosing namespace set. */
2618 check_unqualified_spec_or_inst (tree t
, location_t loc
)
2620 tree tmpl
= most_general_template (t
);
2621 if (DECL_NAMESPACE_SCOPE_P (tmpl
)
2622 && !is_nested_namespace (current_namespace
,
2623 CP_DECL_CONTEXT (tmpl
), true))
2625 if (processing_specialization
)
2626 permerror (loc
, "explicit specialization of %qD outside its "
2627 "namespace must use a nested-name-specifier", tmpl
);
2628 else if (processing_explicit_instantiation
2629 && cxx_dialect
>= cxx11
)
2630 /* This was allowed in C++98, so only pedwarn. */
2631 pedwarn (loc
, OPT_Wpedantic
, "explicit instantiation of %qD "
2632 "outside its namespace must use a nested-name-"
2637 /* Warn for a template specialization SPEC that is missing some of a set
2638 of function or type attributes that the template TEMPL is declared with.
2639 ATTRLIST is a list of additional attributes that SPEC should be taken
2640 to ultimately be declared with. */
2643 warn_spec_missing_attributes (tree tmpl
, tree spec
, tree attrlist
)
2645 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
2646 tmpl
= DECL_TEMPLATE_RESULT (tmpl
);
2648 if (TREE_CODE (tmpl
) != FUNCTION_DECL
)
2651 /* Avoid warning if either declaration or its type is deprecated. */
2652 if (TREE_DEPRECATED (tmpl
)
2653 || TREE_DEPRECATED (spec
))
2656 tree tmpl_type
= TREE_TYPE (tmpl
);
2657 tree spec_type
= TREE_TYPE (spec
);
2659 if (TREE_DEPRECATED (tmpl_type
)
2660 || TREE_DEPRECATED (spec_type
)
2661 || TREE_DEPRECATED (TREE_TYPE (tmpl_type
))
2662 || TREE_DEPRECATED (TREE_TYPE (spec_type
)))
2665 tree tmpl_attrs
[] = { DECL_ATTRIBUTES (tmpl
), TYPE_ATTRIBUTES (tmpl_type
) };
2666 tree spec_attrs
[] = { DECL_ATTRIBUTES (spec
), TYPE_ATTRIBUTES (spec_type
) };
2669 spec_attrs
[0] = attrlist
;
2670 else if (!spec_attrs
[1])
2671 spec_attrs
[1] = attrlist
;
2673 /* Avoid warning if the primary has no attributes. */
2674 if (!tmpl_attrs
[0] && !tmpl_attrs
[1])
2677 /* Avoid warning if either declaration contains an attribute on
2678 the white list below. */
2679 const char* const whitelist
[] = {
2683 for (unsigned i
= 0; i
!= 2; ++i
)
2684 for (unsigned j
= 0; j
!= sizeof whitelist
/ sizeof *whitelist
; ++j
)
2685 if (lookup_attribute (whitelist
[j
], tmpl_attrs
[i
])
2686 || lookup_attribute (whitelist
[j
], spec_attrs
[i
]))
2689 /* Avoid warning if the difference between the primary and
2690 the specialization is not in one of the attributes below. */
2691 const char* const blacklist
[] = {
2692 "alloc_align", "alloc_size", "assume_aligned", "format",
2693 "format_arg", "malloc", "nonnull"
2696 /* Put together a list of the black listed attributes that the primary
2697 template is declared with that the specialization is not, in case
2698 it's not apparent from the most recent declaration of the primary. */
2699 unsigned nattrs
= 0;
2702 for (unsigned i
= 0; i
!= sizeof blacklist
/ sizeof *blacklist
; ++i
)
2704 for (unsigned j
= 0; j
!= 2; ++j
)
2706 if (!lookup_attribute (blacklist
[i
], tmpl_attrs
[j
]))
2709 for (unsigned k
= 0; k
!= 1 + !!spec_attrs
[1]; ++k
)
2711 if (lookup_attribute (blacklist
[i
], spec_attrs
[k
]))
2715 pp_string (&str
, ", ");
2716 pp_begin_quote (&str
, pp_show_color (global_dc
->printer
));
2717 pp_string (&str
, blacklist
[i
]);
2718 pp_end_quote (&str
, pp_show_color (global_dc
->printer
));
2727 if (warning_at (DECL_SOURCE_LOCATION (spec
), OPT_Wmissing_attributes
,
2728 "explicit specialization %q#D may be missing attributes",
2730 inform (DECL_SOURCE_LOCATION (tmpl
),
2732 ? G_("missing primary template attributes %s")
2733 : G_("missing primary template attribute %s"),
2734 pp_formatted_text (&str
));
2737 /* Check to see if the function just declared, as indicated in
2738 DECLARATOR, and in DECL, is a specialization of a function
2739 template. We may also discover that the declaration is an explicit
2740 instantiation at this point.
2742 Returns DECL, or an equivalent declaration that should be used
2743 instead if all goes well. Issues an error message if something is
2744 amiss. Returns error_mark_node if the error is not easily
2747 FLAGS is a bitmask consisting of the following flags:
2749 2: The function has a definition.
2750 4: The function is a friend.
2752 The TEMPLATE_COUNT is the number of references to qualifying
2753 template classes that appeared in the name of the function. For
2756 template <class T> struct S { void f(); };
2759 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2760 classes are not counted in the TEMPLATE_COUNT, so that in
2762 template <class T> struct S {};
2763 template <> struct S<int> { void f(); }
2764 template <> void S<int>::f();
2766 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2767 invalid; there should be no template <>.)
2769 If the function is a specialization, it is marked as such via
2770 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2771 is set up correctly, and it is added to the list of specializations
2772 for that template. */
2775 check_explicit_specialization (tree declarator
,
2781 int have_def
= flags
& 2;
2782 int is_friend
= flags
& 4;
2783 bool is_concept
= flags
& 8;
2784 int specialization
= 0;
2785 int explicit_instantiation
= 0;
2786 int member_specialization
= 0;
2787 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2788 tree dname
= DECL_NAME (decl
);
2793 if (!processing_specialization
)
2796 tsk
= tsk_excessive_parms
;
2799 tsk
= current_tmpl_spec_kind (template_count
);
2804 if (processing_specialization
&& !VAR_P (decl
))
2807 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2809 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2812 /* This could be something like:
2814 template <class T> void f(T);
2815 class S { friend void f<>(int); } */
2819 /* This case handles bogus declarations like template <>
2820 template <class T> void f<int>(); */
2822 error ("template-id %qD in declaration of primary template",
2829 case tsk_invalid_member_spec
:
2830 /* The error has already been reported in
2831 check_specialization_scope. */
2832 return error_mark_node
;
2834 case tsk_invalid_expl_inst
:
2835 error ("template parameter list used in explicit instantiation");
2841 error ("definition provided for explicit instantiation");
2843 explicit_instantiation
= 1;
2846 case tsk_excessive_parms
:
2847 case tsk_insufficient_parms
:
2848 if (tsk
== tsk_excessive_parms
)
2849 error ("too many template parameter lists in declaration of %qD",
2851 else if (template_header_count
)
2852 error("too few template parameter lists in declaration of %qD", decl
);
2854 error("explicit specialization of %qD must be introduced by "
2855 "%<template <>%>", decl
);
2860 error ("explicit specialization declared %<concept%>");
2862 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2863 /* In cases like template<> constexpr bool v = true;
2864 We'll give an error in check_template_variable. */
2867 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2869 member_specialization
= 1;
2875 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2877 /* This case handles bogus declarations like template <>
2878 template <class T> void f<int>(); */
2880 if (!uses_template_parms (declarator
))
2881 error ("template-id %qD in declaration of primary template",
2883 else if (variable_template_p (TREE_OPERAND (declarator
, 0)))
2885 /* Partial specialization of variable template. */
2886 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2890 else if (cxx_dialect
< cxx14
)
2891 error ("non-type partial specialization %qD "
2892 "is not allowed", declarator
);
2894 error ("non-class, non-variable partial specialization %qD "
2895 "is not allowed", declarator
);
2900 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2901 /* This is a specialization of a member template, without
2902 specialization the containing class. Something like:
2904 template <class T> struct S {
2905 template <class U> void f (U);
2907 template <> template <class U> void S<int>::f(U) {}
2909 That's a specialization -- but of the entire template. */
2917 if ((specialization
|| member_specialization
)
2918 /* This doesn't apply to variable templates. */
2919 && (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
2920 || TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
))
2922 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2923 for (; t
; t
= TREE_CHAIN (t
))
2924 if (TREE_PURPOSE (t
))
2926 permerror (input_location
,
2927 "default argument specified in explicit specialization");
2932 if (specialization
|| member_specialization
|| explicit_instantiation
)
2934 tree tmpl
= NULL_TREE
;
2935 tree targs
= NULL_TREE
;
2936 bool was_template_id
= (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
);
2938 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2939 if (!was_template_id
)
2943 gcc_assert (identifier_p (declarator
));
2948 /* If there is no class context, the explicit instantiation
2949 must be at namespace scope. */
2950 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2952 /* Find the namespace binding, using the declaration
2954 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2956 if (fns
== error_mark_node
)
2957 /* If lookup fails, look for a friend declaration so we can
2958 give a better diagnostic. */
2959 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2960 /*type*/false, /*complain*/true,
2963 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2965 error ("%qD is not a template function", dname
);
2966 fns
= error_mark_node
;
2970 declarator
= lookup_template_function (fns
, NULL_TREE
);
2973 if (declarator
== error_mark_node
)
2974 return error_mark_node
;
2976 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2978 if (!explicit_instantiation
)
2979 /* A specialization in class scope. This is invalid,
2980 but the error will already have been flagged by
2981 check_specialization_scope. */
2982 return error_mark_node
;
2985 /* It's not valid to write an explicit instantiation in
2988 class C { template void f(); }
2990 This case is caught by the parser. However, on
2993 template class C { void f(); };
2995 (which is invalid) we can get here. The error will be
3002 else if (ctype
!= NULL_TREE
3003 && (identifier_p (TREE_OPERAND (declarator
, 0))))
3005 // We'll match variable templates in start_decl.
3009 /* Find the list of functions in ctype that have the same
3010 name as the declared function. */
3011 tree name
= TREE_OPERAND (declarator
, 0);
3013 if (constructor_name_p (name
, ctype
))
3015 if (DECL_CONSTRUCTOR_P (decl
)
3016 ? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
3017 : !CLASSTYPE_DESTRUCTOR (ctype
))
3019 /* From [temp.expl.spec]:
3021 If such an explicit specialization for the member
3022 of a class template names an implicitly-declared
3023 special member function (clause _special_), the
3024 program is ill-formed.
3026 Similar language is found in [temp.explicit]. */
3027 error ("specialization of implicitly-declared special member function");
3028 return error_mark_node
;
3031 name
= DECL_NAME (decl
);
3034 /* For a type-conversion operator, We might be looking for
3035 `operator int' which will be a specialization of
3036 `operator T'. Grab all the conversion operators, and
3037 then select from them. */
3038 tree fns
= get_class_binding (ctype
, IDENTIFIER_CONV_OP_P (name
)
3039 ? conv_op_identifier
: name
);
3041 if (fns
== NULL_TREE
)
3043 error ("no member function %qD declared in %qT", name
, ctype
);
3044 return error_mark_node
;
3047 TREE_OPERAND (declarator
, 0) = fns
;
3050 /* Figure out what exactly is being specialized at this point.
3051 Note that for an explicit instantiation, even one for a
3052 member function, we cannot tell a priori whether the
3053 instantiation is for a member template, or just a member
3054 function of a template class. Even if a member template is
3055 being instantiated, the member template arguments may be
3056 elided if they can be deduced from the rest of the
3058 tmpl
= determine_specialization (declarator
, decl
,
3060 member_specialization
,
3064 if (!tmpl
|| tmpl
== error_mark_node
)
3065 /* We couldn't figure out what this declaration was
3067 return error_mark_node
;
3070 if (TREE_CODE (decl
) == FUNCTION_DECL
3071 && DECL_HIDDEN_FRIEND_P (tmpl
))
3073 if (pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
3074 "friend declaration %qD is not visible to "
3075 "explicit specialization", tmpl
))
3076 inform (DECL_SOURCE_LOCATION (tmpl
),
3077 "friend declaration here");
3079 else if (!ctype
&& !is_friend
3080 && CP_DECL_CONTEXT (decl
) == current_namespace
)
3081 check_unqualified_spec_or_inst (tmpl
, DECL_SOURCE_LOCATION (decl
));
3083 tree gen_tmpl
= most_general_template (tmpl
);
3085 if (explicit_instantiation
)
3087 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
3088 is done by do_decl_instantiation later. */
3090 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
3091 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
3093 if (arg_depth
> parm_depth
)
3095 /* If TMPL is not the most general template (for
3096 example, if TMPL is a friend template that is
3097 injected into namespace scope), then there will
3098 be too many levels of TARGS. Remove some of them
3103 new_targs
= make_tree_vec (parm_depth
);
3104 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
3105 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
3106 = TREE_VEC_ELT (targs
, i
);
3110 return instantiate_template (tmpl
, targs
, tf_error
);
3113 /* If we thought that the DECL was a member function, but it
3114 turns out to be specializing a static member function,
3115 make DECL a static member function as well. */
3116 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
3117 && DECL_STATIC_FUNCTION_P (tmpl
)
3118 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
3119 revert_static_member_fn (decl
);
3121 /* If this is a specialization of a member template of a
3122 template class, we want to return the TEMPLATE_DECL, not
3123 the specialization of it. */
3124 if (tsk
== tsk_template
&& !was_template_id
)
3126 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
3127 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
3128 DECL_INITIAL (result
) = NULL_TREE
;
3132 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
3133 DECL_SOURCE_LOCATION (result
)
3134 = DECL_SOURCE_LOCATION (decl
);
3135 /* We want to use the argument list specified in the
3136 definition, not in the original declaration. */
3137 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
3138 for (parm
= DECL_ARGUMENTS (result
); parm
;
3139 parm
= DECL_CHAIN (parm
))
3140 DECL_CONTEXT (parm
) = result
;
3142 return register_specialization (tmpl
, gen_tmpl
, targs
,
3146 /* Set up the DECL_TEMPLATE_INFO for DECL. */
3147 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
3149 if (was_template_id
)
3150 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
)) = true;
3152 /* Inherit default function arguments from the template
3153 DECL is specializing. */
3154 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
3155 copy_default_args_to_explicit_spec (decl
);
3157 /* This specialization has the same protection as the
3158 template it specializes. */
3159 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
3160 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
3162 /* 7.1.1-1 [dcl.stc]
3164 A storage-class-specifier shall not be specified in an
3165 explicit specialization...
3167 The parser rejects these, so unless action is taken here,
3168 explicit function specializations will always appear with
3171 The action recommended by the C++ CWG in response to C++
3172 defect report 605 is to make the storage class and linkage
3173 of the explicit specialization match the templated function:
3175 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3177 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
3179 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
3180 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
3182 /* A concept cannot be specialized. */
3183 if (DECL_DECLARED_CONCEPT_P (tmpl_func
))
3185 error ("explicit specialization of function concept %qD",
3187 return error_mark_node
;
3190 /* This specialization has the same linkage and visibility as
3191 the function template it specializes. */
3192 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
3193 if (! TREE_PUBLIC (decl
))
3195 DECL_INTERFACE_KNOWN (decl
) = 1;
3196 DECL_NOT_REALLY_EXTERN (decl
) = 1;
3198 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
3199 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
3201 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3202 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
3206 /* If DECL is a friend declaration, declared using an
3207 unqualified name, the namespace associated with DECL may
3208 have been set incorrectly. For example, in:
3210 template <typename T> void f(T);
3212 struct S { friend void f<int>(int); }
3215 we will have set the DECL_CONTEXT for the friend
3216 declaration to N, rather than to the global namespace. */
3217 if (DECL_NAMESPACE_SCOPE_P (decl
))
3218 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
3220 if (is_friend
&& !have_def
)
3221 /* This is not really a declaration of a specialization.
3222 It's just the name of an instantiation. But, it's not
3223 a request for an instantiation, either. */
3224 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
3225 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3226 /* A specialization is not necessarily COMDAT. */
3227 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
3228 && DECL_DECLARED_INLINE_P (decl
));
3229 else if (VAR_P (decl
))
3230 DECL_COMDAT (decl
) = false;
3232 /* If this is a full specialization, register it so that we can find
3233 it again. Partial specializations will be registered in
3234 process_partial_specialization. */
3235 if (!processing_template_decl
)
3237 warn_spec_missing_attributes (gen_tmpl
, decl
, attrlist
);
3239 decl
= register_specialization (decl
, gen_tmpl
, targs
,
3244 /* A 'structor should already have clones. */
3245 gcc_assert (decl
== error_mark_node
3246 || variable_template_p (tmpl
)
3247 || !(DECL_CONSTRUCTOR_P (decl
)
3248 || DECL_DESTRUCTOR_P (decl
))
3249 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
3256 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3257 parameters. These are represented in the same format used for
3258 DECL_TEMPLATE_PARMS. */
3261 comp_template_parms (const_tree parms1
, const_tree parms2
)
3266 if (parms1
== parms2
)
3269 for (p1
= parms1
, p2
= parms2
;
3270 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
3271 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
3273 tree t1
= TREE_VALUE (p1
);
3274 tree t2
= TREE_VALUE (p2
);
3277 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
3278 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
3280 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3283 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
3285 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
3286 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
3288 /* If either of the template parameters are invalid, assume
3289 they match for the sake of error recovery. */
3290 if (error_operand_p (parm1
) || error_operand_p (parm2
))
3293 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
3296 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
3297 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
3298 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
3300 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
3305 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
3306 /* One set of parameters has more parameters lists than the
3313 /* Determine whether PARM is a parameter pack. */
3316 template_parameter_pack_p (const_tree parm
)
3318 /* Determine if we have a non-type template parameter pack. */
3319 if (TREE_CODE (parm
) == PARM_DECL
)
3320 return (DECL_TEMPLATE_PARM_P (parm
)
3321 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
3322 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
3323 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
3325 /* If this is a list of template parameters, we could get a
3326 TYPE_DECL or a TEMPLATE_DECL. */
3327 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
3328 parm
= TREE_TYPE (parm
);
3330 /* Otherwise it must be a type template parameter. */
3331 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
3332 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
3333 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
3336 /* Determine if T is a function parameter pack. */
3339 function_parameter_pack_p (const_tree t
)
3341 if (t
&& TREE_CODE (t
) == PARM_DECL
)
3342 return DECL_PACK_P (t
);
3346 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3347 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3350 get_function_template_decl (const_tree primary_func_tmpl_inst
)
3352 if (! primary_func_tmpl_inst
3353 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
3354 || ! primary_template_specialization_p (primary_func_tmpl_inst
))
3357 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
3360 /* Return true iff the function parameter PARAM_DECL was expanded
3361 from the function parameter pack PACK. */
3364 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
3366 if (DECL_ARTIFICIAL (param_decl
)
3367 || !function_parameter_pack_p (pack
))
3370 /* The parameter pack and its pack arguments have the same
3372 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
3375 /* Determine whether ARGS describes a variadic template args list,
3376 i.e., one that is terminated by a template argument pack. */
3379 template_args_variadic_p (tree args
)
3384 if (args
== NULL_TREE
)
3387 args
= INNERMOST_TEMPLATE_ARGS (args
);
3388 nargs
= TREE_VEC_LENGTH (args
);
3393 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
3395 return ARGUMENT_PACK_P (last_parm
);
3398 /* Generate a new name for the parameter pack name NAME (an
3399 IDENTIFIER_NODE) that incorporates its */
3402 make_ith_pack_parameter_name (tree name
, int i
)
3404 /* Munge the name to include the parameter index. */
3405 #define NUMBUF_LEN 128
3406 char numbuf
[NUMBUF_LEN
];
3410 if (name
== NULL_TREE
)
3412 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
3413 newname_len
= IDENTIFIER_LENGTH (name
)
3414 + strlen (numbuf
) + 2;
3415 newname
= (char*)alloca (newname_len
);
3416 snprintf (newname
, newname_len
,
3417 "%s#%i", IDENTIFIER_POINTER (name
), i
);
3418 return get_identifier (newname
);
3421 /* Return true if T is a primary function, class or alias template
3422 specialization, not including the template pattern. */
3425 primary_template_specialization_p (const_tree t
)
3430 if (TREE_CODE (t
) == FUNCTION_DECL
|| VAR_P (t
))
3431 return (DECL_LANG_SPECIFIC (t
)
3432 && DECL_USE_TEMPLATE (t
)
3433 && DECL_TEMPLATE_INFO (t
)
3434 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)));
3435 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3436 return (CLASSTYPE_TEMPLATE_INFO (t
)
3437 && CLASSTYPE_USE_TEMPLATE (t
)
3438 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
3439 else if (alias_template_specialization_p (t
))
3444 /* Return true if PARM is a template template parameter. */
3447 template_template_parameter_p (const_tree parm
)
3449 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3452 /* Return true iff PARM is a DECL representing a type template
3456 template_type_parameter_p (const_tree parm
)
3459 && (TREE_CODE (parm
) == TYPE_DECL
3460 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3461 && DECL_TEMPLATE_PARM_P (parm
));
3464 /* Return the template parameters of T if T is a
3465 primary template instantiation, NULL otherwise. */
3468 get_primary_template_innermost_parameters (const_tree t
)
3470 tree parms
= NULL
, template_info
= NULL
;
3472 if ((template_info
= get_template_info (t
))
3473 && primary_template_specialization_p (t
))
3474 parms
= INNERMOST_TEMPLATE_PARMS
3475 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3480 /* Return the template parameters of the LEVELth level from the full list
3481 of template parameters PARMS. */
3484 get_template_parms_at_level (tree parms
, int level
)
3488 || TREE_CODE (parms
) != TREE_LIST
3489 || level
> TMPL_PARMS_DEPTH (parms
))
3492 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3493 if (TMPL_PARMS_DEPTH (p
) == level
)
3499 /* Returns the template arguments of T if T is a template instantiation,
3503 get_template_innermost_arguments (const_tree t
)
3505 tree args
= NULL
, template_info
= NULL
;
3507 if ((template_info
= get_template_info (t
))
3508 && TI_ARGS (template_info
))
3509 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3514 /* Return the argument pack elements of T if T is a template argument pack,
3518 get_template_argument_pack_elems (const_tree t
)
3520 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3521 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3524 return ARGUMENT_PACK_ARGS (t
);
3527 /* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the
3528 ARGUMENT_PACK_SELECT represents. */
3531 argument_pack_select_arg (tree t
)
3533 tree args
= ARGUMENT_PACK_ARGS (ARGUMENT_PACK_SELECT_FROM_PACK (t
));
3534 tree arg
= TREE_VEC_ELT (args
, ARGUMENT_PACK_SELECT_INDEX (t
));
3536 /* If the selected argument is an expansion E, that most likely means we were
3537 called from gen_elem_of_pack_expansion_instantiation during the
3538 substituting of an argument pack (of which the Ith element is a pack
3539 expansion, where I is ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
3540 In this case, the Ith element resulting from this substituting is going to
3541 be a pack expansion, which pattern is the pattern of E. Let's return the
3542 pattern of E, and gen_elem_of_pack_expansion_instantiation will build the
3543 resulting pack expansion from it. */
3544 if (PACK_EXPANSION_P (arg
))
3546 /* Make sure we aren't throwing away arg info. */
3547 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
3548 arg
= PACK_EXPANSION_PATTERN (arg
);
3555 /* True iff FN is a function representing a built-in variadic parameter
3559 builtin_pack_fn_p (tree fn
)
3562 || TREE_CODE (fn
) != FUNCTION_DECL
3563 || !DECL_IS_BUILTIN (fn
))
3566 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3572 /* True iff CALL is a call to a function representing a built-in variadic
3576 builtin_pack_call_p (tree call
)
3578 if (TREE_CODE (call
) != CALL_EXPR
)
3580 return builtin_pack_fn_p (CALL_EXPR_FN (call
));
3583 /* Return a TREE_VEC for the expansion of __integer_pack(HI). */
3586 expand_integer_pack (tree call
, tree args
, tsubst_flags_t complain
,
3589 tree ohi
= CALL_EXPR_ARG (call
, 0);
3590 tree hi
= tsubst_copy_and_build (ohi
, args
, complain
, in_decl
,
3591 false/*fn*/, true/*int_cst*/);
3593 if (value_dependent_expression_p (hi
))
3597 call
= copy_node (call
);
3598 CALL_EXPR_ARG (call
, 0) = hi
;
3600 tree ex
= make_pack_expansion (call
, complain
);
3601 tree vec
= make_tree_vec (1);
3602 TREE_VEC_ELT (vec
, 0) = ex
;
3607 hi
= cxx_constant_value (hi
);
3608 int len
= valid_constant_size_p (hi
) ? tree_to_shwi (hi
) : -1;
3610 /* Calculate the largest value of len that won't make the size of the vec
3611 overflow an int. The compiler will exceed resource limits long before
3612 this, but it seems a decent place to diagnose. */
3613 int max
= ((INT_MAX
- sizeof (tree_vec
)) / sizeof (tree
)) + 1;
3615 if (len
< 0 || len
> max
)
3617 if ((complain
& tf_error
)
3618 && hi
!= error_mark_node
)
3619 error ("argument to __integer_pack must be between 0 and %d", max
);
3620 return error_mark_node
;
3623 tree vec
= make_tree_vec (len
);
3625 for (int i
= 0; i
< len
; ++i
)
3626 TREE_VEC_ELT (vec
, i
) = size_int (i
);
3632 /* Return a TREE_VEC for the expansion of built-in template parameter pack
3636 expand_builtin_pack_call (tree call
, tree args
, tsubst_flags_t complain
,
3639 if (!builtin_pack_call_p (call
))
3642 tree fn
= CALL_EXPR_FN (call
);
3644 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3645 return expand_integer_pack (call
, args
, complain
, in_decl
);
3650 /* Structure used to track the progress of find_parameter_packs_r. */
3651 struct find_parameter_pack_data
3653 /* TREE_LIST that will contain all of the parameter packs found by
3655 tree
* parameter_packs
;
3657 /* Set of AST nodes that have been visited by the traversal. */
3658 hash_set
<tree
> *visited
;
3660 /* True iff we're making a type pack expansion. */
3661 bool type_pack_expansion_p
;
3664 /* Identifies all of the argument packs that occur in a template
3665 argument and appends them to the TREE_LIST inside DATA, which is a
3666 find_parameter_pack_data structure. This is a subroutine of
3667 make_pack_expansion and uses_parameter_packs. */
3669 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3672 struct find_parameter_pack_data
* ppd
=
3673 (struct find_parameter_pack_data
*)data
;
3674 bool parameter_pack_p
= false;
3676 /* Handle type aliases/typedefs. */
3677 if (TYPE_ALIAS_P (t
))
3679 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
3680 cp_walk_tree (&TI_ARGS (tinfo
),
3681 &find_parameter_packs_r
,
3687 /* Identify whether this is a parameter pack or not. */
3688 switch (TREE_CODE (t
))
3690 case TEMPLATE_PARM_INDEX
:
3691 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3692 parameter_pack_p
= true;
3695 case TEMPLATE_TYPE_PARM
:
3696 t
= TYPE_MAIN_VARIANT (t
);
3698 case TEMPLATE_TEMPLATE_PARM
:
3699 /* If the placeholder appears in the decl-specifier-seq of a function
3700 parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3701 is a pack expansion, the invented template parameter is a template
3703 if (ppd
->type_pack_expansion_p
&& is_auto (t
))
3704 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
3705 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3706 parameter_pack_p
= true;
3711 if (DECL_PACK_P (t
))
3713 /* We don't want to walk into the type of a PARM_DECL,
3714 because we don't want to see the type parameter pack. */
3716 parameter_pack_p
= true;
3721 if (DECL_PACK_P (t
))
3723 /* We don't want to walk into the type of a variadic capture proxy,
3724 because we don't want to see the type parameter pack. */
3726 parameter_pack_p
= true;
3728 else if (variable_template_specialization_p (t
))
3730 cp_walk_tree (&DECL_TI_ARGS (t
),
3731 find_parameter_packs_r
,
3738 if (builtin_pack_call_p (t
))
3739 parameter_pack_p
= true;
3743 parameter_pack_p
= true;
3746 /* Not a parameter pack. */
3750 if (parameter_pack_p
)
3752 /* Add this parameter pack to the list. */
3753 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3757 cp_walk_tree (&TYPE_CONTEXT (t
),
3758 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3760 /* This switch statement will return immediately if we don't find a
3762 switch (TREE_CODE (t
))
3764 case TEMPLATE_PARM_INDEX
:
3767 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3768 /* Check the template itself. */
3769 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3770 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3771 /* Check the template arguments. */
3772 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3777 case TEMPLATE_TYPE_PARM
:
3778 case TEMPLATE_TEMPLATE_PARM
:
3785 /* Ignore the declaration of a capture proxy for a parameter pack. */
3786 if (is_capture_proxy (DECL_EXPR_DECL (t
)))
3791 if (TYPE_PTRMEMFUNC_P (t
))
3797 if (TYPE_TEMPLATE_INFO (t
))
3798 cp_walk_tree (&TYPE_TI_ARGS (t
),
3799 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3805 if (!DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
3810 cp_walk_tree (&TREE_TYPE (t
),
3811 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3815 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3820 case TYPE_PACK_EXPANSION
:
3821 case EXPR_PACK_EXPANSION
:
3826 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3831 case IDENTIFIER_NODE
:
3832 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3839 /* Look at explicit captures. */
3840 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
);
3841 cap
; cap
= TREE_CHAIN (cap
))
3842 cp_walk_tree (&TREE_VALUE (cap
), &find_parameter_packs_r
, ppd
,
3844 /* Since we defer implicit capture, look in the parms and body. */
3845 tree fn
= lambda_function (t
);
3846 cp_walk_tree (&TREE_TYPE (fn
), &find_parameter_packs_r
, ppd
,
3848 cp_walk_tree (&DECL_SAVED_TREE (fn
), &find_parameter_packs_r
, ppd
,
3856 /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
3857 type_pack_expansion_p to false so that any placeholders
3858 within the expression don't get marked as parameter packs. */
3859 bool type_pack_expansion_p
= ppd
->type_pack_expansion_p
;
3860 ppd
->type_pack_expansion_p
= false;
3861 cp_walk_tree (&DECLTYPE_TYPE_EXPR (t
), &find_parameter_packs_r
,
3863 ppd
->type_pack_expansion_p
= type_pack_expansion_p
;
3875 /* Determines if the expression or type T uses any parameter packs. */
3877 uses_parameter_packs (tree t
)
3879 tree parameter_packs
= NULL_TREE
;
3880 struct find_parameter_pack_data ppd
;
3881 ppd
.parameter_packs
= ¶meter_packs
;
3882 ppd
.visited
= new hash_set
<tree
>;
3883 ppd
.type_pack_expansion_p
= false;
3884 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3886 return parameter_packs
!= NULL_TREE
;
3889 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3890 representation a base-class initializer into a parameter pack
3891 expansion. If all goes well, the resulting node will be an
3892 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3895 make_pack_expansion (tree arg
, tsubst_flags_t complain
)
3898 tree parameter_packs
= NULL_TREE
;
3899 bool for_types
= false;
3900 struct find_parameter_pack_data ppd
;
3902 if (!arg
|| arg
== error_mark_node
)
3905 if (TREE_CODE (arg
) == TREE_LIST
&& TREE_PURPOSE (arg
))
3907 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3908 class initializer. In this case, the TREE_PURPOSE will be a
3909 _TYPE node (representing the base class expansion we're
3910 initializing) and the TREE_VALUE will be a TREE_LIST
3911 containing the initialization arguments.
3913 The resulting expansion looks somewhat different from most
3914 expansions. Rather than returning just one _EXPANSION, we
3915 return a TREE_LIST whose TREE_PURPOSE is a
3916 TYPE_PACK_EXPANSION containing the bases that will be
3917 initialized. The TREE_VALUE will be identical to the
3918 original TREE_VALUE, which is a list of arguments that will
3919 be passed to each base. We do not introduce any new pack
3920 expansion nodes into the TREE_VALUE (although it is possible
3921 that some already exist), because the TREE_PURPOSE and
3922 TREE_VALUE all need to be expanded together with the same
3923 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3924 resulting TREE_PURPOSE will mention the parameter packs in
3925 both the bases and the arguments to the bases. */
3928 tree parameter_packs
= NULL_TREE
;
3930 /* Determine which parameter packs will be used by the base
3932 ppd
.visited
= new hash_set
<tree
>;
3933 ppd
.parameter_packs
= ¶meter_packs
;
3934 ppd
.type_pack_expansion_p
= true;
3935 gcc_assert (TYPE_P (TREE_PURPOSE (arg
)));
3936 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3939 if (parameter_packs
== NULL_TREE
)
3941 if (complain
& tf_error
)
3942 error ("base initializer expansion %qT contains no parameter packs",
3945 return error_mark_node
;
3948 if (TREE_VALUE (arg
) != void_type_node
)
3950 /* Collect the sets of parameter packs used in each of the
3951 initialization arguments. */
3952 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3954 /* Determine which parameter packs will be expanded in this
3956 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3963 /* Create the pack expansion type for the base type. */
3964 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3965 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3966 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3967 PACK_EXPANSION_LOCAL_P (purpose
) = at_function_scope_p ();
3969 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3970 they will rarely be compared to anything. */
3971 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3973 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3976 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3979 /* Build the PACK_EXPANSION_* node. */
3981 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3982 : make_node (EXPR_PACK_EXPANSION
);
3983 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3984 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3986 /* Propagate type and const-expression information. */
3987 TREE_TYPE (result
) = TREE_TYPE (arg
);
3988 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3989 /* Mark this read now, since the expansion might be length 0. */
3990 mark_exp_read (arg
);
3993 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3994 they will rarely be compared to anything. */
3995 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3997 /* Determine which parameter packs will be expanded. */
3998 ppd
.parameter_packs
= ¶meter_packs
;
3999 ppd
.visited
= new hash_set
<tree
>;
4000 ppd
.type_pack_expansion_p
= TYPE_P (arg
);
4001 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
4004 /* Make sure we found some parameter packs. */
4005 if (parameter_packs
== NULL_TREE
)
4007 if (complain
& tf_error
)
4010 error ("expansion pattern %qT contains no parameter packs", arg
);
4012 error ("expansion pattern %qE contains no parameter packs", arg
);
4014 return error_mark_node
;
4016 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
4018 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
4023 /* Checks T for any "bare" parameter packs, which have not yet been
4024 expanded, and issues an error if any are found. This operation can
4025 only be done on full expressions or types (e.g., an expression
4026 statement, "if" condition, etc.), because we could have expressions like:
4028 foo(f(g(h(args)))...)
4030 where "args" is a parameter pack. check_for_bare_parameter_packs
4031 should not be called for the subexpressions args, h(args),
4032 g(h(args)), or f(g(h(args))), because we would produce erroneous
4035 Returns TRUE and emits an error if there were bare parameter packs,
4036 returns FALSE otherwise. */
4038 check_for_bare_parameter_packs (tree t
, location_t loc
/* = UNKNOWN_LOCATION */)
4040 tree parameter_packs
= NULL_TREE
;
4041 struct find_parameter_pack_data ppd
;
4043 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
4046 /* A lambda might use a parameter pack from the containing context. */
4047 if (current_class_type
&& LAMBDA_TYPE_P (current_class_type
)
4048 && CLASSTYPE_TEMPLATE_INFO (current_class_type
))
4051 if (TREE_CODE (t
) == TYPE_DECL
)
4054 ppd
.parameter_packs
= ¶meter_packs
;
4055 ppd
.visited
= new hash_set
<tree
>;
4056 ppd
.type_pack_expansion_p
= false;
4057 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
4060 if (parameter_packs
)
4062 if (loc
== UNKNOWN_LOCATION
)
4063 loc
= cp_expr_loc_or_loc (t
, input_location
);
4064 error_at (loc
, "parameter packs not expanded with %<...%>:");
4065 while (parameter_packs
)
4067 tree pack
= TREE_VALUE (parameter_packs
);
4068 tree name
= NULL_TREE
;
4070 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
4071 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
4072 name
= TYPE_NAME (pack
);
4073 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
4074 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
4075 else if (TREE_CODE (pack
) == CALL_EXPR
)
4076 name
= DECL_NAME (CALL_EXPR_FN (pack
));
4078 name
= DECL_NAME (pack
);
4081 inform (loc
, " %qD", name
);
4083 inform (loc
, " <anonymous>");
4085 parameter_packs
= TREE_CHAIN (parameter_packs
);
4094 /* Expand any parameter packs that occur in the template arguments in
4097 expand_template_argument_pack (tree args
)
4099 if (args
== error_mark_node
)
4100 return error_mark_node
;
4102 tree result_args
= NULL_TREE
;
4103 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
4104 int num_result_args
= -1;
4105 int non_default_args_count
= -1;
4107 /* First, determine if we need to expand anything, and the number of
4108 slots we'll need. */
4109 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
4111 tree arg
= TREE_VEC_ELT (args
, in_arg
);
4112 if (arg
== NULL_TREE
)
4114 if (ARGUMENT_PACK_P (arg
))
4116 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
4117 if (num_result_args
< 0)
4118 num_result_args
= in_arg
+ num_packed
;
4120 num_result_args
+= num_packed
;
4124 if (num_result_args
>= 0)
4129 /* If no expansion is necessary, we're done. */
4130 if (num_result_args
< 0)
4133 /* Expand arguments. */
4134 result_args
= make_tree_vec (num_result_args
);
4135 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
4136 non_default_args_count
=
4137 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
4138 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
4140 tree arg
= TREE_VEC_ELT (args
, in_arg
);
4141 if (ARGUMENT_PACK_P (arg
))
4143 tree packed
= ARGUMENT_PACK_ARGS (arg
);
4144 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
4145 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
4146 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
4147 if (non_default_args_count
> 0)
4148 non_default_args_count
+= num_packed
- 1;
4152 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
4156 if (non_default_args_count
>= 0)
4157 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
4161 /* Checks if DECL shadows a template parameter.
4163 [temp.local]: A template-parameter shall not be redeclared within its
4164 scope (including nested scopes).
4166 Emits an error and returns TRUE if the DECL shadows a parameter,
4167 returns FALSE otherwise. */
4170 check_template_shadow (tree decl
)
4174 /* If we're not in a template, we can't possibly shadow a template
4176 if (!current_template_parms
)
4179 /* Figure out what we're shadowing. */
4180 decl
= OVL_FIRST (decl
);
4181 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
4183 /* If there's no previous binding for this name, we're not shadowing
4184 anything, let alone a template parameter. */
4188 /* If we're not shadowing a template parameter, we're done. Note
4189 that OLDDECL might be an OVERLOAD (or perhaps even an
4190 ERROR_MARK), so we can't just blithely assume it to be a _DECL
4192 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
4195 /* We check for decl != olddecl to avoid bogus errors for using a
4196 name inside a class. We check TPFI to avoid duplicate errors for
4197 inline member templates. */
4199 || (DECL_TEMPLATE_PARM_P (decl
)
4200 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
4203 /* Don't complain about the injected class name, as we've already
4204 complained about the class itself. */
4205 if (DECL_SELF_REFERENCE_P (decl
))
4208 if (DECL_TEMPLATE_PARM_P (decl
))
4209 error ("declaration of template parameter %q+D shadows "
4210 "template parameter", decl
);
4212 error ("declaration of %q+#D shadows template parameter", decl
);
4213 inform (DECL_SOURCE_LOCATION (olddecl
),
4214 "template parameter %qD declared here", olddecl
);
4218 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
4219 ORIG_LEVEL, DECL, and TYPE. */
4222 build_template_parm_index (int index
,
4228 tree t
= make_node (TEMPLATE_PARM_INDEX
);
4229 TEMPLATE_PARM_IDX (t
) = index
;
4230 TEMPLATE_PARM_LEVEL (t
) = level
;
4231 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
4232 TEMPLATE_PARM_DECL (t
) = decl
;
4233 TREE_TYPE (t
) = type
;
4234 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
4235 TREE_READONLY (t
) = TREE_READONLY (decl
);
4240 /* Find the canonical type parameter for the given template type
4241 parameter. Returns the canonical type parameter, which may be TYPE
4242 if no such parameter existed. */
4245 canonical_type_parameter (tree type
)
4248 int idx
= TEMPLATE_TYPE_IDX (type
);
4249 if (!canonical_template_parms
)
4250 vec_alloc (canonical_template_parms
, idx
+ 1);
4252 if (canonical_template_parms
->length () <= (unsigned) idx
)
4253 vec_safe_grow_cleared (canonical_template_parms
, idx
+ 1);
4255 list
= (*canonical_template_parms
)[idx
];
4256 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
4257 list
= TREE_CHAIN (list
);
4260 return TREE_VALUE (list
);
4263 (*canonical_template_parms
)[idx
]
4264 = tree_cons (NULL_TREE
, type
, (*canonical_template_parms
)[idx
]);
4269 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
4270 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
4271 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
4272 new one is created. */
4275 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
4276 tsubst_flags_t complain
)
4278 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
4279 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
4280 != TEMPLATE_PARM_LEVEL (index
) - levels
)
4281 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
4283 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
4286 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
4287 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
4288 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
4289 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
4290 DECL_ARTIFICIAL (decl
) = 1;
4291 SET_DECL_TEMPLATE_PARM_P (decl
);
4293 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
4294 TEMPLATE_PARM_LEVEL (index
) - levels
,
4295 TEMPLATE_PARM_ORIG_LEVEL (index
),
4297 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
4298 TEMPLATE_PARM_PARAMETER_PACK (t
)
4299 = TEMPLATE_PARM_PARAMETER_PACK (index
);
4301 /* Template template parameters need this. */
4302 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4304 DECL_TEMPLATE_RESULT (decl
)
4305 = build_decl (DECL_SOURCE_LOCATION (decl
),
4306 TYPE_DECL
, DECL_NAME (decl
), type
);
4307 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (decl
)) = true;
4308 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
4309 (DECL_TEMPLATE_PARMS (orig_decl
), args
, complain
);
4313 return TEMPLATE_PARM_DESCENDANTS (index
);
4316 /* Process information from new template parameter PARM and append it
4317 to the LIST being built. This new parameter is a non-type
4318 parameter iff IS_NON_TYPE is true. This new parameter is a
4319 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4323 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
4324 bool is_non_type
, bool is_parameter_pack
)
4329 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
4330 tree defval
= TREE_PURPOSE (parm
);
4331 tree constr
= TREE_TYPE (parm
);
4335 tree p
= tree_last (list
);
4337 if (p
&& TREE_VALUE (p
) != error_mark_node
)
4340 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
4341 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
4343 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
4351 parm
= TREE_VALUE (parm
);
4353 SET_DECL_TEMPLATE_PARM_P (parm
);
4355 if (TREE_TYPE (parm
) != error_mark_node
)
4359 The top-level cv-qualifiers on the template-parameter are
4360 ignored when determining its type. */
4361 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
4362 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
4363 TREE_TYPE (parm
) = error_mark_node
;
4364 else if (uses_parameter_packs (TREE_TYPE (parm
))
4365 && !is_parameter_pack
4366 /* If we're in a nested template parameter list, the template
4367 template parameter could be a parameter pack. */
4368 && processing_template_parmlist
== 1)
4370 /* This template parameter is not a parameter pack, but it
4371 should be. Complain about "bare" parameter packs. */
4372 check_for_bare_parameter_packs (TREE_TYPE (parm
));
4374 /* Recover by calling this a parameter pack. */
4375 is_parameter_pack
= true;
4379 /* A template parameter is not modifiable. */
4380 TREE_CONSTANT (parm
) = 1;
4381 TREE_READONLY (parm
) = 1;
4382 decl
= build_decl (parm_loc
,
4383 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
4384 TREE_CONSTANT (decl
) = 1;
4385 TREE_READONLY (decl
) = 1;
4386 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
4387 = build_template_parm_index (idx
, processing_template_decl
,
4388 processing_template_decl
,
4389 decl
, TREE_TYPE (parm
));
4391 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
4392 = is_parameter_pack
;
4397 parm
= TREE_VALUE (TREE_VALUE (parm
));
4399 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
4401 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
4402 /* This is for distinguishing between real templates and template
4403 template parameters */
4404 TREE_TYPE (parm
) = t
;
4405 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
4410 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
4411 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4412 decl
= build_decl (parm_loc
,
4413 TYPE_DECL
, parm
, t
);
4416 TYPE_NAME (t
) = decl
;
4417 TYPE_STUB_DECL (t
) = decl
;
4419 TEMPLATE_TYPE_PARM_INDEX (t
)
4420 = build_template_parm_index (idx
, processing_template_decl
,
4421 processing_template_decl
,
4422 decl
, TREE_TYPE (parm
));
4423 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
4424 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
4426 DECL_ARTIFICIAL (decl
) = 1;
4427 SET_DECL_TEMPLATE_PARM_P (decl
);
4429 /* Build requirements for the type/template parameter.
4430 This must be done after SET_DECL_TEMPLATE_PARM_P or
4431 process_template_parm could fail. */
4432 tree reqs
= finish_shorthand_constraint (parm
, constr
);
4436 /* Build the parameter node linking the parameter declaration,
4437 its default argument (if any), and its constraints (if any). */
4438 parm
= build_tree_list (defval
, parm
);
4439 TEMPLATE_PARM_CONSTRAINTS (parm
) = reqs
;
4441 return chainon (list
, parm
);
4444 /* The end of a template parameter list has been reached. Process the
4445 tree list into a parameter vector, converting each parameter into a more
4446 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4450 end_template_parm_list (tree parms
)
4454 tree saved_parmlist
= make_tree_vec (list_length (parms
));
4456 /* Pop the dummy parameter level and add the real one. */
4457 current_template_parms
= TREE_CHAIN (current_template_parms
);
4459 current_template_parms
4460 = tree_cons (size_int (processing_template_decl
),
4461 saved_parmlist
, current_template_parms
);
4463 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
4465 next
= TREE_CHAIN (parm
);
4466 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
4467 TREE_CHAIN (parm
) = NULL_TREE
;
4470 --processing_template_parmlist
;
4472 return saved_parmlist
;
4475 // Explicitly indicate the end of the template parameter list. We assume
4476 // that the current template parameters have been constructed and/or
4477 // managed explicitly, as when creating new template template parameters
4478 // from a shorthand constraint.
4480 end_template_parm_list ()
4482 --processing_template_parmlist
;
4485 /* end_template_decl is called after a template declaration is seen. */
4488 end_template_decl (void)
4490 reset_specialization ();
4492 if (! processing_template_decl
)
4495 /* This matches the pushlevel in begin_template_parm_list. */
4498 --processing_template_decl
;
4499 current_template_parms
= TREE_CHAIN (current_template_parms
);
4502 /* Takes a TREE_LIST representing a template parameter and convert it
4503 into an argument suitable to be passed to the type substitution
4504 functions. Note that If the TREE_LIST contains an error_mark
4505 node, the returned argument is error_mark_node. */
4508 template_parm_to_arg (tree t
)
4512 || TREE_CODE (t
) != TREE_LIST
)
4515 if (error_operand_p (TREE_VALUE (t
)))
4516 return error_mark_node
;
4520 if (TREE_CODE (t
) == TYPE_DECL
4521 || TREE_CODE (t
) == TEMPLATE_DECL
)
4525 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
4527 /* Turn this argument into a TYPE_ARGUMENT_PACK
4528 with a single element, which expands T. */
4529 tree vec
= make_tree_vec (1);
4531 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4533 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4535 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
4536 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4541 t
= DECL_INITIAL (t
);
4543 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
4545 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4546 with a single element, which expands T. */
4547 tree vec
= make_tree_vec (1);
4549 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4551 t
= convert_from_reference (t
);
4552 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4554 t
= make_node (NONTYPE_ARGUMENT_PACK
);
4555 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4558 t
= convert_from_reference (t
);
4563 /* Given a single level of template parameters (a TREE_VEC), return it
4564 as a set of template arguments. */
4567 template_parms_level_to_args (tree parms
)
4569 tree a
= copy_node (parms
);
4570 TREE_TYPE (a
) = NULL_TREE
;
4571 for (int i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
4572 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
4575 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
4580 /* Given a set of template parameters, return them as a set of template
4581 arguments. The template parameters are represented as a TREE_VEC, in
4582 the form documented in cp-tree.h for template arguments. */
4585 template_parms_to_args (tree parms
)
4588 tree args
= NULL_TREE
;
4589 int length
= TMPL_PARMS_DEPTH (parms
);
4592 /* If there is only one level of template parameters, we do not
4593 create a TREE_VEC of TREE_VECs. Instead, we return a single
4594 TREE_VEC containing the arguments. */
4596 args
= make_tree_vec (length
);
4598 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
4600 tree a
= template_parms_level_to_args (TREE_VALUE (header
));
4603 TREE_VEC_ELT (args
, --l
) = a
;
4611 /* Within the declaration of a template, return the currently active
4612 template parameters as an argument TREE_VEC. */
4615 current_template_args (void)
4617 return template_parms_to_args (current_template_parms
);
4620 /* Update the declared TYPE by doing any lookups which were thought to be
4621 dependent, but are not now that we know the SCOPE of the declarator. */
4624 maybe_update_decl_type (tree orig_type
, tree scope
)
4626 tree type
= orig_type
;
4628 if (type
== NULL_TREE
)
4631 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4632 type
= TREE_TYPE (type
);
4634 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
4635 && dependent_type_p (type
)
4636 /* Don't bother building up the args in this case. */
4637 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
4639 /* tsubst in the args corresponding to the template parameters,
4640 including auto if present. Most things will be unchanged, but
4641 make_typename_type and tsubst_qualified_id will resolve
4642 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4643 tree args
= current_template_args ();
4644 tree auto_node
= type_uses_auto (type
);
4648 tree auto_vec
= make_tree_vec (1);
4649 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4650 args
= add_to_template_args (args
, auto_vec
);
4652 pushed
= push_scope (scope
);
4653 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4658 if (type
== error_mark_node
)
4661 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4663 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4666 type
= TYPE_NAME (type
);
4671 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4672 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4673 the new template is a member template. */
4676 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4678 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4679 SET_DECL_LANGUAGE (tmpl
, DECL_LANGUAGE (decl
));
4680 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4681 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4682 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4683 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4688 struct template_parm_data
4690 /* The level of the template parameters we are currently
4694 /* The index of the specialization argument we are currently
4698 /* An array whose size is the number of template parameters. The
4699 elements are nonzero if the parameter has been used in any one
4700 of the arguments processed so far. */
4703 /* An array whose size is the number of template arguments. The
4704 elements are nonzero if the argument makes use of template
4705 parameters of this level. */
4706 int* arg_uses_template_parms
;
4709 /* Subroutine of push_template_decl used to see if each template
4710 parameter in a partial specialization is used in the explicit
4711 argument list. If T is of the LEVEL given in DATA (which is
4712 treated as a template_parm_data*), then DATA->PARMS is marked
4716 mark_template_parm (tree t
, void* data
)
4720 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4722 template_parm_level_and_index (t
, &level
, &idx
);
4724 if (level
== tpd
->level
)
4726 tpd
->parms
[idx
] = 1;
4727 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4730 /* In C++17 the type of a non-type argument is a deduced context. */
4731 if (cxx_dialect
>= cxx17
4732 && TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4733 for_each_template_parm (TREE_TYPE (t
),
4734 &mark_template_parm
,
4737 /*include_nondeduced_p=*/false);
4739 /* Return zero so that for_each_template_parm will continue the
4740 traversal of the tree; we want to mark *every* template parm. */
4744 /* Process the partial specialization DECL. */
4747 process_partial_specialization (tree decl
)
4749 tree type
= TREE_TYPE (decl
);
4750 tree tinfo
= get_template_info (decl
);
4751 tree maintmpl
= TI_TEMPLATE (tinfo
);
4752 tree specargs
= TI_ARGS (tinfo
);
4753 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4754 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4757 int nargs
= TREE_VEC_LENGTH (inner_args
);
4760 bool did_error_intro
= false;
4761 struct template_parm_data tpd
;
4762 struct template_parm_data tpd2
;
4764 gcc_assert (current_template_parms
);
4766 /* A concept cannot be specialized. */
4767 if (flag_concepts
&& variable_concept_p (maintmpl
))
4769 error ("specialization of variable concept %q#D", maintmpl
);
4770 return error_mark_node
;
4773 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4774 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4776 /* We check that each of the template parameters given in the
4777 partial specialization is used in the argument list to the
4778 specialization. For example:
4780 template <class T> struct S;
4781 template <class T> struct S<T*>;
4783 The second declaration is OK because `T*' uses the template
4784 parameter T, whereas
4786 template <class T> struct S<int>;
4788 is no good. Even trickier is:
4799 The S2<T> declaration is actually invalid; it is a
4800 full-specialization. Of course,
4803 struct S2<T (*)(U)>;
4805 or some such would have been OK. */
4806 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4807 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4808 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4810 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4811 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4812 for (i
= 0; i
< nargs
; ++i
)
4814 tpd
.current_arg
= i
;
4815 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4816 &mark_template_parm
,
4819 /*include_nondeduced_p=*/false);
4821 for (i
= 0; i
< ntparms
; ++i
)
4822 if (tpd
.parms
[i
] == 0)
4824 /* One of the template parms was not used in a deduced context in the
4826 if (!did_error_intro
)
4828 error ("template parameters not deducible in "
4829 "partial specialization:");
4830 did_error_intro
= true;
4833 inform (input_location
, " %qD",
4834 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4837 if (did_error_intro
)
4838 return error_mark_node
;
4840 /* [temp.class.spec]
4842 The argument list of the specialization shall not be identical to
4843 the implicit argument list of the primary template. */
4845 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl
)));
4846 if (comp_template_args (inner_args
, INNERMOST_TEMPLATE_ARGS (main_args
))
4848 || !strictly_subsumes (current_template_constraints (),
4849 get_constraints (maintmpl
))))
4852 error ("partial specialization %q+D does not specialize "
4853 "any template arguments; to define the primary template, "
4854 "remove the template argument list", decl
);
4856 error ("partial specialization %q+D does not specialize any "
4857 "template arguments and is not more constrained than "
4858 "the primary template; to define the primary template, "
4859 "remove the template argument list", decl
);
4860 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4863 /* A partial specialization that replaces multiple parameters of the
4864 primary template with a pack expansion is less specialized for those
4866 if (nargs
< DECL_NTPARMS (maintmpl
))
4868 error ("partial specialization is not more specialized than the "
4869 "primary template because it replaces multiple parameters "
4870 "with a pack expansion");
4871 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4872 /* Avoid crash in process_partial_specialization. */
4876 /* If we aren't in a dependent class, we can actually try deduction. */
4877 else if (tpd
.level
== 1
4878 /* FIXME we should be able to handle a partial specialization of a
4879 partial instantiation, but currently we can't (c++/41727). */
4880 && TMPL_ARGS_DEPTH (specargs
) == 1
4881 && !get_partial_spec_bindings (maintmpl
, maintmpl
, specargs
))
4883 if (permerror (input_location
, "partial specialization %qD is not "
4884 "more specialized than", decl
))
4885 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template %qD",
4889 /* [temp.class.spec]
4891 A partially specialized non-type argument expression shall not
4892 involve template parameters of the partial specialization except
4893 when the argument expression is a simple identifier.
4895 The type of a template parameter corresponding to a specialized
4896 non-type argument shall not be dependent on a parameter of the
4899 Also, we verify that pack expansions only occur at the
4900 end of the argument list. */
4901 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4903 for (i
= 0; i
< nargs
; ++i
)
4905 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4906 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4907 tree packed_args
= NULL_TREE
;
4910 if (ARGUMENT_PACK_P (arg
))
4912 /* Extract the arguments from the argument pack. We'll be
4913 iterating over these in the following loop. */
4914 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4915 len
= TREE_VEC_LENGTH (packed_args
);
4918 for (j
= 0; j
< len
; j
++)
4921 /* Get the Jth argument in the parameter pack. */
4922 arg
= TREE_VEC_ELT (packed_args
, j
);
4924 if (PACK_EXPANSION_P (arg
))
4926 /* Pack expansions must come at the end of the
4928 if ((packed_args
&& j
< len
- 1)
4929 || (!packed_args
&& i
< nargs
- 1))
4931 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4932 error ("parameter pack argument %qE must be at the "
4933 "end of the template argument list", arg
);
4935 error ("parameter pack argument %qT must be at the "
4936 "end of the template argument list", arg
);
4940 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4941 /* We only care about the pattern. */
4942 arg
= PACK_EXPANSION_PATTERN (arg
);
4944 if (/* These first two lines are the `non-type' bit. */
4946 && TREE_CODE (arg
) != TEMPLATE_DECL
4947 /* This next two lines are the `argument expression is not just a
4948 simple identifier' condition and also the `specialized
4949 non-type argument' bit. */
4950 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4951 && !(REFERENCE_REF_P (arg
)
4952 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4954 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4955 || (packed_args
&& uses_template_parms (arg
)))
4956 error ("template argument %qE involves template parameter(s)",
4960 /* Look at the corresponding template parameter,
4961 marking which template parameters its type depends
4963 tree type
= TREE_TYPE (parm
);
4967 /* We haven't yet initialized TPD2. Do so now. */
4968 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4969 /* The number of parameters here is the number in the
4970 main template, which, as checked in the assertion
4972 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4974 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4977 /* Mark the template parameters. But this time, we're
4978 looking for the template parameters of the main
4979 template, not in the specialization. */
4980 tpd2
.current_arg
= i
;
4981 tpd2
.arg_uses_template_parms
[i
] = 0;
4982 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4983 for_each_template_parm (type
,
4984 &mark_template_parm
,
4987 /*include_nondeduced_p=*/false);
4989 if (tpd2
.arg_uses_template_parms
[i
])
4991 /* The type depended on some template parameters.
4992 If they are fully specialized in the
4993 specialization, that's OK. */
4996 for (j
= 0; j
< nargs
; ++j
)
4997 if (tpd2
.parms
[j
] != 0
4998 && tpd
.arg_uses_template_parms
[j
])
5001 error_n (input_location
, count
,
5002 "type %qT of template argument %qE depends "
5003 "on a template parameter",
5004 "type %qT of template argument %qE depends "
5005 "on template parameters",
5014 /* We should only get here once. */
5015 if (TREE_CODE (decl
) == TYPE_DECL
)
5016 gcc_assert (!COMPLETE_TYPE_P (type
));
5018 // Build the template decl.
5019 tree tmpl
= build_template_decl (decl
, current_template_parms
,
5020 DECL_MEMBER_TEMPLATE_P (maintmpl
));
5021 TREE_TYPE (tmpl
) = type
;
5022 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5023 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5024 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
5025 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
5027 /* Give template template parms a DECL_CONTEXT of the template
5028 for which they are a parameter. */
5029 for (i
= 0; i
< ntparms
; ++i
)
5031 tree parm
= TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
));
5032 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5033 DECL_CONTEXT (parm
) = tmpl
;
5037 /* We didn't register this in check_explicit_specialization so we could
5038 wait until the constraints were set. */
5039 decl
= register_specialization (decl
, maintmpl
, specargs
, false, 0);
5041 associate_classtype_constraints (type
);
5043 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
5044 = tree_cons (specargs
, tmpl
,
5045 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
5046 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
5048 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
5049 inst
= TREE_CHAIN (inst
))
5051 tree instance
= TREE_VALUE (inst
);
5052 if (TYPE_P (instance
)
5053 ? (COMPLETE_TYPE_P (instance
)
5054 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance
))
5055 : DECL_TEMPLATE_INSTANTIATION (instance
))
5057 tree spec
= most_specialized_partial_spec (instance
, tf_none
);
5058 tree inst_decl
= (DECL_P (instance
)
5059 ? instance
: TYPE_NAME (instance
));
5062 else if (spec
== error_mark_node
)
5063 permerror (input_location
,
5064 "declaration of %qD ambiguates earlier template "
5065 "instantiation for %qD", decl
, inst_decl
);
5066 else if (TREE_VALUE (spec
) == tmpl
)
5067 permerror (input_location
,
5068 "partial specialization of %qD after instantiation "
5069 "of %qD", decl
, inst_decl
);
5076 /* PARM is a template parameter of some form; return the corresponding
5077 TEMPLATE_PARM_INDEX. */
5080 get_template_parm_index (tree parm
)
5082 if (TREE_CODE (parm
) == PARM_DECL
5083 || TREE_CODE (parm
) == CONST_DECL
)
5084 parm
= DECL_INITIAL (parm
);
5085 else if (TREE_CODE (parm
) == TYPE_DECL
5086 || TREE_CODE (parm
) == TEMPLATE_DECL
)
5087 parm
= TREE_TYPE (parm
);
5088 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
5089 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
5090 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
5091 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
5092 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
5096 /* Subroutine of fixed_parameter_pack_p below. Look for any template
5097 parameter packs used by the template parameter PARM. */
5100 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
5102 /* A type parm can't refer to another parm. */
5103 if (TREE_CODE (parm
) == TYPE_DECL
|| parm
== error_mark_node
)
5105 else if (TREE_CODE (parm
) == PARM_DECL
)
5107 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
5112 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
5114 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
5115 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
5116 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
5119 /* PARM is a template parameter pack. Return any parameter packs used in
5120 its type or the type of any of its template parameters. If there are
5121 any such packs, it will be instantiated into a fixed template parameter
5122 list by partial instantiation rather than be fully deduced. */
5125 fixed_parameter_pack_p (tree parm
)
5127 /* This can only be true in a member template. */
5128 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
5130 /* This can only be true for a parameter pack. */
5131 if (!template_parameter_pack_p (parm
))
5133 /* A type parm can't refer to another parm. */
5134 if (TREE_CODE (parm
) == TYPE_DECL
)
5137 tree parameter_packs
= NULL_TREE
;
5138 struct find_parameter_pack_data ppd
;
5139 ppd
.parameter_packs
= ¶meter_packs
;
5140 ppd
.visited
= new hash_set
<tree
>;
5141 ppd
.type_pack_expansion_p
= false;
5143 fixed_parameter_pack_p_1 (parm
, &ppd
);
5146 return parameter_packs
;
5149 /* Check that a template declaration's use of default arguments and
5150 parameter packs is not invalid. Here, PARMS are the template
5151 parameters. IS_PRIMARY is true if DECL is the thing declared by
5152 a primary template. IS_PARTIAL is true if DECL is a partial
5155 IS_FRIEND_DECL is nonzero if DECL is either a non-defining friend
5156 function template declaration or a friend class template
5157 declaration. In the function case, 1 indicates a declaration, 2
5158 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
5159 emitted for extraneous default arguments.
5161 Returns TRUE if there were no errors found, FALSE otherwise. */
5164 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
5165 bool is_partial
, int is_friend_decl
)
5168 int last_level_to_check
;
5170 bool no_errors
= true;
5174 A default template-argument shall not be specified in a
5175 function template declaration or a function template definition, nor
5176 in the template-parameter-list of the definition of a member of a
5179 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
5180 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
5181 /* You can't have a function template declaration in a local
5182 scope, nor you can you define a member of a class template in a
5186 if ((TREE_CODE (decl
) == TYPE_DECL
5188 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5189 || (TREE_CODE (decl
) == FUNCTION_DECL
5190 && LAMBDA_FUNCTION_P (decl
)))
5191 /* A lambda doesn't have an explicit declaration; don't complain
5192 about the parms of the enclosing class. */
5195 if (current_class_type
5196 && !TYPE_BEING_DEFINED (current_class_type
)
5197 && DECL_LANG_SPECIFIC (decl
)
5198 && DECL_DECLARES_FUNCTION_P (decl
)
5199 /* If this is either a friend defined in the scope of the class
5200 or a member function. */
5201 && (DECL_FUNCTION_MEMBER_P (decl
)
5202 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
5203 : DECL_FRIEND_CONTEXT (decl
)
5204 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
5206 /* And, if it was a member function, it really was defined in
5207 the scope of the class. */
5208 && (!DECL_FUNCTION_MEMBER_P (decl
)
5209 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
5210 /* We already checked these parameters when the template was
5211 declared, so there's no need to do it again now. This function
5212 was defined in class scope, but we're processing its body now
5213 that the class is complete. */
5216 /* Core issue 226 (C++0x only): the following only applies to class
5219 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
5223 If a template-parameter has a default template-argument, all
5224 subsequent template-parameters shall have a default
5225 template-argument supplied. */
5226 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
5228 tree inner_parms
= TREE_VALUE (parm_level
);
5229 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
5230 int seen_def_arg_p
= 0;
5233 for (i
= 0; i
< ntparms
; ++i
)
5235 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
5237 if (parm
== error_mark_node
)
5240 if (TREE_PURPOSE (parm
))
5242 else if (seen_def_arg_p
5243 && !template_parameter_pack_p (TREE_VALUE (parm
)))
5245 error ("no default argument for %qD", TREE_VALUE (parm
));
5246 /* For better subsequent error-recovery, we indicate that
5247 there should have been a default argument. */
5248 TREE_PURPOSE (parm
) = error_mark_node
;
5251 else if (!is_partial
5253 /* Don't complain about an enclosing partial
5255 && parm_level
== parms
5256 && TREE_CODE (decl
) == TYPE_DECL
5258 && template_parameter_pack_p (TREE_VALUE (parm
))
5259 /* A fixed parameter pack will be partially
5260 instantiated into a fixed length list. */
5261 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
5263 /* A primary class template can only have one
5264 parameter pack, at the end of the template
5267 error ("parameter pack %q+D must be at the end of the"
5268 " template parameter list", TREE_VALUE (parm
));
5270 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
5278 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
5282 /* For an ordinary class template, default template arguments are
5283 allowed at the innermost level, e.g.:
5284 template <class T = int>
5286 but, in a partial specialization, they're not allowed even
5287 there, as we have in [temp.class.spec]:
5289 The template parameter list of a specialization shall not
5290 contain default template argument values.
5292 So, for a partial specialization, or for a function template
5293 (in C++98/C++03), we look at all of them. */
5296 /* But, for a primary class template that is not a partial
5297 specialization we look at all template parameters except the
5299 parms
= TREE_CHAIN (parms
);
5301 /* Figure out what error message to issue. */
5302 if (is_friend_decl
== 2)
5303 msg
= G_("default template arguments may not be used in function template "
5304 "friend re-declaration");
5305 else if (is_friend_decl
)
5306 msg
= G_("default template arguments may not be used in template "
5307 "friend declarations");
5308 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
5309 msg
= G_("default template arguments may not be used in function templates "
5310 "without -std=c++11 or -std=gnu++11");
5311 else if (is_partial
)
5312 msg
= G_("default template arguments may not be used in "
5313 "partial specializations");
5314 else if (current_class_type
&& CLASSTYPE_IS_TEMPLATE (current_class_type
))
5315 msg
= G_("default argument for template parameter for class enclosing %qD");
5317 /* Per [temp.param]/9, "A default template-argument shall not be
5318 specified in the template-parameter-lists of the definition of
5319 a member of a class template that appears outside of the member's
5320 class.", thus if we aren't handling a member of a class template
5321 there is no need to examine the parameters. */
5324 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
5325 /* If we're inside a class definition, there's no need to
5326 examine the parameters to the class itself. On the one
5327 hand, they will be checked when the class is defined, and,
5328 on the other, default arguments are valid in things like:
5329 template <class T = double>
5330 struct S { template <class U> void f(U); };
5331 Here the default argument for `S' has no bearing on the
5332 declaration of `f'. */
5333 last_level_to_check
= template_class_depth (current_class_type
) + 1;
5335 /* Check everything. */
5336 last_level_to_check
= 0;
5338 for (parm_level
= parms
;
5339 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
5340 parm_level
= TREE_CHAIN (parm_level
))
5342 tree inner_parms
= TREE_VALUE (parm_level
);
5346 ntparms
= TREE_VEC_LENGTH (inner_parms
);
5347 for (i
= 0; i
< ntparms
; ++i
)
5349 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
5352 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
5357 if (is_friend_decl
== 2)
5364 /* Clear out the default argument so that we are not
5366 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
5370 /* At this point, if we're still interested in issuing messages,
5371 they must apply to classes surrounding the object declared. */
5373 msg
= G_("default argument for template parameter for class "
5380 /* Worker for push_template_decl_real, called via
5381 for_each_template_parm. DATA is really an int, indicating the
5382 level of the parameters we are interested in. If T is a template
5383 parameter of that level, return nonzero. */
5386 template_parm_this_level_p (tree t
, void* data
)
5388 int this_level
= *(int *)data
;
5391 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5392 level
= TEMPLATE_PARM_LEVEL (t
);
5394 level
= TEMPLATE_TYPE_LEVEL (t
);
5395 return level
== this_level
;
5398 /* Worker for uses_outer_template_parms, called via for_each_template_parm.
5399 DATA is really an int, indicating the innermost outer level of parameters.
5400 If T is a template parameter of that level or further out, return
5404 template_parm_outer_level (tree t
, void *data
)
5406 int this_level
= *(int *)data
;
5409 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5410 level
= TEMPLATE_PARM_LEVEL (t
);
5412 level
= TEMPLATE_TYPE_LEVEL (t
);
5413 return level
<= this_level
;
5416 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5417 parameters given by current_template_args, or reuses a
5418 previously existing one, if appropriate. Returns the DECL, or an
5419 equivalent one, if it is replaced via a call to duplicate_decls.
5421 If IS_FRIEND is true, DECL is a friend declaration. */
5424 push_template_decl_real (tree decl
, bool is_friend
)
5432 int new_template_p
= 0;
5433 /* True if the template is a member template, in the sense of
5435 bool member_template_p
= false;
5437 if (decl
== error_mark_node
|| !current_template_parms
)
5438 return error_mark_node
;
5440 /* See if this is a partial specialization. */
5441 is_partial
= ((DECL_IMPLICIT_TYPEDEF_P (decl
)
5442 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
5443 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
5445 && DECL_LANG_SPECIFIC (decl
)
5446 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5447 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
))));
5449 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
5453 /* For a friend, we want the context of the friend, not
5454 the type of which it is a friend. */
5455 ctx
= CP_DECL_CONTEXT (decl
);
5456 else if (CP_DECL_CONTEXT (decl
)
5457 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
5458 /* In the case of a virtual function, we want the class in which
5460 ctx
= CP_DECL_CONTEXT (decl
);
5462 /* Otherwise, if we're currently defining some class, the DECL
5463 is assumed to be a member of the class. */
5464 ctx
= current_scope ();
5466 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5469 if (!DECL_CONTEXT (decl
))
5470 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
5472 /* See if this is a primary template. */
5473 if (is_friend
&& ctx
5474 && uses_template_parms_level (ctx
, processing_template_decl
))
5475 /* A friend template that specifies a class context, i.e.
5476 template <typename T> friend void A<T>::f();
5479 else if (TREE_CODE (decl
) == TYPE_DECL
5480 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5483 is_primary
= template_parm_scope_p ();
5487 warning (OPT_Wtemplates
, "template %qD declared", decl
);
5489 if (DECL_CLASS_SCOPE_P (decl
))
5490 member_template_p
= true;
5491 if (TREE_CODE (decl
) == TYPE_DECL
5492 && anon_aggrname_p (DECL_NAME (decl
)))
5494 error ("template class without a name");
5495 return error_mark_node
;
5497 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
5499 if (member_template_p
)
5501 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
5502 error ("member template %qD may not have virt-specifiers", decl
);
5504 if (DECL_DESTRUCTOR_P (decl
))
5508 A destructor shall not be a member template. */
5509 error ("destructor %qD declared as member template", decl
);
5510 return error_mark_node
;
5512 if (IDENTIFIER_NEWDEL_OP_P (DECL_NAME (decl
))
5513 && (!prototype_p (TREE_TYPE (decl
))
5514 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
5515 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5516 || (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5517 == void_list_node
)))
5519 /* [basic.stc.dynamic.allocation]
5521 An allocation function can be a function
5522 template. ... Template allocation functions shall
5523 have two or more parameters. */
5524 error ("invalid template declaration of %qD", decl
);
5525 return error_mark_node
;
5528 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5529 && CLASS_TYPE_P (TREE_TYPE (decl
)))
5531 /* Class template, set TEMPLATE_TYPE_PARM_FOR_CLASS. */
5532 tree parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
5533 for (int i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
5535 tree t
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5536 if (TREE_CODE (t
) == TYPE_DECL
)
5538 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
5539 TEMPLATE_TYPE_PARM_FOR_CLASS (t
) = true;
5542 else if (TREE_CODE (decl
) == TYPE_DECL
5543 && TYPE_DECL_ALIAS_P (decl
))
5544 /* alias-declaration */
5545 gcc_assert (!DECL_ARTIFICIAL (decl
));
5546 else if (VAR_P (decl
))
5547 /* C++14 variable template. */;
5550 error ("template declaration of %q#D", decl
);
5551 return error_mark_node
;
5555 /* Check to see that the rules regarding the use of default
5556 arguments are not being violated. We check args for a friend
5557 functions when we know whether it's a definition, introducing
5558 declaration or re-declaration. */
5559 if (!is_friend
|| TREE_CODE (decl
) != FUNCTION_DECL
)
5560 check_default_tmpl_args (decl
, current_template_parms
,
5561 is_primary
, is_partial
, is_friend
);
5563 /* Ensure that there are no parameter packs in the type of this
5564 declaration that have not been expanded. */
5565 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5567 /* Check each of the arguments individually to see if there are
5568 any bare parameter packs. */
5569 tree type
= TREE_TYPE (decl
);
5570 tree arg
= DECL_ARGUMENTS (decl
);
5571 tree argtype
= TYPE_ARG_TYPES (type
);
5573 while (arg
&& argtype
)
5575 if (!DECL_PACK_P (arg
)
5576 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
5578 /* This is a PARM_DECL that contains unexpanded parameter
5579 packs. We have already complained about this in the
5580 check_for_bare_parameter_packs call, so just replace
5581 these types with ERROR_MARK_NODE. */
5582 TREE_TYPE (arg
) = error_mark_node
;
5583 TREE_VALUE (argtype
) = error_mark_node
;
5586 arg
= DECL_CHAIN (arg
);
5587 argtype
= TREE_CHAIN (argtype
);
5590 /* Check for bare parameter packs in the return type and the
5591 exception specifiers. */
5592 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
5593 /* Errors were already issued, set return type to int
5594 as the frontend doesn't expect error_mark_node as
5596 TREE_TYPE (type
) = integer_type_node
;
5597 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
5598 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
5600 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
5601 && TYPE_DECL_ALIAS_P (decl
))
5602 ? DECL_ORIGINAL_TYPE (decl
)
5603 : TREE_TYPE (decl
)))
5605 TREE_TYPE (decl
) = error_mark_node
;
5606 return error_mark_node
;
5610 return process_partial_specialization (decl
);
5612 args
= current_template_args ();
5615 || TREE_CODE (ctx
) == FUNCTION_DECL
5616 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
5617 || (TREE_CODE (decl
) == TYPE_DECL
5618 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5619 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
5621 if (DECL_LANG_SPECIFIC (decl
)
5622 && DECL_TEMPLATE_INFO (decl
)
5623 && DECL_TI_TEMPLATE (decl
))
5624 tmpl
= DECL_TI_TEMPLATE (decl
);
5625 /* If DECL is a TYPE_DECL for a class-template, then there won't
5626 be DECL_LANG_SPECIFIC. The information equivalent to
5627 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5628 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5629 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
5630 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
5632 /* Since a template declaration already existed for this
5633 class-type, we must be redeclaring it here. Make sure
5634 that the redeclaration is valid. */
5635 redeclare_class_template (TREE_TYPE (decl
),
5636 current_template_parms
,
5637 current_template_constraints ());
5638 /* We don't need to create a new TEMPLATE_DECL; just use the
5639 one we already had. */
5640 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
5644 tmpl
= build_template_decl (decl
, current_template_parms
,
5648 if (DECL_LANG_SPECIFIC (decl
)
5649 && DECL_TEMPLATE_SPECIALIZATION (decl
))
5651 /* A specialization of a member template of a template
5653 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5654 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
5655 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
5661 tree a
, t
, current
, parms
;
5663 tree tinfo
= get_template_info (decl
);
5667 error ("template definition of non-template %q#D", decl
);
5668 return error_mark_node
;
5671 tmpl
= TI_TEMPLATE (tinfo
);
5673 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
5674 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
5675 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5676 && DECL_MEMBER_TEMPLATE_P (tmpl
))
5680 /* The declaration is a specialization of a member
5681 template, declared outside the class. Therefore, the
5682 innermost template arguments will be NULL, so we
5683 replace them with the arguments determined by the
5684 earlier call to check_explicit_specialization. */
5685 args
= DECL_TI_ARGS (decl
);
5688 = build_template_decl (decl
, current_template_parms
,
5690 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
5691 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
5692 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
5693 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
5694 DECL_TEMPLATE_INFO (new_tmpl
)
5695 = build_template_info (tmpl
, args
);
5697 register_specialization (new_tmpl
,
5698 most_general_template (tmpl
),
5704 /* Make sure the template headers we got make sense. */
5706 parms
= DECL_TEMPLATE_PARMS (tmpl
);
5707 i
= TMPL_PARMS_DEPTH (parms
);
5708 if (TMPL_ARGS_DEPTH (args
) != i
)
5710 error ("expected %d levels of template parms for %q#D, got %d",
5711 i
, decl
, TMPL_ARGS_DEPTH (args
));
5712 DECL_INTERFACE_KNOWN (decl
) = 1;
5713 return error_mark_node
;
5716 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
5718 a
= TMPL_ARGS_LEVEL (args
, i
);
5719 t
= INNERMOST_TEMPLATE_PARMS (parms
);
5721 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
5723 if (current
== decl
)
5724 error ("got %d template parameters for %q#D",
5725 TREE_VEC_LENGTH (a
), decl
);
5727 error ("got %d template parameters for %q#T",
5728 TREE_VEC_LENGTH (a
), current
);
5729 error (" but %d required", TREE_VEC_LENGTH (t
));
5730 /* Avoid crash in import_export_decl. */
5731 DECL_INTERFACE_KNOWN (decl
) = 1;
5732 return error_mark_node
;
5735 if (current
== decl
)
5737 else if (current
== NULL_TREE
)
5738 /* Can happen in erroneous input. */
5741 current
= get_containing_scope (current
);
5744 /* Check that the parms are used in the appropriate qualifying scopes
5745 in the declarator. */
5746 if (!comp_template_args
5748 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
5750 error ("template arguments to %qD do not match original "
5751 "template %qD", decl
, DECL_TEMPLATE_RESULT (tmpl
));
5752 if (!uses_template_parms (TI_ARGS (tinfo
)))
5753 inform (input_location
, "use %<template<>%> for"
5754 " an explicit specialization");
5755 /* Avoid crash in import_export_decl. */
5756 DECL_INTERFACE_KNOWN (decl
) = 1;
5757 return error_mark_node
;
5761 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5762 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5764 /* Push template declarations for global functions and types. Note
5765 that we do not try to push a global template friend declared in a
5766 template class; such a thing may well depend on the template
5767 parameters of the class. */
5768 if (new_template_p
&& !ctx
5769 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5771 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5772 if (tmpl
== error_mark_node
)
5773 return error_mark_node
;
5775 /* Hide template friend classes that haven't been declared yet. */
5776 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5778 DECL_ANTICIPATED (tmpl
) = 1;
5779 DECL_FRIEND_P (tmpl
) = 1;
5785 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5787 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5789 /* Give template template parms a DECL_CONTEXT of the template
5790 for which they are a parameter. */
5791 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5792 for (int i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5794 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5795 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5796 DECL_CONTEXT (parm
) = tmpl
;
5799 if (TREE_CODE (decl
) == TYPE_DECL
5800 && TYPE_DECL_ALIAS_P (decl
)
5801 && complex_alias_template_p (tmpl
))
5802 TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl
) = true;
5805 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5806 back to its most general template. If TMPL is a specialization,
5807 ARGS may only have the innermost set of arguments. Add the missing
5808 argument levels if necessary. */
5809 if (DECL_TEMPLATE_INFO (tmpl
))
5810 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5812 info
= build_template_info (tmpl
, args
);
5814 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5815 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5819 retrofit_lang_decl (decl
);
5820 if (DECL_LANG_SPECIFIC (decl
))
5821 DECL_TEMPLATE_INFO (decl
) = info
;
5824 if (flag_implicit_templates
5826 && TREE_PUBLIC (decl
)
5827 && VAR_OR_FUNCTION_DECL_P (decl
))
5828 /* Set DECL_COMDAT on template instantiations; if we force
5829 them to be emitted by explicit instantiation or -frepo,
5830 mark_needed will tell cgraph to do the right thing. */
5831 DECL_COMDAT (decl
) = true;
5833 return DECL_TEMPLATE_RESULT (tmpl
);
5837 push_template_decl (tree decl
)
5839 return push_template_decl_real (decl
, false);
5842 /* FN is an inheriting constructor that inherits from the constructor
5843 template INHERITED; turn FN into a constructor template with a matching
5847 add_inherited_template_parms (tree fn
, tree inherited
)
5850 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5851 inner_parms
= copy_node (inner_parms
);
5853 = tree_cons (size_int (processing_template_decl
+ 1),
5854 inner_parms
, current_template_parms
);
5855 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5856 tree args
= template_parms_to_args (parms
);
5857 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5858 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5859 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5860 DECL_ARTIFICIAL (tmpl
) = true;
5861 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5865 /* Called when a class template TYPE is redeclared with the indicated
5866 template PARMS, e.g.:
5868 template <class T> struct S;
5869 template <class T> struct S {}; */
5872 redeclare_class_template (tree type
, tree parms
, tree cons
)
5878 if (!TYPE_TEMPLATE_INFO (type
))
5880 error ("%qT is not a template type", type
);
5884 tmpl
= TYPE_TI_TEMPLATE (type
);
5885 if (!PRIMARY_TEMPLATE_P (tmpl
))
5886 /* The type is nested in some template class. Nothing to worry
5887 about here; there are no new template parameters for the nested
5893 error ("template specifiers not specified in declaration of %qD",
5898 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5899 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5901 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5903 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5904 "redeclared with %d template parameter",
5905 "redeclared with %d template parameters",
5906 TREE_VEC_LENGTH (parms
));
5907 inform_n (DECL_SOURCE_LOCATION (tmpl
), TREE_VEC_LENGTH (tmpl_parms
),
5908 "previous declaration %qD used %d template parameter",
5909 "previous declaration %qD used %d template parameters",
5910 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5914 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5921 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5922 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5925 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5926 if (error_operand_p (tmpl_parm
))
5929 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5930 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5931 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5933 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5935 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5936 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5937 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5938 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5939 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5940 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5941 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5942 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5943 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5945 error ("template parameter %q+#D", tmpl_parm
);
5946 error ("redeclared here as %q#D", parm
);
5950 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5952 /* We have in [temp.param]:
5954 A template-parameter may not be given default arguments
5955 by two different declarations in the same scope. */
5956 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5957 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5958 "original definition appeared here");
5962 if (parm_default
!= NULL_TREE
)
5963 /* Update the previous template parameters (which are the ones
5964 that will really count) with the new default value. */
5965 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5966 else if (tmpl_default
!= NULL_TREE
)
5967 /* Update the new parameters, too; they'll be used as the
5968 parameters for any members. */
5969 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5971 /* Give each template template parm in this redeclaration a
5972 DECL_CONTEXT of the template for which they are a parameter. */
5973 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5975 gcc_assert (DECL_CONTEXT (parm
) == NULL_TREE
);
5976 DECL_CONTEXT (parm
) = tmpl
;
5979 if (TREE_CODE (parm
) == TYPE_DECL
)
5980 TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (parm
)) = true;
5983 // Cannot redeclare a class template with a different set of constraints.
5984 if (!equivalent_constraints (get_constraints (tmpl
), cons
))
5986 error_at (input_location
, "redeclaration %q#D with different "
5987 "constraints", tmpl
);
5988 inform (DECL_SOURCE_LOCATION (tmpl
),
5989 "original declaration appeared here");
5995 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5996 to be used when the caller has already checked
5997 (processing_template_decl
5998 && !instantiation_dependent_expression_p (expr)
5999 && potential_constant_expression (expr))
6000 and cleared processing_template_decl. */
6003 instantiate_non_dependent_expr_internal (tree expr
, tsubst_flags_t complain
)
6005 return tsubst_copy_and_build (expr
,
6008 /*in_decl=*/NULL_TREE
,
6009 /*function_p=*/false,
6010 /*integral_constant_expression_p=*/true);
6013 /* Simplify EXPR if it is a non-dependent expression. Returns the
6014 (possibly simplified) expression. */
6017 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
6019 if (expr
== NULL_TREE
)
6022 /* If we're in a template, but EXPR isn't value dependent, simplify
6023 it. We're supposed to treat:
6025 template <typename T> void f(T[1 + 1]);
6026 template <typename T> void f(T[2]);
6028 as two declarations of the same function, for example. */
6029 if (processing_template_decl
6030 && is_nondependent_constant_expression (expr
))
6032 processing_template_decl_sentinel s
;
6033 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6039 instantiate_non_dependent_expr (tree expr
)
6041 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
6044 /* Like instantiate_non_dependent_expr, but return NULL_TREE rather than
6045 an uninstantiated expression. */
6048 instantiate_non_dependent_or_null (tree expr
)
6050 if (expr
== NULL_TREE
)
6052 if (processing_template_decl
)
6054 if (!is_nondependent_constant_expression (expr
))
6058 processing_template_decl_sentinel s
;
6059 expr
= instantiate_non_dependent_expr_internal (expr
, tf_error
);
6065 /* True iff T is a specialization of a variable template. */
6068 variable_template_specialization_p (tree t
)
6070 if (!VAR_P (t
) || !DECL_LANG_SPECIFIC (t
) || !DECL_TEMPLATE_INFO (t
))
6072 tree tmpl
= DECL_TI_TEMPLATE (t
);
6073 return variable_template_p (tmpl
);
6076 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
6077 template declaration, or a TYPE_DECL for an alias declaration. */
6080 alias_type_or_template_p (tree t
)
6084 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
6087 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
6088 || DECL_ALIAS_TEMPLATE_P (t
));
6091 /* Return TRUE iff T is a specialization of an alias template. */
6094 alias_template_specialization_p (const_tree t
)
6096 /* It's an alias template specialization if it's an alias and its
6097 TYPE_NAME is a specialization of a primary template. */
6098 if (TYPE_ALIAS_P (t
))
6099 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
6100 return PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
));
6105 /* An alias template is complex from a SFINAE perspective if a template-id
6106 using that alias can be ill-formed when the expansion is not, as with
6107 the void_t template. We determine this by checking whether the
6108 expansion for the alias template uses all its template parameters. */
6110 struct uses_all_template_parms_data
6117 uses_all_template_parms_r (tree t
, void *data_
)
6119 struct uses_all_template_parms_data
&data
6120 = *(struct uses_all_template_parms_data
*)data_
;
6121 tree idx
= get_template_parm_index (t
);
6123 if (TEMPLATE_PARM_LEVEL (idx
) == data
.level
)
6124 data
.seen
[TEMPLATE_PARM_IDX (idx
)] = true;
6129 complex_alias_template_p (const_tree tmpl
)
6131 struct uses_all_template_parms_data data
;
6132 tree pat
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
6133 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
6134 data
.level
= TMPL_PARMS_DEPTH (parms
);
6135 int len
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms
));
6136 data
.seen
= XALLOCAVEC (bool, len
);
6137 for (int i
= 0; i
< len
; ++i
)
6138 data
.seen
[i
] = false;
6140 for_each_template_parm (pat
, uses_all_template_parms_r
, &data
, NULL
, true);
6141 for (int i
= 0; i
< len
; ++i
)
6147 /* Return TRUE iff T is a specialization of a complex alias template with
6148 dependent template-arguments. */
6151 dependent_alias_template_spec_p (const_tree t
)
6153 if (!alias_template_specialization_p (t
))
6156 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
);
6157 if (!TEMPLATE_DECL_COMPLEX_ALIAS_P (TI_TEMPLATE (tinfo
)))
6160 tree args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
));
6161 if (!any_dependent_template_arguments_p (args
))
6167 /* Return the number of innermost template parameters in TMPL. */
6170 num_innermost_template_parms (tree tmpl
)
6172 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
6173 return TREE_VEC_LENGTH (parms
);
6176 /* Return either TMPL or another template that it is equivalent to under DR
6177 1286: An alias that just changes the name of a template is equivalent to
6178 the other template. */
6181 get_underlying_template (tree tmpl
)
6183 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
6184 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
6186 /* Determine if the alias is equivalent to an underlying template. */
6187 tree orig_type
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
6188 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (orig_type
);
6192 tree underlying
= TI_TEMPLATE (tinfo
);
6193 if (!PRIMARY_TEMPLATE_P (underlying
)
6194 || (num_innermost_template_parms (tmpl
)
6195 != num_innermost_template_parms (underlying
)))
6198 tree alias_args
= INNERMOST_TEMPLATE_ARGS
6199 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
6200 if (!comp_template_args (TI_ARGS (tinfo
), alias_args
))
6203 /* Alias is equivalent. Strip it and repeat. */
6210 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
6211 must be a reference-to-function or a pointer-to-function type, as specified
6212 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
6213 and check that the resulting function has external linkage. */
6216 convert_nontype_argument_function (tree type
, tree expr
,
6217 tsubst_flags_t complain
)
6221 linkage_kind linkage
;
6223 fn
= instantiate_type (type
, fns
, tf_none
);
6224 if (fn
== error_mark_node
)
6225 return error_mark_node
;
6227 if (value_dependent_expression_p (fn
))
6230 fn_no_ptr
= strip_fnptr_conv (fn
);
6231 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
6232 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
6233 if (BASELINK_P (fn_no_ptr
))
6234 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
6236 /* [temp.arg.nontype]/1
6238 A template-argument for a non-type, non-template template-parameter
6241 -- the address of an object or function with external [C++11: or
6242 internal] linkage. */
6244 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
6246 if (complain
& tf_error
)
6248 error ("%qE is not a valid template argument for type %qT",
6250 if (TYPE_PTR_P (type
))
6251 inform (input_location
, "it must be the address of a function "
6252 "with external linkage");
6254 inform (input_location
, "it must be the name of a function with "
6255 "external linkage");
6260 linkage
= decl_linkage (fn_no_ptr
);
6261 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
6263 if (complain
& tf_error
)
6265 if (cxx_dialect
>= cxx11
)
6266 error ("%qE is not a valid template argument for type %qT "
6267 "because %qD has no linkage",
6268 expr
, type
, fn_no_ptr
);
6270 error ("%qE is not a valid template argument for type %qT "
6271 "because %qD does not have external linkage",
6272 expr
, type
, fn_no_ptr
);
6278 if (TYPE_REF_P (type
))
6280 if (REFERENCE_REF_P (fn
))
6281 fn
= TREE_OPERAND (fn
, 0);
6283 fn
= build_address (fn
);
6285 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (fn
)))
6286 fn
= build_nop (type
, fn
);
6291 /* Subroutine of convert_nontype_argument.
6292 Check if EXPR of type TYPE is a valid pointer-to-member constant.
6293 Emit an error otherwise. */
6296 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
6297 tsubst_flags_t complain
)
6299 location_t loc
= cp_expr_loc_or_loc (expr
, input_location
);
6300 tree orig_expr
= expr
;
6302 if (null_ptr_cst_p (expr
))
6304 if (TREE_CODE (expr
) == PTRMEM_CST
6305 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
6306 PTRMEM_CST_CLASS (expr
)))
6308 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
6310 if (processing_template_decl
6311 && TREE_CODE (expr
) == ADDR_EXPR
6312 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
6314 if (complain
& tf_error
)
6316 error_at (loc
, "%qE is not a valid template argument for type %qT",
6318 if (TREE_CODE (expr
) != PTRMEM_CST
)
6319 inform (loc
, "it must be a pointer-to-member of the form %<&X::Y%>");
6321 inform (loc
, "because it is a member of %qT", PTRMEM_CST_CLASS (expr
));
6326 /* Returns TRUE iff the address of OP is value-dependent.
6328 14.6.2.4 [temp.dep.temp]:
6329 A non-integral non-type template-argument is dependent if its type is
6330 dependent or it has either of the following forms
6333 and contains a nested-name-specifier which specifies a class-name that
6334 names a dependent type.
6336 We generalize this to just say that the address of a member of a
6337 dependent class is value-dependent; the above doesn't cover the
6338 address of a static data member named with an unqualified-id. */
6341 has_value_dependent_address (tree op
)
6343 /* We could use get_inner_reference here, but there's no need;
6344 this is only relevant for template non-type arguments, which
6345 can only be expressed as &id-expression. */
6348 tree ctx
= CP_DECL_CONTEXT (op
);
6349 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
6356 /* The next set of functions are used for providing helpful explanatory
6357 diagnostics for failed overload resolution. Their messages should be
6358 indented by two spaces for consistency with the messages in
6362 unify_success (bool /*explain_p*/)
6367 /* Other failure functions should call this one, to provide a single function
6368 for setting a breakpoint on. */
6371 unify_invalid (bool /*explain_p*/)
6377 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
6380 inform (input_location
,
6381 " couldn't deduce template parameter %qD", parm
);
6382 return unify_invalid (explain_p
);
6386 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
6389 inform (input_location
,
6390 " types %qT and %qT have incompatible cv-qualifiers",
6392 return unify_invalid (explain_p
);
6396 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
6399 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
6400 return unify_invalid (explain_p
);
6404 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
6407 inform (input_location
,
6408 " template parameter %qD is not a parameter pack, but "
6411 return unify_invalid (explain_p
);
6415 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
6418 inform (input_location
,
6419 " template argument %qE does not match "
6420 "pointer-to-member constant %qE",
6422 return unify_invalid (explain_p
);
6426 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
6429 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
6430 return unify_invalid (explain_p
);
6434 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
6437 inform (input_location
,
6438 " inconsistent parameter pack deduction with %qT and %qT",
6440 return unify_invalid (explain_p
);
6444 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
6449 inform (input_location
,
6450 " deduced conflicting types for parameter %qT (%qT and %qT)",
6451 parm
, first
, second
);
6453 inform (input_location
,
6454 " deduced conflicting values for non-type parameter "
6455 "%qE (%qE and %qE)", parm
, first
, second
);
6457 return unify_invalid (explain_p
);
6461 unify_vla_arg (bool explain_p
, tree arg
)
6464 inform (input_location
,
6465 " variable-sized array type %qT is not "
6466 "a valid template argument",
6468 return unify_invalid (explain_p
);
6472 unify_method_type_error (bool explain_p
, tree arg
)
6475 inform (input_location
,
6476 " member function type %qT is not a valid template argument",
6478 return unify_invalid (explain_p
);
6482 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
6487 inform_n (input_location
, wanted
,
6488 " candidate expects at least %d argument, %d provided",
6489 " candidate expects at least %d arguments, %d provided",
6492 inform_n (input_location
, wanted
,
6493 " candidate expects %d argument, %d provided",
6494 " candidate expects %d arguments, %d provided",
6497 return unify_invalid (explain_p
);
6501 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
6503 return unify_arity (explain_p
, have
, wanted
);
6507 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
6508 bool least_p
= false)
6510 return unify_arity (explain_p
, have
, wanted
, least_p
);
6514 unify_arg_conversion (bool explain_p
, tree to_type
,
6515 tree from_type
, tree arg
)
6518 inform (cp_expr_loc_or_loc (arg
, input_location
),
6519 " cannot convert %qE (type %qT) to type %qT",
6520 arg
, from_type
, to_type
);
6521 return unify_invalid (explain_p
);
6525 unify_no_common_base (bool explain_p
, enum template_base_result r
,
6526 tree parm
, tree arg
)
6531 case tbr_ambiguous_baseclass
:
6532 inform (input_location
, " %qT is an ambiguous base class of %qT",
6536 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
6539 return unify_invalid (explain_p
);
6543 unify_inconsistent_template_template_parameters (bool explain_p
)
6546 inform (input_location
,
6547 " template parameters of a template template argument are "
6548 "inconsistent with other deduced template arguments");
6549 return unify_invalid (explain_p
);
6553 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
6556 inform (input_location
,
6557 " can't deduce a template for %qT from non-template type %qT",
6559 return unify_invalid (explain_p
);
6563 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
6566 inform (input_location
,
6567 " template argument %qE does not match %qE", arg
, parm
);
6568 return unify_invalid (explain_p
);
6571 /* Attempt to convert the non-type template parameter EXPR to the
6572 indicated TYPE. If the conversion is successful, return the
6573 converted value. If the conversion is unsuccessful, return
6574 NULL_TREE if we issued an error message, or error_mark_node if we
6575 did not. We issue error messages for out-and-out bad template
6576 parameters, but not simply because the conversion failed, since we
6577 might be just trying to do argument deduction. Both TYPE and EXPR
6578 must be non-dependent.
6580 The conversion follows the special rules described in
6581 [temp.arg.nontype], and it is much more strict than an implicit
6584 This function is called twice for each template argument (see
6585 lookup_template_class for a more accurate description of this
6586 problem). This means that we need to handle expressions which
6587 are not valid in a C++ source, but can be created from the
6588 first call (for instance, casts to perform conversions). These
6589 hacks can go away after we fix the double coercion problem. */
6592 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
6595 location_t loc
= cp_expr_loc_or_loc (expr
, input_location
);
6596 tree orig_expr
= expr
;
6598 /* Detect immediately string literals as invalid non-type argument.
6599 This special-case is not needed for correctness (we would easily
6600 catch this later), but only to provide better diagnostic for this
6601 common user mistake. As suggested by DR 100, we do not mention
6602 linkage issues in the diagnostic as this is not the point. */
6603 /* FIXME we're making this OK. */
6604 if (TREE_CODE (expr
) == STRING_CST
)
6606 if (complain
& tf_error
)
6607 error ("%qE is not a valid template argument for type %qT "
6608 "because string literals can never be used in this context",
6613 /* Add the ADDR_EXPR now for the benefit of
6614 value_dependent_expression_p. */
6615 if (TYPE_PTROBV_P (type
)
6616 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
6618 expr
= decay_conversion (expr
, complain
);
6619 if (expr
== error_mark_node
)
6620 return error_mark_node
;
6623 /* If we are in a template, EXPR may be non-dependent, but still
6624 have a syntactic, rather than semantic, form. For example, EXPR
6625 might be a SCOPE_REF, rather than the VAR_DECL to which the
6626 SCOPE_REF refers. Preserving the qualifying scope is necessary
6627 so that access checking can be performed when the template is
6628 instantiated -- but here we need the resolved form so that we can
6629 convert the argument. */
6630 bool non_dep
= false;
6631 if (TYPE_REF_OBJ_P (type
)
6632 && has_value_dependent_address (expr
))
6633 /* If we want the address and it's value-dependent, don't fold. */;
6634 else if (processing_template_decl
6635 && is_nondependent_constant_expression (expr
))
6637 if (error_operand_p (expr
))
6638 return error_mark_node
;
6639 expr_type
= TREE_TYPE (expr
);
6641 /* If the argument is non-dependent, perform any conversions in
6642 non-dependent context as well. */
6643 processing_template_decl_sentinel
s (non_dep
);
6645 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6647 if (value_dependent_expression_p (expr
))
6648 expr
= canonicalize_expr_argument (expr
, complain
);
6650 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
6651 to a non-type argument of "nullptr". */
6652 if (NULLPTR_TYPE_P (expr_type
) && TYPE_PTR_OR_PTRMEM_P (type
))
6653 expr
= fold_simple (convert (type
, expr
));
6655 /* In C++11, integral or enumeration non-type template arguments can be
6656 arbitrary constant expressions. Pointer and pointer to
6657 member arguments can be general constant expressions that evaluate
6658 to a null value, but otherwise still need to be of a specific form. */
6659 if (cxx_dialect
>= cxx11
)
6661 if (TREE_CODE (expr
) == PTRMEM_CST
)
6662 /* A PTRMEM_CST is already constant, and a valid template
6663 argument for a parameter of pointer to member type, we just want
6664 to leave it in that form rather than lower it to a
6666 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
6667 || cxx_dialect
>= cxx17
)
6669 /* C++17: A template-argument for a non-type template-parameter shall
6670 be a converted constant expression (8.20) of the type of the
6671 template-parameter. */
6672 expr
= build_converted_constant_expr (type
, expr
, complain
);
6673 if (expr
== error_mark_node
)
6674 return error_mark_node
;
6675 expr
= maybe_constant_value (expr
);
6676 expr
= convert_from_reference (expr
);
6678 else if (TYPE_PTR_OR_PTRMEM_P (type
))
6680 tree folded
= maybe_constant_value (expr
);
6681 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
6682 : null_member_pointer_value_p (folded
))
6687 if (TYPE_REF_P (type
))
6688 expr
= mark_lvalue_use (expr
);
6690 expr
= mark_rvalue_use (expr
);
6692 /* HACK: Due to double coercion, we can get a
6693 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
6694 which is the tree that we built on the first call (see
6695 below when coercing to reference to object or to reference to
6696 function). We just strip everything and get to the arg.
6697 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
6699 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
6701 tree probe_type
, probe
= expr
;
6702 if (REFERENCE_REF_P (probe
))
6703 probe
= TREE_OPERAND (probe
, 0);
6704 probe_type
= TREE_TYPE (probe
);
6705 if (TREE_CODE (probe
) == NOP_EXPR
)
6707 /* ??? Maybe we could use convert_from_reference here, but we
6708 would need to relax its constraints because the NOP_EXPR
6709 could actually change the type to something more cv-qualified,
6710 and this is not folded by convert_from_reference. */
6711 tree addr
= TREE_OPERAND (probe
, 0);
6712 if (TYPE_REF_P (probe_type
)
6713 && TREE_CODE (addr
) == ADDR_EXPR
6714 && TYPE_PTR_P (TREE_TYPE (addr
))
6715 && (same_type_ignoring_top_level_qualifiers_p
6716 (TREE_TYPE (probe_type
),
6717 TREE_TYPE (TREE_TYPE (addr
)))))
6719 expr
= TREE_OPERAND (addr
, 0);
6720 expr_type
= TREE_TYPE (probe_type
);
6725 /* [temp.arg.nontype]/5, bullet 1
6727 For a non-type template-parameter of integral or enumeration type,
6728 integral promotions (_conv.prom_) and integral conversions
6729 (_conv.integral_) are applied. */
6730 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6732 if (cxx_dialect
< cxx11
)
6734 tree t
= build_converted_constant_expr (type
, expr
, complain
);
6735 t
= maybe_constant_value (t
);
6736 if (t
!= error_mark_node
)
6740 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
6741 return error_mark_node
;
6743 /* Notice that there are constant expressions like '4 % 0' which
6744 do not fold into integer constants. */
6745 if (TREE_CODE (expr
) != INTEGER_CST
6746 && !value_dependent_expression_p (expr
))
6748 if (complain
& tf_error
)
6750 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
6751 if (!require_potential_constant_expression (expr
))
6752 expr
= error_mark_node
;
6754 expr
= cxx_constant_value (expr
);
6755 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
6756 inform (loc
, "in template argument for type %qT", type
);
6757 if (expr
== error_mark_node
)
6759 /* else cxx_constant_value complained but gave us
6760 a real constant, so go ahead. */
6761 if (TREE_CODE (expr
) != INTEGER_CST
)
6763 /* Some assemble time constant expressions like
6764 (intptr_t)&&lab1 - (intptr_t)&&lab2 or
6765 4 + (intptr_t)&&var satisfy reduced_constant_expression_p
6766 as we can emit them into .rodata initializers of
6767 variables, yet they can't fold into an INTEGER_CST at
6768 compile time. Refuse them here. */
6769 gcc_checking_assert (reduced_constant_expression_p (expr
));
6770 error_at (loc
, "template argument %qE for type %qT not "
6771 "a constant integer", expr
, type
);
6779 /* Avoid typedef problems. */
6780 if (TREE_TYPE (expr
) != type
)
6781 expr
= fold_convert (type
, expr
);
6783 /* [temp.arg.nontype]/5, bullet 2
6785 For a non-type template-parameter of type pointer to object,
6786 qualification conversions (_conv.qual_) and the array-to-pointer
6787 conversion (_conv.array_) are applied. */
6788 else if (TYPE_PTROBV_P (type
))
6790 tree decayed
= expr
;
6792 /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
6793 decay_conversion or an explicit cast. If it's a problematic cast,
6794 we'll complain about it below. */
6795 if (TREE_CODE (expr
) == NOP_EXPR
)
6799 if (TREE_CODE (probe
) == ADDR_EXPR
6800 && TYPE_PTR_P (TREE_TYPE (probe
)))
6803 expr_type
= TREE_TYPE (expr
);
6807 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6809 A template-argument for a non-type, non-template template-parameter
6810 shall be one of: [...]
6812 -- the name of a non-type template-parameter;
6813 -- the address of an object or function with external linkage, [...]
6814 expressed as "& id-expression" where the & is optional if the name
6815 refers to a function or array, or if the corresponding
6816 template-parameter is a reference.
6818 Here, we do not care about functions, as they are invalid anyway
6819 for a parameter of type pointer-to-object. */
6821 if (value_dependent_expression_p (expr
))
6822 /* Non-type template parameters are OK. */
6824 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6825 /* Null pointer values are OK in C++11. */;
6826 else if (TREE_CODE (expr
) != ADDR_EXPR
)
6830 if (complain
& tf_error
)
6831 error ("%qD is not a valid template argument "
6832 "because %qD is a variable, not the address of "
6833 "a variable", orig_expr
, expr
);
6836 if (INDIRECT_TYPE_P (expr_type
))
6838 if (complain
& tf_error
)
6839 error ("%qE is not a valid template argument for %qT "
6840 "because it is not the address of a variable",
6844 /* Other values, like integer constants, might be valid
6845 non-type arguments of some other type. */
6846 return error_mark_node
;
6850 tree decl
= TREE_OPERAND (expr
, 0);
6854 if (complain
& tf_error
)
6855 error ("%qE is not a valid template argument of type %qT "
6856 "because %qE is not a variable", orig_expr
, type
, decl
);
6859 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
6861 if (complain
& tf_error
)
6862 error ("%qE is not a valid template argument of type %qT "
6863 "because %qD does not have external linkage",
6864 orig_expr
, type
, decl
);
6867 else if ((cxx_dialect
>= cxx11
&& cxx_dialect
< cxx17
)
6868 && decl_linkage (decl
) == lk_none
)
6870 if (complain
& tf_error
)
6871 error ("%qE is not a valid template argument of type %qT "
6872 "because %qD has no linkage", orig_expr
, type
, decl
);
6875 /* C++17: For a non-type template-parameter of reference or pointer
6876 type, the value of the constant expression shall not refer to (or
6877 for a pointer type, shall not be the address of):
6878 * a subobject (4.5),
6879 * a temporary object (15.2),
6880 * a string literal (5.13.5),
6881 * the result of a typeid expression (8.2.8), or
6882 * a predefined __func__ variable (11.4.1). */
6883 else if (DECL_ARTIFICIAL (decl
))
6885 if (complain
& tf_error
)
6886 error ("the address of %qD is not a valid template argument",
6890 else if (!same_type_ignoring_top_level_qualifiers_p
6891 (strip_array_types (TREE_TYPE (type
)),
6892 strip_array_types (TREE_TYPE (decl
))))
6894 if (complain
& tf_error
)
6895 error ("the address of the %qT subobject of %qD is not a "
6896 "valid template argument", TREE_TYPE (type
), decl
);
6899 else if (!TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
6901 if (complain
& tf_error
)
6902 error ("the address of %qD is not a valid template argument "
6903 "because it does not have static storage duration",
6911 expr
= perform_qualification_conversions (type
, expr
);
6912 if (expr
== error_mark_node
)
6913 return error_mark_node
;
6915 /* [temp.arg.nontype]/5, bullet 3
6917 For a non-type template-parameter of type reference to object, no
6918 conversions apply. The type referred to by the reference may be more
6919 cv-qualified than the (otherwise identical) type of the
6920 template-argument. The template-parameter is bound directly to the
6921 template-argument, which must be an lvalue. */
6922 else if (TYPE_REF_OBJ_P (type
))
6924 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
6926 return error_mark_node
;
6928 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
6930 if (complain
& tf_error
)
6931 error ("%qE is not a valid template argument for type %qT "
6932 "because of conflicts in cv-qualification", expr
, type
);
6936 if (!lvalue_p (expr
))
6938 if (complain
& tf_error
)
6939 error ("%qE is not a valid template argument for type %qT "
6940 "because it is not an lvalue", expr
, type
);
6944 /* [temp.arg.nontype]/1
6946 A template-argument for a non-type, non-template template-parameter
6947 shall be one of: [...]
6949 -- the address of an object or function with external linkage. */
6950 if (INDIRECT_REF_P (expr
)
6951 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
6953 expr
= TREE_OPERAND (expr
, 0);
6956 if (complain
& tf_error
)
6957 error ("%q#D is not a valid template argument for type %qT "
6958 "because a reference variable does not have a constant "
6959 "address", expr
, type
);
6964 if (TYPE_REF_OBJ_P (TREE_TYPE (expr
))
6965 && value_dependent_expression_p (expr
))
6966 /* OK, dependent reference. We don't want to ask whether a DECL is
6967 itself value-dependent, since what we want here is its address. */;
6972 if (complain
& tf_error
)
6973 error ("%qE is not a valid template argument for type %qT "
6974 "because it is not an object with linkage",
6979 /* DR 1155 allows internal linkage in C++11 and up. */
6980 linkage_kind linkage
= decl_linkage (expr
);
6981 if (linkage
< (cxx_dialect
>= cxx11
? lk_internal
: lk_external
))
6983 if (complain
& tf_error
)
6984 error ("%qE is not a valid template argument for type %qT "
6985 "because object %qD does not have linkage",
6990 expr
= build_address (expr
);
6993 if (!same_type_p (type
, TREE_TYPE (expr
)))
6994 expr
= build_nop (type
, expr
);
6996 /* [temp.arg.nontype]/5, bullet 4
6998 For a non-type template-parameter of type pointer to function, only
6999 the function-to-pointer conversion (_conv.func_) is applied. If the
7000 template-argument represents a set of overloaded functions (or a
7001 pointer to such), the matching function is selected from the set
7003 else if (TYPE_PTRFN_P (type
))
7005 /* If the argument is a template-id, we might not have enough
7006 context information to decay the pointer. */
7007 if (!type_unknown_p (expr_type
))
7009 expr
= decay_conversion (expr
, complain
);
7010 if (expr
== error_mark_node
)
7011 return error_mark_node
;
7014 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
7015 /* Null pointer values are OK in C++11. */
7016 return perform_qualification_conversions (type
, expr
);
7018 expr
= convert_nontype_argument_function (type
, expr
, complain
);
7019 if (!expr
|| expr
== error_mark_node
)
7022 /* [temp.arg.nontype]/5, bullet 5
7024 For a non-type template-parameter of type reference to function, no
7025 conversions apply. If the template-argument represents a set of
7026 overloaded functions, the matching function is selected from the set
7028 else if (TYPE_REFFN_P (type
))
7030 if (TREE_CODE (expr
) == ADDR_EXPR
)
7032 if (complain
& tf_error
)
7034 error ("%qE is not a valid template argument for type %qT "
7035 "because it is a pointer", expr
, type
);
7036 inform (input_location
, "try using %qE instead",
7037 TREE_OPERAND (expr
, 0));
7042 expr
= convert_nontype_argument_function (type
, expr
, complain
);
7043 if (!expr
|| expr
== error_mark_node
)
7046 /* [temp.arg.nontype]/5, bullet 6
7048 For a non-type template-parameter of type pointer to member function,
7049 no conversions apply. If the template-argument represents a set of
7050 overloaded member functions, the matching member function is selected
7051 from the set (_over.over_). */
7052 else if (TYPE_PTRMEMFUNC_P (type
))
7054 expr
= instantiate_type (type
, expr
, tf_none
);
7055 if (expr
== error_mark_node
)
7056 return error_mark_node
;
7058 /* [temp.arg.nontype] bullet 1 says the pointer to member
7059 expression must be a pointer-to-member constant. */
7060 if (!value_dependent_expression_p (expr
)
7061 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
7064 /* Repeated conversion can't deal with a conversion that turns PTRMEM_CST
7065 into a CONSTRUCTOR, so build up a new PTRMEM_CST instead. */
7066 if (fnptr_conv_p (type
, TREE_TYPE (expr
)))
7067 expr
= make_ptrmem_cst (type
, PTRMEM_CST_MEMBER (expr
));
7069 /* [temp.arg.nontype]/5, bullet 7
7071 For a non-type template-parameter of type pointer to data member,
7072 qualification conversions (_conv.qual_) are applied. */
7073 else if (TYPE_PTRDATAMEM_P (type
))
7075 /* [temp.arg.nontype] bullet 1 says the pointer to member
7076 expression must be a pointer-to-member constant. */
7077 if (!value_dependent_expression_p (expr
)
7078 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
7081 expr
= perform_qualification_conversions (type
, expr
);
7082 if (expr
== error_mark_node
)
7085 else if (NULLPTR_TYPE_P (type
))
7087 if (!NULLPTR_TYPE_P (TREE_TYPE (expr
)))
7089 if (complain
& tf_error
)
7090 error ("%qE is not a valid template argument for type %qT "
7091 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
7096 /* A template non-type parameter must be one of the above. */
7100 /* Sanity check: did we actually convert the argument to the
7102 gcc_assert (same_type_ignoring_top_level_qualifiers_p
7103 (type
, TREE_TYPE (expr
)));
7104 return convert_from_reference (expr
);
7107 /* Subroutine of coerce_template_template_parms, which returns 1 if
7108 PARM_PARM and ARG_PARM match using the rule for the template
7109 parameters of template template parameters. Both PARM and ARG are
7110 template parameters; the rest of the arguments are the same as for
7111 coerce_template_template_parms.
7114 coerce_template_template_parm (tree parm
,
7116 tsubst_flags_t complain
,
7120 if (arg
== NULL_TREE
|| error_operand_p (arg
)
7121 || parm
== NULL_TREE
|| error_operand_p (parm
))
7124 if (TREE_CODE (arg
) != TREE_CODE (parm
))
7127 switch (TREE_CODE (parm
))
7130 /* We encounter instantiations of templates like
7131 template <template <template <class> class> class TT>
7134 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
7135 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
7137 if (!coerce_template_template_parms
7138 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
7144 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
7145 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
7146 /* Argument is a parameter pack but parameter is not. */
7151 /* The tsubst call is used to handle cases such as
7153 template <int> class C {};
7154 template <class T, template <T> class TT> class D {};
7157 i.e. the parameter list of TT depends on earlier parameters. */
7158 if (!uses_template_parms (TREE_TYPE (arg
)))
7160 tree t
= tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
);
7161 if (!uses_template_parms (t
)
7162 && !same_type_p (t
, TREE_TYPE (arg
)))
7166 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
7167 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
7168 /* Argument is a parameter pack but parameter is not. */
7180 /* Coerce template argument list ARGLIST for use with template
7181 template-parameter TEMPL. */
7184 coerce_template_args_for_ttp (tree templ
, tree arglist
,
7185 tsubst_flags_t complain
)
7187 /* Consider an example where a template template parameter declared as
7189 template <class T, class U = std::allocator<T> > class TT
7191 The template parameter level of T and U are one level larger than
7192 of TT. To proper process the default argument of U, say when an
7193 instantiation `TT<int>' is seen, we need to build the full
7194 arguments containing {int} as the innermost level. Outer levels,
7195 available when not appearing as default template argument, can be
7196 obtained from the arguments of the enclosing template.
7198 Suppose that TT is later substituted with std::vector. The above
7199 instantiation is `TT<int, std::allocator<T> >' with TT at
7200 level 1, and T at level 2, while the template arguments at level 1
7201 becomes {std::vector} and the inner level 2 is {int}. */
7203 tree outer
= DECL_CONTEXT (templ
);
7206 if (DECL_TEMPLATE_SPECIALIZATION (outer
))
7207 /* We want arguments for the partial specialization, not arguments for
7208 the primary template. */
7209 outer
= template_parms_to_args (DECL_TEMPLATE_PARMS (outer
));
7211 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7213 else if (current_template_parms
)
7215 /* This is an argument of the current template, so we haven't set
7216 DECL_CONTEXT yet. */
7217 tree relevant_template_parms
;
7219 /* Parameter levels that are greater than the level of the given
7220 template template parm are irrelevant. */
7221 relevant_template_parms
= current_template_parms
;
7222 while (TMPL_PARMS_DEPTH (relevant_template_parms
)
7223 != TEMPLATE_TYPE_LEVEL (TREE_TYPE (templ
)))
7224 relevant_template_parms
= TREE_CHAIN (relevant_template_parms
);
7226 outer
= template_parms_to_args (relevant_template_parms
);
7230 arglist
= add_to_template_args (outer
, arglist
);
7232 tree parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7233 return coerce_template_parms (parmlist
, arglist
, templ
,
7235 /*require_all_args=*/true,
7236 /*use_default_args=*/true);
7239 /* A cache of template template parameters with match-all default
7241 static GTY((deletable
)) hash_map
<tree
,tree
> *defaulted_ttp_cache
;
7243 store_defaulted_ttp (tree v
, tree t
)
7245 if (!defaulted_ttp_cache
)
7246 defaulted_ttp_cache
= hash_map
<tree
,tree
>::create_ggc (13);
7247 defaulted_ttp_cache
->put (v
, t
);
7250 lookup_defaulted_ttp (tree v
)
7252 if (defaulted_ttp_cache
)
7253 if (tree
*p
= defaulted_ttp_cache
->get (v
))
7258 /* T is a bound template template-parameter. Copy its arguments into default
7259 arguments of the template template-parameter's template parameters. */
7262 add_defaults_to_ttp (tree otmpl
)
7264 if (tree c
= lookup_defaulted_ttp (otmpl
))
7267 tree ntmpl
= copy_node (otmpl
);
7269 tree ntype
= copy_node (TREE_TYPE (otmpl
));
7270 TYPE_STUB_DECL (ntype
) = TYPE_NAME (ntype
) = ntmpl
;
7271 TYPE_MAIN_VARIANT (ntype
) = ntype
;
7272 TYPE_POINTER_TO (ntype
) = TYPE_REFERENCE_TO (ntype
) = NULL_TREE
;
7273 TYPE_NAME (ntype
) = ntmpl
;
7274 SET_TYPE_STRUCTURAL_EQUALITY (ntype
);
7276 tree idx
= TEMPLATE_TYPE_PARM_INDEX (ntype
)
7277 = copy_node (TEMPLATE_TYPE_PARM_INDEX (ntype
));
7278 TEMPLATE_PARM_DECL (idx
) = ntmpl
;
7279 TREE_TYPE (ntmpl
) = TREE_TYPE (idx
) = ntype
;
7281 tree oparms
= DECL_TEMPLATE_PARMS (otmpl
);
7282 tree parms
= DECL_TEMPLATE_PARMS (ntmpl
) = copy_node (oparms
);
7283 TREE_CHAIN (parms
) = TREE_CHAIN (oparms
);
7284 tree vec
= TREE_VALUE (parms
) = copy_node (TREE_VALUE (parms
));
7285 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
7287 tree o
= TREE_VEC_ELT (vec
, i
);
7288 if (!template_parameter_pack_p (TREE_VALUE (o
)))
7290 tree n
= TREE_VEC_ELT (vec
, i
) = copy_node (o
);
7291 TREE_PURPOSE (n
) = any_targ_node
;
7295 store_defaulted_ttp (otmpl
, ntmpl
);
7299 /* ARG is a bound potential template template-argument, and PARGS is a list
7300 of arguments for the corresponding template template-parameter. Adjust
7301 PARGS as appropriate for application to ARG's template, and if ARG is a
7302 BOUND_TEMPLATE_TEMPLATE_PARM, possibly adjust it to add default template
7303 arguments to the template template parameter. */
7306 coerce_ttp_args_for_tta (tree
& arg
, tree pargs
, tsubst_flags_t complain
)
7308 ++processing_template_decl
;
7309 tree arg_tmpl
= TYPE_TI_TEMPLATE (arg
);
7310 if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg_tmpl
))
7312 /* When comparing two template template-parameters in partial ordering,
7313 rewrite the one currently being used as an argument to have default
7314 arguments for all parameters. */
7315 arg_tmpl
= add_defaults_to_ttp (arg_tmpl
);
7316 pargs
= coerce_template_args_for_ttp (arg_tmpl
, pargs
, complain
);
7317 if (pargs
!= error_mark_node
)
7318 arg
= bind_template_template_parm (TREE_TYPE (arg_tmpl
),
7319 TYPE_TI_ARGS (arg
));
7324 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (arg_tmpl
));
7325 pargs
= coerce_template_parms (aparms
, pargs
, arg_tmpl
, complain
,
7326 /*require_all*/true,
7327 /*use_default*/true);
7329 --processing_template_decl
;
7333 /* Subroutine of unify for the case when PARM is a
7334 BOUND_TEMPLATE_TEMPLATE_PARM. */
7337 unify_bound_ttp_args (tree tparms
, tree targs
, tree parm
, tree
& arg
,
7340 tree parmvec
= TYPE_TI_ARGS (parm
);
7341 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
7343 /* The template template parm might be variadic and the argument
7344 not, so flatten both argument lists. */
7345 parmvec
= expand_template_argument_pack (parmvec
);
7346 argvec
= expand_template_argument_pack (argvec
);
7350 /* In keeping with P0522R0, adjust P's template arguments
7351 to apply to A's template; then flatten it again. */
7352 tree nparmvec
= parmvec
;
7353 nparmvec
= coerce_ttp_args_for_tta (arg
, parmvec
, tf_none
);
7354 nparmvec
= expand_template_argument_pack (nparmvec
);
7356 if (unify (tparms
, targs
, nparmvec
, argvec
,
7357 UNIFY_ALLOW_NONE
, explain_p
))
7360 /* If the P0522 adjustment eliminated a pack expansion, deduce
7363 && TREE_VEC_LENGTH (nparmvec
) < TREE_VEC_LENGTH (parmvec
)
7364 && unify_pack_expansion (tparms
, targs
, parmvec
, argvec
,
7365 DEDUCE_EXACT
, /*sub*/true, explain_p
))
7370 /* Deduce arguments T, i from TT<T> or TT<i>.
7371 We check each element of PARMVEC and ARGVEC individually
7372 rather than the whole TREE_VEC since they can have
7373 different number of elements, which is allowed under N2555. */
7375 int len
= TREE_VEC_LENGTH (parmvec
);
7377 /* Check if the parameters end in a pack, making them
7379 int parm_variadic_p
= 0;
7381 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
7382 parm_variadic_p
= 1;
7384 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7385 /* If the template argument list of P contains a pack
7386 expansion that is not the last template argument, the
7387 entire template argument list is a non-deduced
7389 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
7390 return unify_success (explain_p
);
7392 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
7393 return unify_too_few_arguments (explain_p
,
7394 TREE_VEC_LENGTH (argvec
), len
);
7396 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7397 if (unify (tparms
, targs
,
7398 TREE_VEC_ELT (parmvec
, i
),
7399 TREE_VEC_ELT (argvec
, i
),
7400 UNIFY_ALLOW_NONE
, explain_p
))
7404 && unify_pack_expansion (tparms
, targs
,
7407 /*subr=*/true, explain_p
))
7414 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
7415 template template parameters. Both PARM_PARMS and ARG_PARMS are
7416 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
7419 Consider the example:
7420 template <class T> class A;
7421 template<template <class U> class TT> class B;
7423 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
7424 the parameters to A, and OUTER_ARGS contains A. */
7427 coerce_template_template_parms (tree parm_parms
,
7429 tsubst_flags_t complain
,
7433 int nparms
, nargs
, i
;
7437 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
7438 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
7440 nparms
= TREE_VEC_LENGTH (parm_parms
);
7441 nargs
= TREE_VEC_LENGTH (arg_parms
);
7445 /* P0522R0: A template template-parameter P is at least as specialized as
7446 a template template-argument A if, given the following rewrite to two
7447 function templates, the function template corresponding to P is at
7448 least as specialized as the function template corresponding to A
7449 according to the partial ordering rules for function templates
7450 ([temp.func.order]). Given an invented class template X with the
7451 template parameter list of A (including default arguments):
7453 * Each of the two function templates has the same template parameters,
7454 respectively, as P or A.
7456 * Each function template has a single function parameter whose type is
7457 a specialization of X with template arguments corresponding to the
7458 template parameters from the respective function template where, for
7459 each template parameter PP in the template parameter list of the
7460 function template, a corresponding template argument AA is formed. If
7461 PP declares a parameter pack, then AA is the pack expansion
7462 PP... ([temp.variadic]); otherwise, AA is the id-expression PP.
7464 If the rewrite produces an invalid type, then P is not at least as
7465 specialized as A. */
7467 /* So coerce P's args to apply to A's parms, and then deduce between A's
7468 args and the converted args. If that succeeds, A is at least as
7469 specialized as P, so they match.*/
7470 tree pargs
= template_parms_level_to_args (parm_parms
);
7471 ++processing_template_decl
;
7472 pargs
= coerce_template_parms (arg_parms
, pargs
, NULL_TREE
, tf_none
,
7473 /*require_all*/true, /*use_default*/true);
7474 --processing_template_decl
;
7475 if (pargs
!= error_mark_node
)
7477 tree targs
= make_tree_vec (nargs
);
7478 tree aargs
= template_parms_level_to_args (arg_parms
);
7479 if (!unify (arg_parms
, targs
, aargs
, pargs
, UNIFY_ALLOW_NONE
,
7485 /* Determine whether we have a parameter pack at the end of the
7486 template template parameter's template parameter list. */
7487 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
7489 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
7491 if (error_operand_p (parm
))
7494 switch (TREE_CODE (parm
))
7498 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
7503 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
7513 && !(variadic_p
&& nargs
>= nparms
- 1))
7516 /* Check all of the template parameters except the parameter pack at
7517 the end (if any). */
7518 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
7520 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
7521 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7524 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7525 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7527 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7535 /* Check each of the template parameters in the template
7536 argument against the template parameter pack at the end of
7537 the template template parameter. */
7538 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
7541 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7543 for (; i
< nargs
; ++i
)
7545 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7548 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7550 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7559 /* Verifies that the deduced template arguments (in TARGS) for the
7560 template template parameters (in TPARMS) represent valid bindings,
7561 by comparing the template parameter list of each template argument
7562 to the template parameter list of its corresponding template
7563 template parameter, in accordance with DR150. This
7564 routine can only be called after all template arguments have been
7565 deduced. It will return TRUE if all of the template template
7566 parameter bindings are okay, FALSE otherwise. */
7568 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
7570 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
7573 /* We're dealing with template parms in this process. */
7574 ++processing_template_decl
;
7576 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
7578 for (i
= 0; i
< ntparms
; ++i
)
7580 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
7581 tree targ
= TREE_VEC_ELT (targs
, i
);
7583 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
7585 tree packed_args
= NULL_TREE
;
7588 if (ARGUMENT_PACK_P (targ
))
7590 /* Look inside the argument pack. */
7591 packed_args
= ARGUMENT_PACK_ARGS (targ
);
7592 len
= TREE_VEC_LENGTH (packed_args
);
7595 for (idx
= 0; idx
< len
; ++idx
)
7597 tree targ_parms
= NULL_TREE
;
7600 /* Extract the next argument from the argument
7602 targ
= TREE_VEC_ELT (packed_args
, idx
);
7604 if (PACK_EXPANSION_P (targ
))
7605 /* Look at the pattern of the pack expansion. */
7606 targ
= PACK_EXPANSION_PATTERN (targ
);
7608 /* Extract the template parameters from the template
7610 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
7611 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
7612 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
7613 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
7615 /* Verify that we can coerce the template template
7616 parameters from the template argument to the template
7617 parameter. This requires an exact match. */
7619 && !coerce_template_template_parms
7620 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
7635 --processing_template_decl
;
7639 /* Since type attributes aren't mangled, we need to strip them from
7640 template type arguments. */
7643 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
7645 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
7647 bool removed_attributes
= false;
7648 tree canon
= strip_typedefs (arg
, &removed_attributes
);
7649 if (removed_attributes
7650 && (complain
& tf_warning
))
7651 warning (OPT_Wignored_attributes
,
7652 "ignoring attributes on template argument %qT", arg
);
7656 /* And from inside dependent non-type arguments like sizeof(Type). */
7659 canonicalize_expr_argument (tree arg
, tsubst_flags_t complain
)
7661 if (!arg
|| arg
== error_mark_node
)
7663 bool removed_attributes
= false;
7664 tree canon
= strip_typedefs_expr (arg
, &removed_attributes
);
7665 if (removed_attributes
7666 && (complain
& tf_warning
))
7667 warning (OPT_Wignored_attributes
,
7668 "ignoring attributes in template argument %qE", arg
);
7672 // A template declaration can be substituted for a constrained
7673 // template template parameter only when the argument is more
7674 // constrained than the parameter.
7676 is_compatible_template_arg (tree parm
, tree arg
)
7678 tree parm_cons
= get_constraints (parm
);
7680 /* For now, allow constrained template template arguments
7681 and unconstrained template template parameters. */
7682 if (parm_cons
== NULL_TREE
)
7685 tree arg_cons
= get_constraints (arg
);
7687 // If the template parameter is constrained, we need to rewrite its
7688 // constraints in terms of the ARG's template parameters. This ensures
7689 // that all of the template parameter types will have the same depth.
7691 // Note that this is only valid when coerce_template_template_parm is
7692 // true for the innermost template parameters of PARM and ARG. In other
7693 // words, because coercion is successful, this conversion will be valid.
7696 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (arg
));
7697 parm_cons
= tsubst_constraint_info (parm_cons
,
7698 INNERMOST_TEMPLATE_ARGS (args
),
7699 tf_none
, NULL_TREE
);
7700 if (parm_cons
== error_mark_node
)
7704 return subsumes (parm_cons
, arg_cons
);
7707 // Convert a placeholder argument into a binding to the original
7708 // parameter. The original parameter is saved as the TREE_TYPE of
7711 convert_wildcard_argument (tree parm
, tree arg
)
7713 TREE_TYPE (arg
) = parm
;
7717 /* We can't fully resolve ARG given as a non-type template argument to TYPE,
7718 because one of them is dependent. But we need to represent the
7719 conversion for the benefit of cp_tree_equal. */
7722 maybe_convert_nontype_argument (tree type
, tree arg
)
7724 /* Auto parms get no conversion. */
7725 if (type_uses_auto (type
))
7727 /* We don't need or want to add this conversion now if we're going to use the
7728 argument for deduction. */
7729 if (value_dependent_expression_p (arg
))
7732 type
= cv_unqualified (type
);
7733 tree argtype
= TREE_TYPE (arg
);
7734 if (same_type_p (type
, argtype
))
7737 arg
= build1 (IMPLICIT_CONV_EXPR
, type
, arg
);
7738 IMPLICIT_CONV_EXPR_NONTYPE_ARG (arg
) = true;
7742 /* Convert the indicated template ARG as necessary to match the
7743 indicated template PARM. Returns the converted ARG, or
7744 error_mark_node if the conversion was unsuccessful. Error and
7745 warning messages are issued under control of COMPLAIN. This
7746 conversion is for the Ith parameter in the parameter list. ARGS is
7747 the full set of template arguments deduced so far. */
7750 convert_template_argument (tree parm
,
7753 tsubst_flags_t complain
,
7759 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
7761 if (parm
== error_mark_node
)
7762 return error_mark_node
;
7764 /* Trivially convert placeholders. */
7765 if (TREE_CODE (arg
) == WILDCARD_DECL
)
7766 return convert_wildcard_argument (parm
, arg
);
7768 if (arg
== any_targ_node
)
7771 if (TREE_CODE (arg
) == TREE_LIST
7772 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
7774 /* The template argument was the name of some
7775 member function. That's usually
7776 invalid, but static members are OK. In any
7777 case, grab the underlying fields/functions
7778 and issue an error later if required. */
7779 orig_arg
= TREE_VALUE (arg
);
7780 TREE_TYPE (arg
) = unknown_type_node
;
7785 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
7786 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
7787 || requires_tmpl_type
);
7789 /* When determining whether an argument pack expansion is a template,
7790 look at the pattern. */
7791 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
7792 arg
= PACK_EXPANSION_PATTERN (arg
);
7794 /* Deal with an injected-class-name used as a template template arg. */
7795 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
7797 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
7798 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7800 if (cxx_dialect
>= cxx11
)
7801 /* OK under DR 1004. */;
7802 else if (complain
& tf_warning_or_error
)
7803 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
7804 " used as template template argument", TYPE_NAME (arg
));
7805 else if (flag_pedantic_errors
)
7813 ((TREE_CODE (arg
) == TEMPLATE_DECL
7814 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
7815 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
7816 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7817 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
7820 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7821 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
7822 arg
= TYPE_STUB_DECL (arg
);
7824 is_type
= TYPE_P (arg
) || is_tmpl_type
;
7826 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
7827 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
7829 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
7831 if (complain
& tf_error
)
7832 error ("invalid use of destructor %qE as a type", orig_arg
);
7833 return error_mark_node
;
7836 permerror (input_location
,
7837 "to refer to a type member of a template parameter, "
7838 "use %<typename %E%>", orig_arg
);
7840 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
7841 TREE_OPERAND (arg
, 1),
7847 if (is_type
!= requires_type
)
7851 if (complain
& tf_error
)
7853 error ("type/value mismatch at argument %d in template "
7854 "parameter list for %qD",
7857 inform (input_location
,
7858 " expected a constant of type %qT, got %qT",
7860 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
7861 else if (requires_tmpl_type
)
7862 inform (input_location
,
7863 " expected a class template, got %qE", orig_arg
);
7865 inform (input_location
,
7866 " expected a type, got %qE", orig_arg
);
7869 return error_mark_node
;
7871 if (is_tmpl_type
^ requires_tmpl_type
)
7873 if (in_decl
&& (complain
& tf_error
))
7875 error ("type/value mismatch at argument %d in template "
7876 "parameter list for %qD",
7879 inform (input_location
,
7880 " expected a type, got %qT", DECL_NAME (arg
));
7882 inform (input_location
,
7883 " expected a class template, got %qT", orig_arg
);
7885 return error_mark_node
;
7888 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
7889 /* We already did the appropriate conversion when packing args. */
7893 if (requires_tmpl_type
)
7895 if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
7896 /* The number of argument required is not known yet.
7897 Just accept it for now. */
7901 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
7904 /* Strip alias templates that are equivalent to another
7906 arg
= get_underlying_template (arg
);
7907 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
7909 if (coerce_template_template_parms (parmparm
, argparm
,
7915 /* TEMPLATE_TEMPLATE_PARM node is preferred over
7917 if (val
!= error_mark_node
)
7919 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
7920 val
= TREE_TYPE (val
);
7921 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
7922 val
= make_pack_expansion (val
, complain
);
7927 if (in_decl
&& (complain
& tf_error
))
7929 error ("type/value mismatch at argument %d in "
7930 "template parameter list for %qD",
7932 inform (input_location
,
7933 " expected a template of type %qD, got %qT",
7937 val
= error_mark_node
;
7940 // Check that the constraints are compatible before allowing the
7942 if (val
!= error_mark_node
)
7943 if (!is_compatible_template_arg (parm
, arg
))
7945 if (in_decl
&& (complain
& tf_error
))
7947 error ("constraint mismatch at argument %d in "
7948 "template parameter list for %qD",
7950 inform (input_location
, " expected %qD but got %qD",
7953 val
= error_mark_node
;
7959 /* We only form one instance of each template specialization.
7960 Therefore, if we use a non-canonical variant (i.e., a
7961 typedef), any future messages referring to the type will use
7962 the typedef, which is confusing if those future uses do not
7963 themselves also use the typedef. */
7965 val
= canonicalize_type_argument (val
, complain
);
7969 tree t
= TREE_TYPE (parm
);
7971 if (TEMPLATE_PARM_LEVEL (get_template_parm_index (parm
))
7972 > TMPL_ARGS_DEPTH (args
))
7973 /* We don't have enough levels of args to do any substitution. This
7974 can happen in the context of -fnew-ttp-matching. */;
7975 else if (tree a
= type_uses_auto (t
))
7977 t
= do_auto_deduction (t
, arg
, a
, complain
, adc_unify
, args
);
7978 if (t
== error_mark_node
)
7979 return error_mark_node
;
7982 t
= tsubst (t
, args
, complain
, in_decl
);
7984 if (invalid_nontype_parm_type_p (t
, complain
))
7985 return error_mark_node
;
7987 if (!type_dependent_expression_p (orig_arg
)
7988 && !uses_template_parms (t
))
7989 /* We used to call digest_init here. However, digest_init
7990 will report errors, which we don't want when complain
7991 is zero. More importantly, digest_init will try too
7992 hard to convert things: for example, `0' should not be
7993 converted to pointer type at this point according to
7994 the standard. Accepting this is not merely an
7995 extension, since deciding whether or not these
7996 conversions can occur is part of determining which
7997 function template to call, or whether a given explicit
7998 argument specification is valid. */
7999 val
= convert_nontype_argument (t
, orig_arg
, complain
);
8002 val
= canonicalize_expr_argument (orig_arg
, complain
);
8003 val
= maybe_convert_nontype_argument (t
, val
);
8007 if (val
== NULL_TREE
)
8008 val
= error_mark_node
;
8009 else if (val
== error_mark_node
&& (complain
& tf_error
))
8010 error ("could not convert template argument %qE from %qT to %qT",
8011 orig_arg
, TREE_TYPE (orig_arg
), t
);
8013 if (INDIRECT_REF_P (val
))
8015 /* Reject template arguments that are references to built-in
8016 functions with no library fallbacks. */
8017 const_tree inner
= TREE_OPERAND (val
, 0);
8018 const_tree innertype
= TREE_TYPE (inner
);
8020 && TYPE_REF_P (innertype
)
8021 && TREE_CODE (TREE_TYPE (innertype
)) == FUNCTION_TYPE
8022 && TREE_OPERAND_LENGTH (inner
) > 0
8023 && reject_gcc_builtin (TREE_OPERAND (inner
, 0)))
8024 return error_mark_node
;
8027 if (TREE_CODE (val
) == SCOPE_REF
)
8029 /* Strip typedefs from the SCOPE_REF. */
8030 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
8031 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
8033 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
8034 QUALIFIED_NAME_IS_TEMPLATE (val
));
8041 /* Coerces the remaining template arguments in INNER_ARGS (from
8042 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
8043 Returns the coerced argument pack. PARM_IDX is the position of this
8044 parameter in the template parameter list. ARGS is the original
8045 template argument list. */
8047 coerce_template_parameter_pack (tree parms
,
8055 tsubst_flags_t complain
)
8057 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
8058 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
8061 tree packed_parms
= NULL_TREE
;
8063 if (arg_idx
> nargs
)
8066 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
8068 /* When the template parameter is a non-type template parameter pack
8069 or template template parameter pack whose type or template
8070 parameters use parameter packs, we know exactly how many arguments
8071 we are looking for. Build a vector of the instantiated decls for
8072 these template parameters in PACKED_PARMS. */
8073 /* We can't use make_pack_expansion here because it would interpret a
8074 _DECL as a use rather than a declaration. */
8075 tree decl
= TREE_VALUE (parm
);
8076 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
8077 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
8078 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
8079 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
8081 TREE_VEC_LENGTH (args
)--;
8082 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
8083 TREE_VEC_LENGTH (args
)++;
8085 if (packed_parms
== error_mark_node
)
8086 return error_mark_node
;
8088 /* If we're doing a partial instantiation of a member template,
8089 verify that all of the types used for the non-type
8090 template parameter pack are, in fact, valid for non-type
8091 template parameters. */
8093 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
8095 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
8096 for (j
= 0; j
< len
; ++j
)
8098 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
8099 if (invalid_nontype_parm_type_p (t
, complain
))
8100 return error_mark_node
;
8102 /* We don't know how many args we have yet, just
8103 use the unconverted ones for now. */
8107 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
8109 /* Check if we have a placeholder pack, which indicates we're
8110 in the context of a introduction list. In that case we want
8111 to match this pack to the single placeholder. */
8112 else if (arg_idx
< nargs
8113 && TREE_CODE (TREE_VEC_ELT (inner_args
, arg_idx
)) == WILDCARD_DECL
8114 && WILDCARD_PACK_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
8116 nargs
= arg_idx
+ 1;
8117 packed_args
= make_tree_vec (1);
8120 packed_args
= make_tree_vec (nargs
- arg_idx
);
8122 /* Convert the remaining arguments, which will be a part of the
8123 parameter pack "parm". */
8124 int first_pack_arg
= arg_idx
;
8125 for (; arg_idx
< nargs
; ++arg_idx
)
8127 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
8128 tree actual_parm
= TREE_VALUE (parm
);
8129 int pack_idx
= arg_idx
- first_pack_arg
;
8133 /* Once we've packed as many args as we have types, stop. */
8134 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
8136 else if (PACK_EXPANSION_P (arg
))
8137 /* We don't know how many args we have yet, just
8138 use the unconverted ones for now. */
8141 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
8144 if (arg
== error_mark_node
)
8146 if (complain
& tf_error
)
8147 error ("template argument %d is invalid", arg_idx
+ 1);
8150 arg
= convert_template_argument (actual_parm
,
8151 arg
, new_args
, complain
, parm_idx
,
8153 if (arg
== error_mark_node
)
8155 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
8158 if (arg_idx
- first_pack_arg
< TREE_VEC_LENGTH (packed_args
)
8159 && TREE_VEC_LENGTH (packed_args
) > 0)
8161 if (complain
& tf_error
)
8162 error ("wrong number of template arguments (%d, should be %d)",
8163 arg_idx
- first_pack_arg
, TREE_VEC_LENGTH (packed_args
));
8164 return error_mark_node
;
8167 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
8168 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
8169 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
8172 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
8173 TREE_CONSTANT (argument_pack
) = 1;
8176 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
8178 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
8179 TREE_VEC_LENGTH (packed_args
));
8180 return argument_pack
;
8183 /* Returns the number of pack expansions in the template argument vector
8187 pack_expansion_args_count (tree args
)
8192 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
8194 tree elt
= TREE_VEC_ELT (args
, i
);
8195 if (elt
&& PACK_EXPANSION_P (elt
))
8201 /* Convert all template arguments to their appropriate types, and
8202 return a vector containing the innermost resulting template
8203 arguments. If any error occurs, return error_mark_node. Error and
8204 warning messages are issued under control of COMPLAIN.
8206 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
8207 for arguments not specified in ARGS. Otherwise, if
8208 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
8209 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
8210 USE_DEFAULT_ARGS is false, then all arguments must be specified in
8214 coerce_template_parms (tree parms
,
8217 tsubst_flags_t complain
,
8218 bool require_all_args
,
8219 bool use_default_args
)
8221 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
8222 tree orig_inner_args
;
8225 tree new_inner_args
;
8226 int saved_unevaluated_operand
;
8227 int saved_inhibit_evaluation_warnings
;
8229 /* When used as a boolean value, indicates whether this is a
8230 variadic template parameter list. Since it's an int, we can also
8231 subtract it from nparms to get the number of non-variadic
8234 int variadic_args_p
= 0;
8235 int post_variadic_parms
= 0;
8237 /* Adjustment to nparms for fixed parameter packs. */
8238 int fixed_pack_adjust
= 0;
8239 int fixed_packs
= 0;
8242 /* Likewise for parameters with default arguments. */
8245 if (args
== error_mark_node
)
8246 return error_mark_node
;
8248 nparms
= TREE_VEC_LENGTH (parms
);
8250 /* Determine if there are any parameter packs or default arguments. */
8251 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
8253 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
8255 ++post_variadic_parms
;
8256 if (template_parameter_pack_p (TREE_VALUE (parm
)))
8258 if (TREE_PURPOSE (parm
))
8262 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
8263 /* If there are no parameters that follow a parameter pack, we need to
8264 expand any argument packs so that we can deduce a parameter pack from
8265 some non-packed args followed by an argument pack, as in variadic85.C.
8266 If there are such parameters, we need to leave argument packs intact
8267 so the arguments are assigned properly. This can happen when dealing
8268 with a nested class inside a partial specialization of a class
8269 template, as in variadic92.C, or when deducing a template parameter pack
8270 from a sub-declarator, as in variadic114.C. */
8271 if (!post_variadic_parms
)
8272 inner_args
= expand_template_argument_pack (inner_args
);
8274 /* Count any pack expansion args. */
8275 variadic_args_p
= pack_expansion_args_count (inner_args
);
8277 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
8278 if ((nargs
- variadic_args_p
> nparms
&& !variadic_p
)
8279 || (nargs
< nparms
- variadic_p
8282 && (!use_default_args
8283 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
8284 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
8287 if (complain
& tf_error
)
8289 if (variadic_p
|| default_p
)
8291 nparms
-= variadic_p
+ default_p
;
8292 error ("wrong number of template arguments "
8293 "(%d, should be at least %d)", nargs
, nparms
);
8296 error ("wrong number of template arguments "
8297 "(%d, should be %d)", nargs
, nparms
);
8300 inform (DECL_SOURCE_LOCATION (in_decl
),
8301 "provided for %qD", in_decl
);
8304 return error_mark_node
;
8306 /* We can't pass a pack expansion to a non-pack parameter of an alias
8307 template (DR 1430). */
8309 && (DECL_ALIAS_TEMPLATE_P (in_decl
)
8310 || concept_template_p (in_decl
))
8312 && nargs
- variadic_args_p
< nparms
- variadic_p
)
8314 if (complain
& tf_error
)
8316 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
8318 tree arg
= TREE_VEC_ELT (inner_args
, i
);
8319 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
8321 if (PACK_EXPANSION_P (arg
)
8322 && !template_parameter_pack_p (parm
))
8324 if (DECL_ALIAS_TEMPLATE_P (in_decl
))
8325 error_at (location_of (arg
),
8326 "pack expansion argument for non-pack parameter "
8327 "%qD of alias template %qD", parm
, in_decl
);
8329 error_at (location_of (arg
),
8330 "pack expansion argument for non-pack parameter "
8331 "%qD of concept %qD", parm
, in_decl
);
8332 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
8339 return error_mark_node
;
8342 /* We need to evaluate the template arguments, even though this
8343 template-id may be nested within a "sizeof". */
8344 saved_unevaluated_operand
= cp_unevaluated_operand
;
8345 cp_unevaluated_operand
= 0;
8346 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
8347 c_inhibit_evaluation_warnings
= 0;
8348 new_inner_args
= make_tree_vec (nparms
);
8349 new_args
= add_outermost_template_args (args
, new_inner_args
);
8350 int pack_adjust
= 0;
8351 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
8356 /* Get the Ith template parameter. */
8357 parm
= TREE_VEC_ELT (parms
, parm_idx
);
8359 if (parm
== error_mark_node
)
8361 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
8365 /* Calculate the next argument. */
8366 if (arg_idx
< nargs
)
8367 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
8371 if (template_parameter_pack_p (TREE_VALUE (parm
))
8372 && !(arg
&& ARGUMENT_PACK_P (arg
)))
8374 /* Some arguments will be placed in the
8375 template parameter pack PARM. */
8376 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
8377 inner_args
, arg_idx
,
8381 if (arg
== NULL_TREE
)
8383 /* We don't know how many args we have yet, just use the
8384 unconverted (and still packed) ones for now. */
8385 new_inner_args
= orig_inner_args
;
8390 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
8392 /* Store this argument. */
8393 if (arg
== error_mark_node
)
8396 /* We are done with all of the arguments. */
8402 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
8403 arg_idx
+= pack_adjust
;
8404 if (fixed_parameter_pack_p (TREE_VALUE (parm
)))
8407 fixed_pack_adjust
+= pack_adjust
;
8415 if (PACK_EXPANSION_P (arg
))
8417 /* "If every valid specialization of a variadic template
8418 requires an empty template parameter pack, the template is
8419 ill-formed, no diagnostic required." So check that the
8420 pattern works with this parameter. */
8421 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
8422 tree conv
= convert_template_argument (TREE_VALUE (parm
),
8426 if (conv
== error_mark_node
)
8428 if (complain
& tf_error
)
8429 inform (input_location
, "so any instantiation with a "
8430 "non-empty parameter pack would be ill-formed");
8433 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
8434 /* Recover from missing typename. */
8435 TREE_VEC_ELT (inner_args
, arg_idx
)
8436 = make_pack_expansion (conv
, complain
);
8438 /* We don't know how many args we have yet, just
8439 use the unconverted ones for now. */
8440 new_inner_args
= inner_args
;
8445 else if (require_all_args
)
8447 /* There must be a default arg in this case. */
8448 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
8450 /* The position of the first default template argument,
8451 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
8453 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8454 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8455 arg_idx
- pack_adjust
);
8460 if (arg
== error_mark_node
)
8462 if (complain
& tf_error
)
8463 error ("template argument %d is invalid", arg_idx
+ 1);
8467 /* This can occur if there was an error in the template
8468 parameter list itself (which we would already have
8469 reported) that we are trying to recover from, e.g., a class
8470 template with a parameter list such as
8471 template<typename..., typename> (cpp0x/variadic150.C). */
8474 /* This can also happen with a fixed parameter pack (71834). */
8475 if (arg_idx
>= nargs
)
8479 arg
= convert_template_argument (TREE_VALUE (parm
),
8480 arg
, new_args
, complain
,
8483 if (arg
== error_mark_node
)
8485 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
8487 cp_unevaluated_operand
= saved_unevaluated_operand
;
8488 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
8490 if (missing
|| arg_idx
< nargs
- variadic_args_p
)
8492 /* If we had fixed parameter packs, we didn't know how many arguments we
8493 actually needed earlier; now we do. */
8494 nparms
+= fixed_pack_adjust
;
8495 variadic_p
-= fixed_packs
;
8499 if (arg_idx
< nargs
)
8501 /* We had some pack expansion arguments that will only work if the packs
8502 are empty, but wait until instantiation time to complain.
8503 See variadic-ttp3.C. */
8504 int len
= nparms
+ (nargs
- arg_idx
);
8505 tree args
= make_tree_vec (len
);
8507 for (; i
< nparms
; ++i
)
8508 TREE_VEC_ELT (args
, i
) = TREE_VEC_ELT (new_inner_args
, i
);
8509 for (; i
< len
; ++i
, ++arg_idx
)
8510 TREE_VEC_ELT (args
, i
) = TREE_VEC_ELT (inner_args
,
8511 arg_idx
- pack_adjust
);
8512 new_inner_args
= args
;
8517 gcc_assert (!(complain
& tf_error
) || seen_error ());
8518 return error_mark_node
;
8521 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8522 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8523 TREE_VEC_LENGTH (new_inner_args
));
8525 return new_inner_args
;
8528 /* Convert all template arguments to their appropriate types, and
8529 return a vector containing the innermost resulting template
8530 arguments. If any error occurs, return error_mark_node. Error and
8531 warning messages are not issued.
8533 Note that no function argument deduction is performed, and default
8534 arguments are used to fill in unspecified arguments. */
8536 coerce_template_parms (tree parms
, tree args
, tree in_decl
)
8538 return coerce_template_parms (parms
, args
, in_decl
, tf_none
, true, true);
8541 /* Convert all template arguments to their appropriate type, and
8542 instantiate default arguments as needed. This returns a vector
8543 containing the innermost resulting template arguments, or
8544 error_mark_node if unsuccessful. */
8546 coerce_template_parms (tree parms
, tree args
, tree in_decl
,
8547 tsubst_flags_t complain
)
8549 return coerce_template_parms (parms
, args
, in_decl
, complain
, true, true);
8552 /* Like coerce_template_parms. If PARMS represents all template
8553 parameters levels, this function returns a vector of vectors
8554 representing all the resulting argument levels. Note that in this
8555 case, only the innermost arguments are coerced because the
8556 outermost ones are supposed to have been coerced already.
8558 Otherwise, if PARMS represents only (the innermost) vector of
8559 parameters, this function returns a vector containing just the
8560 innermost resulting arguments. */
8563 coerce_innermost_template_parms (tree parms
,
8566 tsubst_flags_t complain
,
8567 bool require_all_args
,
8568 bool use_default_args
)
8570 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
8571 int args_depth
= TMPL_ARGS_DEPTH (args
);
8574 if (parms_depth
> 1)
8576 coerced_args
= make_tree_vec (parms_depth
);
8580 for (level
= parms
, cur_depth
= parms_depth
;
8581 parms_depth
> 0 && level
!= NULL_TREE
;
8582 level
= TREE_CHAIN (level
), --cur_depth
)
8585 if (cur_depth
== args_depth
)
8586 l
= coerce_template_parms (TREE_VALUE (level
),
8587 args
, in_decl
, complain
,
8591 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
8593 if (l
== error_mark_node
)
8594 return error_mark_node
;
8596 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
8600 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
8601 args
, in_decl
, complain
,
8604 return coerced_args
;
8607 /* Returns 1 if template args OT and NT are equivalent. */
8610 template_args_equal (tree ot
, tree nt
, bool partial_order
/* = false */)
8614 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
8616 if (nt
== any_targ_node
|| ot
== any_targ_node
)
8619 if (TREE_CODE (nt
) == TREE_VEC
)
8620 /* For member templates */
8621 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
8622 else if (PACK_EXPANSION_P (ot
))
8623 return (PACK_EXPANSION_P (nt
)
8624 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
8625 PACK_EXPANSION_PATTERN (nt
))
8626 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
8627 PACK_EXPANSION_EXTRA_ARGS (nt
)));
8628 else if (ARGUMENT_PACK_P (ot
))
8633 if (!ARGUMENT_PACK_P (nt
))
8636 opack
= ARGUMENT_PACK_ARGS (ot
);
8637 npack
= ARGUMENT_PACK_ARGS (nt
);
8638 len
= TREE_VEC_LENGTH (opack
);
8639 if (TREE_VEC_LENGTH (npack
) != len
)
8641 for (i
= 0; i
< len
; ++i
)
8642 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
8643 TREE_VEC_ELT (npack
, i
)))
8647 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
8649 else if (TYPE_P (nt
))
8653 /* Don't treat an alias template specialization with dependent
8654 arguments as equivalent to its underlying type when used as a
8655 template argument; we need them to be distinct so that we
8656 substitute into the specialization arguments at instantiation
8657 time. And aliases can't be equivalent without being ==, so
8658 we don't need to look any deeper.
8660 During partial ordering, however, we need to treat them normally so
8661 that we can order uses of the same alias with different
8662 cv-qualification (79960). */
8664 && (TYPE_ALIAS_P (nt
) || TYPE_ALIAS_P (ot
)))
8667 return same_type_p (ot
, nt
);
8669 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
8673 /* Try to treat a template non-type argument that has been converted
8674 to the parameter type as equivalent to one that hasn't yet. */
8675 for (enum tree_code code1
= TREE_CODE (ot
);
8676 CONVERT_EXPR_CODE_P (code1
)
8677 || code1
== NON_LVALUE_EXPR
;
8678 code1
= TREE_CODE (ot
))
8679 ot
= TREE_OPERAND (ot
, 0);
8680 for (enum tree_code code2
= TREE_CODE (nt
);
8681 CONVERT_EXPR_CODE_P (code2
)
8682 || code2
== NON_LVALUE_EXPR
;
8683 code2
= TREE_CODE (nt
))
8684 nt
= TREE_OPERAND (nt
, 0);
8686 return cp_tree_equal (ot
, nt
);
8690 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
8691 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
8692 NEWARG_PTR with the offending arguments if they are non-NULL. */
8695 comp_template_args (tree oldargs
, tree newargs
,
8696 tree
*oldarg_ptr
, tree
*newarg_ptr
,
8701 if (oldargs
== newargs
)
8704 if (!oldargs
|| !newargs
)
8707 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
8710 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
8712 tree nt
= TREE_VEC_ELT (newargs
, i
);
8713 tree ot
= TREE_VEC_ELT (oldargs
, i
);
8715 if (! template_args_equal (ot
, nt
, partial_order
))
8717 if (oldarg_ptr
!= NULL
)
8719 if (newarg_ptr
!= NULL
)
8728 comp_template_args_porder (tree oargs
, tree nargs
)
8730 return comp_template_args (oargs
, nargs
, NULL
, NULL
, true);
8733 /* Implement a freelist interface for objects of type T.
8735 Head is a separate object, rather than a regular member, so that we
8736 can define it as a GTY deletable pointer, which is highly
8737 desirable. A data member could be declared that way, but then the
8738 containing object would implicitly get GTY((user)), which would
8739 prevent us from instantiating freelists as global objects.
8740 Although this way we can create freelist global objects, they're
8741 such thin wrappers that instantiating temporaries at every use
8742 loses nothing and saves permanent storage for the freelist object.
8744 Member functions next, anew, poison and reinit have default
8745 implementations that work for most of the types we're interested
8746 in, but if they don't work for some type, they should be explicitly
8747 specialized. See the comments before them for requirements, and
8748 the example specializations for the tree_list_freelist. */
8749 template <typename T
>
8752 /* Return the next object in a chain. We could just do type
8753 punning, but if we access the object with its underlying type, we
8754 avoid strict-aliasing trouble. This needs only work between
8755 poison and reinit. */
8756 static T
*&next (T
*obj
) { return obj
->next
; }
8758 /* Return a newly allocated, uninitialized or minimally-initialized
8759 object of type T. Any initialization performed by anew should
8760 either remain across the life of the object and the execution of
8761 poison, or be redone by reinit. */
8762 static T
*anew () { return ggc_alloc
<T
> (); }
8764 /* Optionally scribble all over the bits holding the object, so that
8765 they become (mostly?) uninitialized memory. This is called while
8766 preparing to make the object part of the free list. */
8767 static void poison (T
*obj
) {
8768 T
*p ATTRIBUTE_UNUSED
= obj
;
8769 T
**q ATTRIBUTE_UNUSED
= &next (obj
);
8771 #ifdef ENABLE_GC_CHECKING
8772 /* Poison the data, to indicate the data is garbage. */
8773 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (p
, sizeof (*p
)));
8774 memset (p
, 0xa5, sizeof (*p
));
8776 /* Let valgrind know the object is free. */
8777 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (p
, sizeof (*p
)));
8779 /* Let valgrind know the next portion of the object is available,
8780 but uninitialized. */
8781 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (q
, sizeof (*q
)));
8784 /* Bring an object that underwent at least one lifecycle after anew
8785 and before the most recent free and poison, back to a usable
8786 state, reinitializing whatever is needed for it to be
8787 functionally equivalent to an object just allocated and returned
8788 by anew. This may poison or clear the next field, used by
8789 freelist housekeeping after poison was called. */
8790 static void reinit (T
*obj
) {
8791 T
**q ATTRIBUTE_UNUSED
= &next (obj
);
8793 #ifdef ENABLE_GC_CHECKING
8794 memset (q
, 0xa5, sizeof (*q
));
8796 /* Let valgrind know the entire object is available, but
8798 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (*obj
)));
8801 /* Reference a GTY-deletable pointer that points to the first object
8802 in the free list proper. */
8805 /* Construct a freelist object chaining objects off of HEAD. */
8806 freelist (T
*&head
) : head(head
) {}
8808 /* Add OBJ to the free object list. The former head becomes OBJ's
8817 /* Take an object from the free list, if one is available, or
8818 allocate a new one. Objects taken from the free list should be
8819 regarded as filled with garbage, except for bits that are
8820 configured to be preserved across free and alloc. */
8835 /* Explicitly specialize the interfaces for freelist<tree_node>: we
8836 want to allocate a TREE_LIST using the usual interface, and ensure
8837 TREE_CHAIN remains functional. Alas, we have to duplicate a bit of
8838 build_tree_list logic in reinit, so this could go out of sync. */
8841 freelist
<tree_node
>::next (tree obj
)
8843 return TREE_CHAIN (obj
);
8847 freelist
<tree_node
>::anew ()
8849 return build_tree_list (NULL
, NULL
);
8853 freelist
<tree_node
>::poison (tree obj ATTRIBUTE_UNUSED
)
8855 int size ATTRIBUTE_UNUSED
= sizeof (tree_list
);
8856 tree p ATTRIBUTE_UNUSED
= obj
;
8857 tree_base
*b ATTRIBUTE_UNUSED
= &obj
->base
;
8858 tree
*q ATTRIBUTE_UNUSED
= &next (obj
);
8860 #ifdef ENABLE_GC_CHECKING
8861 gcc_checking_assert (TREE_CODE (obj
) == TREE_LIST
);
8863 /* Poison the data, to indicate the data is garbage. */
8864 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (p
, size
));
8865 memset (p
, 0xa5, size
);
8867 /* Let valgrind know the object is free. */
8868 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (p
, size
));
8869 /* But we still want to use the TREE_CODE and TREE_CHAIN parts. */
8870 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
8871 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (q
, sizeof (*q
)));
8873 #ifdef ENABLE_GC_CHECKING
8874 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (b
, sizeof (*b
)));
8875 /* Keep TREE_CHAIN functional. */
8876 TREE_SET_CODE (obj
, TREE_LIST
);
8878 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
8883 freelist
<tree_node
>::reinit (tree obj ATTRIBUTE_UNUSED
)
8885 tree_base
*b ATTRIBUTE_UNUSED
= &obj
->base
;
8887 #ifdef ENABLE_GC_CHECKING
8888 gcc_checking_assert (TREE_CODE (obj
) == TREE_LIST
);
8889 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (tree_list
)));
8890 memset (obj
, 0, sizeof (tree_list
));
8893 /* Let valgrind know the entire object is available, but
8895 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj
, sizeof (tree_list
)));
8897 #ifdef ENABLE_GC_CHECKING
8898 TREE_SET_CODE (obj
, TREE_LIST
);
8900 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b
, sizeof (*b
)));
8904 /* Point to the first object in the TREE_LIST freelist. */
8905 static GTY((deletable
)) tree tree_list_freelist_head
;
8906 /* Return the/an actual TREE_LIST freelist. */
8907 static inline freelist
<tree_node
>
8908 tree_list_freelist ()
8910 return tree_list_freelist_head
;
8913 /* Point to the first object in the tinst_level freelist. */
8914 static GTY((deletable
)) tinst_level
*tinst_level_freelist_head
;
8915 /* Return the/an actual tinst_level freelist. */
8916 static inline freelist
<tinst_level
>
8917 tinst_level_freelist ()
8919 return tinst_level_freelist_head
;
8922 /* Point to the first object in the pending_template freelist. */
8923 static GTY((deletable
)) pending_template
*pending_template_freelist_head
;
8924 /* Return the/an actual pending_template freelist. */
8925 static inline freelist
<pending_template
>
8926 pending_template_freelist ()
8928 return pending_template_freelist_head
;
8931 /* Build the TREE_LIST object out of a split list, store it
8932 permanently, and return it. */
8934 tinst_level::to_list ()
8936 gcc_assert (split_list_p ());
8937 tree ret
= tree_list_freelist ().alloc ();
8938 TREE_PURPOSE (ret
) = tldcl
;
8939 TREE_VALUE (ret
) = targs
;
8942 gcc_assert (tree_list_p ());
8946 const unsigned short tinst_level::refcount_infinity
;
8948 /* Increment OBJ's refcount unless it is already infinite. */
8949 static tinst_level
*
8950 inc_refcount_use (tinst_level
*obj
)
8952 if (obj
&& obj
->refcount
!= tinst_level::refcount_infinity
)
8957 /* Release storage for OBJ and node, if it's a TREE_LIST. */
8959 tinst_level::free (tinst_level
*obj
)
8961 if (obj
->tree_list_p ())
8962 tree_list_freelist ().free (obj
->get_node ());
8963 tinst_level_freelist ().free (obj
);
8966 /* Decrement OBJ's refcount if not infinite. If it reaches zero, release
8967 OBJ's DECL and OBJ, and start over with the tinst_level object that
8968 used to be referenced by OBJ's NEXT. */
8970 dec_refcount_use (tinst_level
*obj
)
8973 && obj
->refcount
!= tinst_level::refcount_infinity
8974 && !--obj
->refcount
)
8976 tinst_level
*next
= obj
->next
;
8977 tinst_level::free (obj
);
8982 /* Modify PTR so that it points to OBJ, adjusting the refcounts of OBJ
8983 and of the former PTR. Omitting the second argument is equivalent
8984 to passing (T*)NULL; this is allowed because passing the
8985 zero-valued integral constant NULL confuses type deduction and/or
8986 overload resolution. */
8987 template <typename T
>
8989 set_refcount_ptr (T
*& ptr
, T
*obj
= NULL
)
8992 ptr
= inc_refcount_use (obj
);
8993 dec_refcount_use (save
);
8997 add_pending_template (tree d
)
8999 tree ti
= (TYPE_P (d
)
9000 ? CLASSTYPE_TEMPLATE_INFO (d
)
9001 : DECL_TEMPLATE_INFO (d
));
9002 struct pending_template
*pt
;
9005 if (TI_PENDING_TEMPLATE_FLAG (ti
))
9008 /* We are called both from instantiate_decl, where we've already had a
9009 tinst_level pushed, and instantiate_template, where we haven't.
9011 gcc_assert (TREE_CODE (d
) != TREE_LIST
);
9012 level
= !current_tinst_level
9013 || current_tinst_level
->maybe_get_node () != d
;
9016 push_tinst_level (d
);
9018 pt
= pending_template_freelist ().alloc ();
9021 set_refcount_ptr (pt
->tinst
, current_tinst_level
);
9022 if (last_pending_template
)
9023 last_pending_template
->next
= pt
;
9025 pending_templates
= pt
;
9027 last_pending_template
= pt
;
9029 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
9036 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
9037 ARGLIST. Valid choices for FNS are given in the cp-tree.def
9038 documentation for TEMPLATE_ID_EXPR. */
9041 lookup_template_function (tree fns
, tree arglist
)
9045 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
9046 return error_mark_node
;
9048 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
9050 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
9052 error ("%q#D is not a function template", fns
);
9053 return error_mark_node
;
9056 if (BASELINK_P (fns
))
9058 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
9060 BASELINK_FUNCTIONS (fns
),
9065 type
= TREE_TYPE (fns
);
9066 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
9067 type
= unknown_type_node
;
9069 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
9072 /* Within the scope of a template class S<T>, the name S gets bound
9073 (in build_self_reference) to a TYPE_DECL for the class, not a
9074 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
9075 or one of its enclosing classes, and that type is a template,
9076 return the associated TEMPLATE_DECL. Otherwise, the original
9079 Also handle the case when DECL is a TREE_LIST of ambiguous
9080 injected-class-names from different bases. */
9083 maybe_get_template_decl_from_type_decl (tree decl
)
9085 if (decl
== NULL_TREE
)
9088 /* DR 176: A lookup that finds an injected-class-name (10.2
9089 [class.member.lookup]) can result in an ambiguity in certain cases
9090 (for example, if it is found in more than one base class). If all of
9091 the injected-class-names that are found refer to specializations of
9092 the same class template, and if the name is followed by a
9093 template-argument-list, the reference refers to the class template
9094 itself and not a specialization thereof, and is not ambiguous. */
9095 if (TREE_CODE (decl
) == TREE_LIST
)
9097 tree t
, tmpl
= NULL_TREE
;
9098 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
9100 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
9103 else if (tmpl
!= elt
)
9106 if (tmpl
&& t
== NULL_TREE
)
9112 return (decl
!= NULL_TREE
9113 && DECL_SELF_REFERENCE_P (decl
)
9114 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
9115 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
9118 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
9119 parameters, find the desired type.
9121 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
9123 IN_DECL, if non-NULL, is the template declaration we are trying to
9126 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
9127 the class we are looking up.
9129 Issue error and warning messages under control of COMPLAIN.
9131 If the template class is really a local class in a template
9132 function, then the FUNCTION_CONTEXT is the function in which it is
9135 ??? Note that this function is currently called *twice* for each
9136 template-id: the first time from the parser, while creating the
9137 incomplete type (finish_template_type), and the second type during the
9138 real instantiation (instantiate_template_class). This is surely something
9139 that we want to avoid. It also causes some problems with argument
9140 coercion (see convert_nontype_argument for more information on this). */
9143 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
9144 int entering_scope
, tsubst_flags_t complain
)
9146 tree templ
= NULL_TREE
, parmlist
;
9153 if (identifier_p (d1
))
9155 tree value
= innermost_non_namespace_value (d1
);
9156 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
9161 push_decl_namespace (context
);
9162 templ
= lookup_name (d1
);
9163 templ
= maybe_get_template_decl_from_type_decl (templ
);
9165 pop_decl_namespace ();
9168 context
= DECL_CONTEXT (templ
);
9170 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
9172 tree type
= TREE_TYPE (d1
);
9174 /* If we are declaring a constructor, say A<T>::A<T>, we will get
9175 an implicit typename for the second A. Deal with it. */
9176 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
9177 type
= TREE_TYPE (type
);
9179 if (CLASSTYPE_TEMPLATE_INFO (type
))
9181 templ
= CLASSTYPE_TI_TEMPLATE (type
);
9182 d1
= DECL_NAME (templ
);
9185 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
9186 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
9188 templ
= TYPE_TI_TEMPLATE (d1
);
9189 d1
= DECL_NAME (templ
);
9191 else if (DECL_TYPE_TEMPLATE_P (d1
))
9194 d1
= DECL_NAME (templ
);
9195 context
= DECL_CONTEXT (templ
);
9197 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
9200 d1
= DECL_NAME (templ
);
9203 /* Issue an error message if we didn't find a template. */
9206 if (complain
& tf_error
)
9207 error ("%qT is not a template", d1
);
9208 return error_mark_node
;
9211 if (TREE_CODE (templ
) != TEMPLATE_DECL
9212 /* Make sure it's a user visible template, if it was named by
9214 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
9215 && !PRIMARY_TEMPLATE_P (templ
)))
9217 if (complain
& tf_error
)
9219 error ("non-template type %qT used as a template", d1
);
9221 error ("for template declaration %q+D", in_decl
);
9223 return error_mark_node
;
9226 complain
&= ~tf_user
;
9228 /* An alias that just changes the name of a template is equivalent to the
9229 other template, so if any of the arguments are pack expansions, strip
9230 the alias to avoid problems with a pack expansion passed to a non-pack
9231 alias template parameter (DR 1430). */
9232 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
9233 templ
= get_underlying_template (templ
);
9235 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
9238 tree arglist2
= coerce_template_args_for_ttp (templ
, arglist
, complain
);
9239 if (arglist2
== error_mark_node
9240 || (!uses_template_parms (arglist2
)
9241 && check_instantiated_args (templ
, arglist2
, complain
)))
9242 return error_mark_node
;
9244 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
9249 tree template_type
= TREE_TYPE (templ
);
9252 tree found
= NULL_TREE
;
9255 int is_dependent_type
;
9256 int use_partial_inst_tmpl
= false;
9258 if (template_type
== error_mark_node
)
9259 /* An error occurred while building the template TEMPL, and a
9260 diagnostic has most certainly been emitted for that
9261 already. Let's propagate that error. */
9262 return error_mark_node
;
9264 gen_tmpl
= most_general_template (templ
);
9265 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
9266 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
9267 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
9269 if (arg_depth
== 1 && parm_depth
> 1)
9271 /* We've been given an incomplete set of template arguments.
9274 template <class T> struct S1 {
9275 template <class U> struct S2 {};
9276 template <class U> struct S2<U*> {};
9279 we will be called with an ARGLIST of `U*', but the
9280 TEMPLATE will be `template <class T> template
9281 <class U> struct S1<T>::S2'. We must fill in the missing
9283 tree ti
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (templ
));
9284 arglist
= add_outermost_template_args (TI_ARGS (ti
), arglist
);
9285 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
9288 /* Now we should have enough arguments. */
9289 gcc_assert (parm_depth
== arg_depth
);
9291 /* From here on, we're only interested in the most general
9294 /* Calculate the BOUND_ARGS. These will be the args that are
9295 actually tsubst'd into the definition to create the
9297 arglist
= coerce_innermost_template_parms (parmlist
, arglist
, gen_tmpl
,
9299 /*require_all_args=*/true,
9300 /*use_default_args=*/true);
9302 if (arglist
== error_mark_node
)
9303 /* We were unable to bind the arguments. */
9304 return error_mark_node
;
9306 /* In the scope of a template class, explicit references to the
9307 template class refer to the type of the template, not any
9308 instantiation of it. For example, in:
9310 template <class T> class C { void f(C<T>); }
9312 the `C<T>' is just the same as `C'. Outside of the
9313 class, however, such a reference is an instantiation. */
9315 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
9316 || currently_open_class (template_type
))
9318 tree tinfo
= TYPE_TEMPLATE_INFO (template_type
);
9320 if (tinfo
&& comp_template_args (TI_ARGS (tinfo
), arglist
))
9321 return template_type
;
9324 /* If we already have this specialization, return it. */
9325 elt
.tmpl
= gen_tmpl
;
9327 elt
.spec
= NULL_TREE
;
9328 hash
= spec_hasher::hash (&elt
);
9329 entry
= type_specializations
->find_with_hash (&elt
, hash
);
9334 /* If the the template's constraints are not satisfied,
9335 then we cannot form a valid type.
9337 Note that the check is deferred until after the hash
9338 lookup. This prevents redundant checks on previously
9339 instantiated specializations. */
9340 if (flag_concepts
&& !constraints_satisfied_p (gen_tmpl
, arglist
))
9342 if (complain
& tf_error
)
9344 error ("template constraint failure");
9345 diagnose_constraints (input_location
, gen_tmpl
, arglist
);
9347 return error_mark_node
;
9350 is_dependent_type
= uses_template_parms (arglist
);
9352 /* If the deduced arguments are invalid, then the binding
9354 if (!is_dependent_type
9355 && check_instantiated_args (gen_tmpl
,
9356 INNERMOST_TEMPLATE_ARGS (arglist
),
9358 return error_mark_node
;
9360 if (!is_dependent_type
9361 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
9362 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
9363 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
9365 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
9366 DECL_NAME (gen_tmpl
),
9367 /*tag_scope=*/ts_global
);
9371 context
= DECL_CONTEXT (gen_tmpl
);
9372 if (context
&& TYPE_P (context
))
9374 context
= tsubst_aggr_type (context
, arglist
, complain
, in_decl
, true);
9375 context
= complete_type (context
);
9378 context
= tsubst (context
, arglist
, complain
, in_decl
);
9380 if (context
== error_mark_node
)
9381 return error_mark_node
;
9384 context
= global_namespace
;
9386 /* Create the type. */
9387 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9389 /* The user referred to a specialization of an alias
9390 template represented by GEN_TMPL.
9392 [temp.alias]/2 says:
9394 When a template-id refers to the specialization of an
9395 alias template, it is equivalent to the associated
9396 type obtained by substitution of its
9397 template-arguments for the template-parameters in the
9398 type-id of the alias template. */
9400 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
9401 /* Note that the call above (by indirectly calling
9402 register_specialization in tsubst_decl) registers the
9403 TYPE_DECL representing the specialization of the alias
9404 template. So next time someone substitutes ARGLIST for
9405 the template parms into the alias template (GEN_TMPL),
9406 she'll get that TYPE_DECL back. */
9408 if (t
== error_mark_node
)
9411 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
9413 if (!is_dependent_type
)
9415 set_current_access_from_decl (TYPE_NAME (template_type
));
9416 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
9417 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
9418 arglist
, complain
, in_decl
),
9419 tsubst_attributes (TYPE_ATTRIBUTES (template_type
),
9420 arglist
, complain
, in_decl
),
9421 SCOPED_ENUM_P (template_type
), NULL
);
9423 if (t
== error_mark_node
)
9428 /* We don't want to call start_enum for this type, since
9429 the values for the enumeration constants may involve
9430 template parameters. And, no one should be interested
9431 in the enumeration constants for such a type. */
9432 t
= cxx_make_type (ENUMERAL_TYPE
);
9433 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
9435 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
9436 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
9437 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
9439 else if (CLASS_TYPE_P (template_type
))
9441 /* Lambda closures are regenerated in tsubst_lambda_expr, not
9442 instantiated here. */
9443 gcc_assert (!LAMBDA_TYPE_P (template_type
));
9445 t
= make_class_type (TREE_CODE (template_type
));
9446 CLASSTYPE_DECLARED_CLASS (t
)
9447 = CLASSTYPE_DECLARED_CLASS (template_type
);
9448 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
9450 /* A local class. Make sure the decl gets registered properly. */
9451 if (context
== current_function_decl
)
9452 if (pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
)
9454 return error_mark_node
;
9456 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
9457 /* This instantiation is another name for the primary
9458 template type. Set the TYPE_CANONICAL field
9460 TYPE_CANONICAL (t
) = template_type
;
9461 else if (any_template_arguments_need_structural_equality_p (arglist
))
9462 /* Some of the template arguments require structural
9463 equality testing, so this template class requires
9464 structural equality testing. */
9465 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9470 /* If we called start_enum or pushtag above, this information
9471 will already be set up. */
9474 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
9476 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
9477 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
9478 DECL_SOURCE_LOCATION (type_decl
)
9479 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
9482 type_decl
= TYPE_NAME (t
);
9484 if (CLASS_TYPE_P (template_type
))
9486 TREE_PRIVATE (type_decl
)
9487 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
9488 TREE_PROTECTED (type_decl
)
9489 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
9490 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
9492 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
9493 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
9497 if (OVERLOAD_TYPE_P (t
)
9498 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9500 static const char *tags
[] = {"abi_tag", "may_alias"};
9502 for (unsigned ix
= 0; ix
!= 2; ix
++)
9505 = lookup_attribute (tags
[ix
], TYPE_ATTRIBUTES (template_type
));
9509 = tree_cons (TREE_PURPOSE (attributes
),
9510 TREE_VALUE (attributes
),
9511 TYPE_ATTRIBUTES (t
));
9515 /* Let's consider the explicit specialization of a member
9516 of a class template specialization that is implicitly instantiated,
9521 template<class U> struct M {}; //#0
9526 struct S<int>::M<char> //#1
9530 [temp.expl.spec]/4 says this is valid.
9532 In this case, when we write:
9535 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
9538 When we encounter #1, we want to store the partial instantiation
9539 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
9541 For all cases other than this "explicit specialization of member of a
9542 class template", we just want to store the most general template into
9543 the CLASSTYPE_TI_TEMPLATE of M.
9545 This case of "explicit specialization of member of a class template"
9547 1/ the enclosing class is an instantiation of, and therefore not
9548 the same as, the context of the most general template, and
9549 2/ we aren't looking at the partial instantiation itself, i.e.
9550 the innermost arguments are not the same as the innermost parms of
9551 the most general template.
9553 So it's only when 1/ and 2/ happens that we want to use the partial
9554 instantiation of the member template in lieu of its most general
9557 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
9558 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
9559 /* the enclosing class must be an instantiation... */
9560 && CLASS_TYPE_P (context
)
9561 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
9563 TREE_VEC_LENGTH (arglist
)--;
9564 ++processing_template_decl
;
9565 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (gen_tmpl
));
9566 tree partial_inst_args
=
9567 tsubst (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
)),
9568 arglist
, complain
, NULL_TREE
);
9569 --processing_template_decl
;
9570 TREE_VEC_LENGTH (arglist
)++;
9571 if (partial_inst_args
== error_mark_node
)
9572 return error_mark_node
;
9573 use_partial_inst_tmpl
=
9574 /*...and we must not be looking at the partial instantiation
9576 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
9580 if (!use_partial_inst_tmpl
)
9581 /* This case is easy; there are no member templates involved. */
9585 /* This is a full instantiation of a member template. Find
9586 the partial instantiation of which this is an instance. */
9588 /* Temporarily reduce by one the number of levels in the ARGLIST
9589 so as to avoid comparing the last set of arguments. */
9590 TREE_VEC_LENGTH (arglist
)--;
9591 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
9592 TREE_VEC_LENGTH (arglist
)++;
9593 /* FOUND is either a proper class type, or an alias
9594 template specialization. In the later case, it's a
9595 TYPE_DECL, resulting from the substituting of arguments
9596 for parameters in the TYPE_DECL of the alias template
9597 done earlier. So be careful while getting the template
9599 found
= (TREE_CODE (found
) == TEMPLATE_DECL
9601 : (TREE_CODE (found
) == TYPE_DECL
9602 ? DECL_TI_TEMPLATE (found
)
9603 : CLASSTYPE_TI_TEMPLATE (found
)));
9606 // Build template info for the new specialization.
9607 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
9610 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
9611 entry
= ggc_alloc
<spec_entry
> ();
9615 /* Note this use of the partial instantiation so we can check it
9616 later in maybe_process_partial_specialization. */
9617 DECL_TEMPLATE_INSTANTIATIONS (found
)
9618 = tree_cons (arglist
, t
,
9619 DECL_TEMPLATE_INSTANTIATIONS (found
));
9621 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
9622 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9623 /* Now that the type has been registered on the instantiations
9624 list, we set up the enumerators. Because the enumeration
9625 constants may involve the enumeration type itself, we make
9626 sure to register the type first, and then create the
9627 constants. That way, doing tsubst_expr for the enumeration
9628 constants won't result in recursive calls here; we'll find
9629 the instantiation and exit above. */
9630 tsubst_enum (template_type
, t
, arglist
);
9632 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
9633 /* If the type makes use of template parameters, the
9634 code that generates debugging information will crash. */
9635 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
9637 /* Possibly limit visibility based on template args. */
9638 TREE_PUBLIC (type_decl
) = 1;
9639 determine_visibility (type_decl
);
9641 inherit_targ_abi_tags (t
);
9647 /* Wrapper for lookup_template_class_1. */
9650 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
9651 int entering_scope
, tsubst_flags_t complain
)
9654 timevar_push (TV_TEMPLATE_INST
);
9655 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
9656 entering_scope
, complain
);
9657 timevar_pop (TV_TEMPLATE_INST
);
9661 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
9664 lookup_template_variable (tree templ
, tree arglist
)
9666 /* The type of the expression is NULL_TREE since the template-id could refer
9667 to an explicit or partial specialization. */
9668 tree type
= NULL_TREE
;
9669 if (flag_concepts
&& variable_concept_p (templ
))
9670 /* Except that concepts are always bool. */
9671 type
= boolean_type_node
;
9672 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
9675 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
9678 finish_template_variable (tree var
, tsubst_flags_t complain
)
9680 tree templ
= TREE_OPERAND (var
, 0);
9681 tree arglist
= TREE_OPERAND (var
, 1);
9683 /* We never want to return a VAR_DECL for a variable concept, since they
9684 aren't instantiated. In a template, leave the TEMPLATE_ID_EXPR alone. */
9685 bool concept_p
= flag_concepts
&& variable_concept_p (templ
);
9686 if (concept_p
&& processing_template_decl
)
9689 tree tmpl_args
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ
));
9690 arglist
= add_outermost_template_args (tmpl_args
, arglist
);
9692 templ
= most_general_template (templ
);
9693 tree parms
= DECL_TEMPLATE_PARMS (templ
);
9694 arglist
= coerce_innermost_template_parms (parms
, arglist
, templ
, complain
,
9696 /*use_default*/true);
9698 if (flag_concepts
&& !constraints_satisfied_p (templ
, arglist
))
9700 if (complain
& tf_error
)
9702 error ("use of invalid variable template %qE", var
);
9703 diagnose_constraints (location_of (var
), templ
, arglist
);
9705 return error_mark_node
;
9708 /* If a template-id refers to a specialization of a variable
9709 concept, then the expression is true if and only if the
9710 concept's constraints are satisfied by the given template
9713 NOTE: This is an extension of Concepts Lite TS that
9714 allows constraints to be used in expressions. */
9717 tree decl
= DECL_TEMPLATE_RESULT (templ
);
9718 return evaluate_variable_concept (decl
, arglist
);
9721 return instantiate_template (templ
, arglist
, complain
);
9724 /* Construct a TEMPLATE_ID_EXPR for the given variable template TEMPL having
9725 TARGS template args, and instantiate it if it's not dependent. */
9728 lookup_and_finish_template_variable (tree templ
, tree targs
,
9729 tsubst_flags_t complain
)
9731 templ
= lookup_template_variable (templ
, targs
);
9732 if (!any_dependent_template_arguments_p (targs
))
9734 templ
= finish_template_variable (templ
, complain
);
9738 return convert_from_reference (templ
);
9747 /* True when we should also visit template parameters that occur in
9748 non-deduced contexts. */
9749 bool include_nondeduced_p
;
9750 hash_set
<tree
> *visited
;
9753 /* Called from for_each_template_parm via walk_tree. */
9756 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
9759 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
9760 tree_fn_t fn
= pfd
->fn
;
9761 void *data
= pfd
->data
;
9762 tree result
= NULL_TREE
;
9764 #define WALK_SUBTREE(NODE) \
9767 result = for_each_template_parm (NODE, fn, data, pfd->visited, \
9768 pfd->include_nondeduced_p, \
9770 if (result) goto out; \
9774 if (pfd
->any_fn
&& (*pfd
->any_fn
)(t
, data
))
9778 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
))
9779 WALK_SUBTREE (TYPE_CONTEXT (t
));
9781 switch (TREE_CODE (t
))
9784 if (TYPE_PTRMEMFUNC_P (t
))
9790 if (!TYPE_TEMPLATE_INFO (t
))
9793 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9797 WALK_SUBTREE (TYPE_MIN_VALUE (t
));
9798 WALK_SUBTREE (TYPE_MAX_VALUE (t
));
9802 /* Since we're not going to walk subtrees, we have to do this
9804 WALK_SUBTREE (TYPE_METHOD_BASETYPE (t
));
9808 /* Check the return type. */
9809 WALK_SUBTREE (TREE_TYPE (t
));
9811 /* Check the parameter types. Since default arguments are not
9812 instantiated until they are needed, the TYPE_ARG_TYPES may
9813 contain expressions that involve template parameters. But,
9814 no-one should be looking at them yet. And, once they're
9815 instantiated, they don't contain template parameters, so
9816 there's no point in looking at them then, either. */
9820 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
9821 WALK_SUBTREE (TREE_VALUE (parm
));
9823 /* Since we've already handled the TYPE_ARG_TYPES, we don't
9824 want walk_tree walking into them itself. */
9828 if (flag_noexcept_type
)
9830 tree spec
= TYPE_RAISES_EXCEPTIONS (t
);
9832 WALK_SUBTREE (TREE_PURPOSE (spec
));
9838 case UNDERLYING_TYPE
:
9839 if (pfd
->include_nondeduced_p
9840 && for_each_template_parm (TYPE_VALUES_RAW (t
), fn
, data
,
9842 pfd
->include_nondeduced_p
,
9844 return error_mark_node
;
9845 *walk_subtrees
= false;
9850 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
9851 WALK_SUBTREE (DECL_TI_ARGS (t
));
9856 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
))
9857 WALK_SUBTREE (DECL_INITIAL (t
));
9858 if (DECL_CONTEXT (t
)
9859 && pfd
->include_nondeduced_p
)
9860 WALK_SUBTREE (DECL_CONTEXT (t
));
9863 case BOUND_TEMPLATE_TEMPLATE_PARM
:
9864 /* Record template parameters such as `T' inside `TT<T>'. */
9865 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9868 case TEMPLATE_TEMPLATE_PARM
:
9869 case TEMPLATE_TYPE_PARM
:
9870 case TEMPLATE_PARM_INDEX
:
9871 if (fn
&& (*fn
)(t
, data
))
9878 /* A template template parameter is encountered. */
9879 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9880 WALK_SUBTREE (TREE_TYPE (t
));
9882 /* Already substituted template template parameter */
9887 /* A template-id in a TYPENAME_TYPE might be a deduced context after
9888 partial instantiation. */
9889 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t
));
9893 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
9894 && pfd
->include_nondeduced_p
)
9895 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
9900 /* If there's no type, then this thing must be some expression
9901 involving template parameters. */
9902 if (!fn
&& !TREE_TYPE (t
))
9903 return error_mark_node
;
9908 case IMPLICIT_CONV_EXPR
:
9909 case REINTERPRET_CAST_EXPR
:
9910 case CONST_CAST_EXPR
:
9911 case STATIC_CAST_EXPR
:
9912 case DYNAMIC_CAST_EXPR
:
9916 case PSEUDO_DTOR_EXPR
:
9918 return error_mark_node
;
9927 /* We didn't find any template parameters we liked. */
9932 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
9933 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
9934 call FN with the parameter and the DATA.
9935 If FN returns nonzero, the iteration is terminated, and
9936 for_each_template_parm returns 1. Otherwise, the iteration
9937 continues. If FN never returns a nonzero value, the value
9938 returned by for_each_template_parm is 0. If FN is NULL, it is
9939 considered to be the function which always returns 1.
9941 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
9942 parameters that occur in non-deduced contexts. When false, only
9943 visits those template parameters that can be deduced. */
9946 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
9947 hash_set
<tree
> *visited
,
9948 bool include_nondeduced_p
,
9951 struct pair_fn_data pfd
;
9956 pfd
.any_fn
= any_fn
;
9958 pfd
.include_nondeduced_p
= include_nondeduced_p
;
9960 /* Walk the tree. (Conceptually, we would like to walk without
9961 duplicates, but for_each_template_parm_r recursively calls
9962 for_each_template_parm, so we would need to reorganize a fair
9963 bit to use walk_tree_without_duplicates, so we keep our own
9966 pfd
.visited
= visited
;
9968 pfd
.visited
= new hash_set
<tree
>;
9969 result
= cp_walk_tree (&t
,
9970 for_each_template_parm_r
,
9984 /* Returns true if T depends on any template parameter. */
9987 uses_template_parms (tree t
)
9993 int saved_processing_template_decl
;
9995 saved_processing_template_decl
= processing_template_decl
;
9996 if (!saved_processing_template_decl
)
9997 processing_template_decl
= 1;
9999 dependent_p
= dependent_type_p (t
);
10000 else if (TREE_CODE (t
) == TREE_VEC
)
10001 dependent_p
= any_dependent_template_arguments_p (t
);
10002 else if (TREE_CODE (t
) == TREE_LIST
)
10003 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
10004 || uses_template_parms (TREE_CHAIN (t
)));
10005 else if (TREE_CODE (t
) == TYPE_DECL
)
10006 dependent_p
= dependent_type_p (TREE_TYPE (t
));
10007 else if (DECL_P (t
)
10009 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
10010 || TREE_CODE (t
) == OVERLOAD
10012 || identifier_p (t
)
10013 || TREE_CODE (t
) == TRAIT_EXPR
10014 || TREE_CODE (t
) == CONSTRUCTOR
10015 || CONSTANT_CLASS_P (t
))
10016 dependent_p
= (type_dependent_expression_p (t
)
10017 || value_dependent_expression_p (t
));
10020 gcc_assert (t
== error_mark_node
);
10021 dependent_p
= false;
10024 processing_template_decl
= saved_processing_template_decl
;
10026 return dependent_p
;
10029 /* Returns true iff current_function_decl is an incompletely instantiated
10030 template. Useful instead of processing_template_decl because the latter
10031 is set to 0 during instantiate_non_dependent_expr. */
10034 in_template_function (void)
10036 tree fn
= current_function_decl
;
10038 ++processing_template_decl
;
10039 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
10040 && DECL_TEMPLATE_INFO (fn
)
10041 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
10042 --processing_template_decl
;
10046 /* Returns true if T depends on any template parameter with level LEVEL. */
10049 uses_template_parms_level (tree t
, int level
)
10051 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
10052 /*include_nondeduced_p=*/true);
10055 /* Returns true if the signature of DECL depends on any template parameter from
10056 its enclosing class. */
10059 uses_outer_template_parms (tree decl
)
10061 int depth
= template_class_depth (CP_DECL_CONTEXT (decl
));
10064 if (for_each_template_parm (TREE_TYPE (decl
), template_parm_outer_level
,
10065 &depth
, NULL
, /*include_nondeduced_p=*/true))
10067 if (PRIMARY_TEMPLATE_P (decl
)
10068 && for_each_template_parm (INNERMOST_TEMPLATE_PARMS
10069 (DECL_TEMPLATE_PARMS (decl
)),
10070 template_parm_outer_level
,
10071 &depth
, NULL
, /*include_nondeduced_p=*/true))
10073 tree ci
= get_constraints (decl
);
10075 ci
= CI_ASSOCIATED_CONSTRAINTS (ci
);
10076 if (ci
&& for_each_template_parm (ci
, template_parm_outer_level
,
10077 &depth
, NULL
, /*nondeduced*/true))
10082 /* Returns TRUE iff INST is an instantiation we don't need to do in an
10083 ill-formed translation unit, i.e. a variable or function that isn't
10084 usable in a constant expression. */
10087 neglectable_inst_p (tree d
)
10089 return (d
&& DECL_P (d
)
10090 && !undeduced_auto_decl (d
)
10091 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
10092 : decl_maybe_constant_var_p (d
)));
10095 /* Returns TRUE iff we should refuse to instantiate DECL because it's
10096 neglectable and instantiated from within an erroneous instantiation. */
10099 limit_bad_template_recursion (tree decl
)
10101 struct tinst_level
*lev
= current_tinst_level
;
10102 int errs
= errorcount
+ sorrycount
;
10103 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
10106 for (; lev
; lev
= lev
->next
)
10107 if (neglectable_inst_p (lev
->maybe_get_node ()))
10110 return (lev
&& errs
> lev
->errors
);
10113 static int tinst_depth
;
10114 extern int max_tinst_depth
;
10117 static GTY(()) struct tinst_level
*last_error_tinst_level
;
10119 /* We're starting to instantiate D; record the template instantiation context
10120 at LOC for diagnostics and to restore it later. */
10123 push_tinst_level_loc (tree tldcl
, tree targs
, location_t loc
)
10125 struct tinst_level
*new_level
;
10127 if (tinst_depth
>= max_tinst_depth
)
10129 /* Tell error.c not to try to instantiate any templates. */
10131 fatal_error (input_location
,
10132 "template instantiation depth exceeds maximum of %d"
10133 " (use -ftemplate-depth= to increase the maximum)",
10138 /* If the current instantiation caused problems, don't let it instantiate
10139 anything else. Do allow deduction substitution and decls usable in
10140 constant expressions. */
10141 if (!targs
&& limit_bad_template_recursion (tldcl
))
10144 /* When not -quiet, dump template instantiations other than functions, since
10145 announce_function will take care of those. */
10146 if (!quiet_flag
&& !targs
10147 && TREE_CODE (tldcl
) != TREE_LIST
10148 && TREE_CODE (tldcl
) != FUNCTION_DECL
)
10149 fprintf (stderr
, " %s", decl_as_string (tldcl
, TFF_DECL_SPECIFIERS
));
10151 new_level
= tinst_level_freelist ().alloc ();
10152 new_level
->tldcl
= tldcl
;
10153 new_level
->targs
= targs
;
10154 new_level
->locus
= loc
;
10155 new_level
->errors
= errorcount
+ sorrycount
;
10156 new_level
->next
= NULL
;
10157 new_level
->refcount
= 0;
10158 set_refcount_ptr (new_level
->next
, current_tinst_level
);
10159 set_refcount_ptr (current_tinst_level
, new_level
);
10162 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
10163 depth_reached
= tinst_depth
;
10168 /* We're starting substitution of TMPL<ARGS>; record the template
10169 substitution context for diagnostics and to restore it later. */
10172 push_tinst_level (tree tmpl
, tree args
)
10174 return push_tinst_level_loc (tmpl
, args
, input_location
);
10177 /* We're starting to instantiate D; record INPUT_LOCATION and the
10178 template instantiation context for diagnostics and to restore it
10182 push_tinst_level (tree d
)
10184 return push_tinst_level_loc (d
, input_location
);
10187 /* Likewise, but record LOC as the program location. */
10190 push_tinst_level_loc (tree d
, location_t loc
)
10192 gcc_assert (TREE_CODE (d
) != TREE_LIST
);
10193 return push_tinst_level_loc (d
, NULL
, loc
);
10196 /* We're done instantiating this template; return to the instantiation
10200 pop_tinst_level (void)
10202 /* Restore the filename and line number stashed away when we started
10203 this instantiation. */
10204 input_location
= current_tinst_level
->locus
;
10205 set_refcount_ptr (current_tinst_level
, current_tinst_level
->next
);
10209 /* We're instantiating a deferred template; restore the template
10210 instantiation context in which the instantiation was requested, which
10211 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
10214 reopen_tinst_level (struct tinst_level
*level
)
10216 struct tinst_level
*t
;
10219 for (t
= level
; t
; t
= t
->next
)
10222 set_refcount_ptr (current_tinst_level
, level
);
10223 pop_tinst_level ();
10224 if (current_tinst_level
)
10225 current_tinst_level
->errors
= errorcount
+sorrycount
;
10226 return level
->maybe_get_node ();
10229 /* Returns the TINST_LEVEL which gives the original instantiation
10232 struct tinst_level
*
10233 outermost_tinst_level (void)
10235 struct tinst_level
*level
= current_tinst_level
;
10237 while (level
->next
)
10238 level
= level
->next
;
10242 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
10243 vector of template arguments, as for tsubst.
10245 Returns an appropriate tsubst'd friend declaration. */
10248 tsubst_friend_function (tree decl
, tree args
)
10252 if (TREE_CODE (decl
) == FUNCTION_DECL
10253 && DECL_TEMPLATE_INSTANTIATION (decl
)
10254 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
10255 /* This was a friend declared with an explicit template
10256 argument list, e.g.:
10258 friend void f<>(T);
10260 to indicate that f was a template instantiation, not a new
10261 function declaration. Now, we have to figure out what
10262 instantiation of what template. */
10264 tree template_id
, arglist
, fns
;
10267 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
10269 /* Friend functions are looked up in the containing namespace scope.
10270 We must enter that scope, to avoid finding member functions of the
10271 current class with same name. */
10272 push_nested_namespace (ns
);
10273 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
10274 tf_warning_or_error
, NULL_TREE
,
10275 /*integral_constant_expression_p=*/false);
10276 pop_nested_namespace (ns
);
10277 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
10278 tf_warning_or_error
, NULL_TREE
);
10279 template_id
= lookup_template_function (fns
, arglist
);
10281 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
10282 tmpl
= determine_specialization (template_id
, new_friend
,
10284 /*need_member_template=*/0,
10285 TREE_VEC_LENGTH (args
),
10287 return instantiate_template (tmpl
, new_args
, tf_error
);
10290 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
10292 /* The NEW_FRIEND will look like an instantiation, to the
10293 compiler, but is not an instantiation from the point of view of
10294 the language. For example, we might have had:
10296 template <class T> struct S {
10297 template <class U> friend void f(T, U);
10300 Then, in S<int>, template <class U> void f(int, U) is not an
10301 instantiation of anything. */
10302 if (new_friend
== error_mark_node
)
10303 return error_mark_node
;
10305 DECL_USE_TEMPLATE (new_friend
) = 0;
10306 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
10308 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
10309 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
10310 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
10313 /* The mangled name for the NEW_FRIEND is incorrect. The function
10314 is not a template instantiation and should not be mangled like
10315 one. Therefore, we forget the mangling here; we'll recompute it
10316 later if we need it. */
10317 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
10319 SET_DECL_RTL (new_friend
, NULL
);
10320 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
10323 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
10326 tree new_friend_template_info
;
10327 tree new_friend_result_template_info
;
10329 int new_friend_is_defn
;
10331 /* We must save some information from NEW_FRIEND before calling
10332 duplicate decls since that function will free NEW_FRIEND if
10334 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
10335 new_friend_is_defn
=
10336 (DECL_INITIAL (DECL_TEMPLATE_RESULT
10337 (template_for_substitution (new_friend
)))
10339 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
10341 /* This declaration is a `primary' template. */
10342 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
10344 new_friend_result_template_info
10345 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
10348 new_friend_result_template_info
= NULL_TREE
;
10350 /* Inside pushdecl_namespace_level, we will push into the
10351 current namespace. However, the friend function should go
10352 into the namespace of the template. */
10353 ns
= decl_namespace_context (new_friend
);
10354 push_nested_namespace (ns
);
10355 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
10356 pop_nested_namespace (ns
);
10358 if (old_decl
== error_mark_node
)
10359 return error_mark_node
;
10361 if (old_decl
!= new_friend
)
10363 /* This new friend declaration matched an existing
10364 declaration. For example, given:
10366 template <class T> void f(T);
10367 template <class U> class C {
10368 template <class T> friend void f(T) {}
10371 the friend declaration actually provides the definition
10372 of `f', once C has been instantiated for some type. So,
10373 old_decl will be the out-of-class template declaration,
10374 while new_friend is the in-class definition.
10376 But, if `f' was called before this point, the
10377 instantiation of `f' will have DECL_TI_ARGS corresponding
10378 to `T' but not to `U', references to which might appear
10379 in the definition of `f'. Previously, the most general
10380 template for an instantiation of `f' was the out-of-class
10381 version; now it is the in-class version. Therefore, we
10382 run through all specialization of `f', adding to their
10383 DECL_TI_ARGS appropriately. In particular, they need a
10384 new set of outer arguments, corresponding to the
10385 arguments for this class instantiation.
10387 The same situation can arise with something like this:
10389 friend void f(int);
10390 template <class T> class C {
10391 friend void f(T) {}
10394 when `C<int>' is instantiated. Now, `f(int)' is defined
10397 if (!new_friend_is_defn
)
10398 /* On the other hand, if the in-class declaration does
10399 *not* provide a definition, then we don't want to alter
10400 existing definitions. We can just leave everything
10405 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
10406 tree new_args
= TI_ARGS (new_friend_template_info
);
10408 /* Overwrite whatever template info was there before, if
10409 any, with the new template information pertaining to
10410 the declaration. */
10411 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
10413 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
10415 /* We should have called reregister_specialization in
10416 duplicate_decls. */
10417 gcc_assert (retrieve_specialization (new_template
,
10421 /* Instantiate it if the global has already been used. */
10422 if (DECL_ODR_USED (old_decl
))
10423 instantiate_decl (old_decl
, /*defer_ok=*/true,
10424 /*expl_inst_class_mem_p=*/false);
10430 /* Indicate that the old function template is a partial
10432 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
10433 = new_friend_result_template_info
;
10435 gcc_assert (new_template
10436 == most_general_template (new_template
));
10437 gcc_assert (new_template
!= old_decl
);
10439 /* Reassign any specializations already in the hash table
10440 to the new more general template, and add the
10441 additional template args. */
10442 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
10444 t
= TREE_CHAIN (t
))
10446 tree spec
= TREE_VALUE (t
);
10449 elt
.tmpl
= old_decl
;
10450 elt
.args
= DECL_TI_ARGS (spec
);
10451 elt
.spec
= NULL_TREE
;
10453 decl_specializations
->remove_elt (&elt
);
10455 DECL_TI_ARGS (spec
)
10456 = add_outermost_template_args (new_args
,
10457 DECL_TI_ARGS (spec
));
10459 register_specialization
10460 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
10463 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
10467 /* The information from NEW_FRIEND has been merged into OLD_DECL
10468 by duplicate_decls. */
10469 new_friend
= old_decl
;
10474 tree context
= DECL_CONTEXT (new_friend
);
10478 template <class T> class C {
10479 template <class U> friend void C1<U>::f (); // case 1
10480 friend void C2<T>::f (); // case 2
10482 we only need to make sure CONTEXT is a complete type for
10483 case 2. To distinguish between the two cases, we note that
10484 CONTEXT of case 1 remains dependent type after tsubst while
10485 this isn't true for case 2. */
10486 ++processing_template_decl
;
10487 dependent_p
= dependent_type_p (context
);
10488 --processing_template_decl
;
10491 && !complete_type_or_else (context
, NULL_TREE
))
10492 return error_mark_node
;
10494 if (COMPLETE_TYPE_P (context
))
10496 tree fn
= new_friend
;
10497 /* do_friend adds the TEMPLATE_DECL for any member friend
10498 template even if it isn't a member template, i.e.
10499 template <class T> friend A<T>::f();
10500 Look through it in that case. */
10501 if (TREE_CODE (fn
) == TEMPLATE_DECL
10502 && !PRIMARY_TEMPLATE_P (fn
))
10503 fn
= DECL_TEMPLATE_RESULT (fn
);
10504 /* Check to see that the declaration is really present, and,
10505 possibly obtain an improved declaration. */
10506 fn
= check_classfn (context
, fn
, NULL_TREE
);
10516 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
10517 template arguments, as for tsubst.
10519 Returns an appropriate tsubst'd friend type or error_mark_node on
10523 tsubst_friend_class (tree friend_tmpl
, tree args
)
10527 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
10529 tmpl
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
10530 return TREE_TYPE (tmpl
);
10533 tree context
= CP_DECL_CONTEXT (friend_tmpl
);
10534 if (TREE_CODE (context
) == NAMESPACE_DECL
)
10535 push_nested_namespace (context
);
10537 push_nested_class (context
);
10539 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), /*prefer_type=*/false,
10540 /*non_class=*/false, /*block_p=*/false,
10541 /*namespaces_only=*/false, LOOKUP_HIDDEN
);
10543 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
10545 /* The friend template has already been declared. Just
10546 check to see that the declarations match, and install any new
10547 default parameters. We must tsubst the default parameters,
10548 of course. We only need the innermost template parameters
10549 because that is all that redeclare_class_template will look
10551 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
10552 > TMPL_ARGS_DEPTH (args
))
10554 tree parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
10555 args
, tf_warning_or_error
);
10556 location_t saved_input_location
= input_location
;
10557 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
10558 tree cons
= get_constraints (tmpl
);
10559 redeclare_class_template (TREE_TYPE (tmpl
), parms
, cons
);
10560 input_location
= saved_input_location
;
10565 /* The friend template has not already been declared. In this
10566 case, the instantiation of the template class will cause the
10567 injection of this template into the namespace scope. */
10568 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
10570 if (tmpl
!= error_mark_node
)
10572 /* The new TMPL is not an instantiation of anything, so we
10573 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE
10574 for the new type because that is supposed to be the
10575 corresponding template decl, i.e., TMPL. */
10576 DECL_USE_TEMPLATE (tmpl
) = 0;
10577 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
10578 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
10579 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
10580 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
10582 /* It is hidden. */
10583 retrofit_lang_decl (DECL_TEMPLATE_RESULT (tmpl
));
10584 DECL_ANTICIPATED (tmpl
)
10585 = DECL_ANTICIPATED (DECL_TEMPLATE_RESULT (tmpl
)) = true;
10587 /* Inject this template into the enclosing namspace scope. */
10588 tmpl
= pushdecl_namespace_level (tmpl
, true);
10592 if (TREE_CODE (context
) == NAMESPACE_DECL
)
10593 pop_nested_namespace (context
);
10595 pop_nested_class ();
10597 return TREE_TYPE (tmpl
);
10600 /* Returns zero if TYPE cannot be completed later due to circularity.
10601 Otherwise returns one. */
10604 can_complete_type_without_circularity (tree type
)
10606 if (type
== NULL_TREE
|| type
== error_mark_node
)
10608 else if (COMPLETE_TYPE_P (type
))
10610 else if (TREE_CODE (type
) == ARRAY_TYPE
)
10611 return can_complete_type_without_circularity (TREE_TYPE (type
));
10612 else if (CLASS_TYPE_P (type
)
10613 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
10619 static tree
tsubst_omp_clauses (tree
, enum c_omp_region_type
, tree
,
10620 tsubst_flags_t
, tree
);
10622 /* Instantiate a single dependent attribute T (a TREE_LIST), and return either
10623 T or a new TREE_LIST, possibly a chain in the case of a pack expansion. */
10626 tsubst_attribute (tree t
, tree
*decl_p
, tree args
,
10627 tsubst_flags_t complain
, tree in_decl
)
10629 gcc_assert (ATTR_IS_DEPENDENT (t
));
10631 tree val
= TREE_VALUE (t
);
10632 if (val
== NULL_TREE
)
10633 /* Nothing to do. */;
10634 else if ((flag_openmp
|| flag_openmp_simd
)
10635 && is_attribute_p ("omp declare simd",
10636 get_attribute_name (t
)))
10638 tree clauses
= TREE_VALUE (val
);
10639 clauses
= tsubst_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
, args
,
10640 complain
, in_decl
);
10641 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
10642 clauses
= finish_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
);
10643 tree parms
= DECL_ARGUMENTS (*decl_p
);
10645 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
10647 val
= build_tree_list (NULL_TREE
, clauses
);
10651 /* If the first attribute argument is an identifier, don't
10652 pass it through tsubst. Attributes like mode, format,
10653 cleanup and several target specific attributes expect it
10655 else if (attribute_takes_identifier_p (get_attribute_name (t
)))
10658 = tsubst_expr (TREE_CHAIN (val
), args
, complain
, in_decl
,
10659 /*integral_constant_expression_p=*/false);
10660 if (chain
!= TREE_CHAIN (val
))
10661 val
= tree_cons (NULL_TREE
, TREE_VALUE (val
), chain
);
10663 else if (PACK_EXPANSION_P (val
))
10665 /* An attribute pack expansion. */
10666 tree purp
= TREE_PURPOSE (t
);
10667 tree pack
= tsubst_pack_expansion (val
, args
, complain
, in_decl
);
10668 if (pack
== error_mark_node
)
10669 return error_mark_node
;
10670 int len
= TREE_VEC_LENGTH (pack
);
10671 tree list
= NULL_TREE
;
10673 for (int i
= 0; i
< len
; ++i
)
10675 tree elt
= TREE_VEC_ELT (pack
, i
);
10676 *q
= build_tree_list (purp
, elt
);
10677 q
= &TREE_CHAIN (*q
);
10682 val
= tsubst_expr (val
, args
, complain
, in_decl
,
10683 /*integral_constant_expression_p=*/false);
10685 if (val
!= TREE_VALUE (t
))
10686 return build_tree_list (TREE_PURPOSE (t
), val
);
10690 /* Instantiate any dependent attributes in ATTRIBUTES, returning either it
10691 unchanged or a new TREE_LIST chain. */
10694 tsubst_attributes (tree attributes
, tree args
,
10695 tsubst_flags_t complain
, tree in_decl
)
10697 tree last_dep
= NULL_TREE
;
10699 for (tree t
= attributes
; t
; t
= TREE_CHAIN (t
))
10700 if (ATTR_IS_DEPENDENT (t
))
10703 attributes
= copy_list (attributes
);
10708 for (tree
*p
= &attributes
; *p
; )
10711 if (ATTR_IS_DEPENDENT (t
))
10713 tree subst
= tsubst_attribute (t
, NULL
, args
, complain
, in_decl
);
10718 p
= &TREE_CHAIN (*p
);
10719 *p
= TREE_CHAIN (t
);
10723 p
= &TREE_CHAIN (*p
);
10729 /* Apply any attributes which had to be deferred until instantiation
10730 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
10731 ARGS, COMPLAIN, IN_DECL are as tsubst. */
10734 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
10735 tree args
, tsubst_flags_t complain
, tree in_decl
)
10737 tree last_dep
= NULL_TREE
;
10741 if (attributes
== NULL_TREE
)
10744 if (DECL_P (*decl_p
))
10746 if (TREE_TYPE (*decl_p
) == error_mark_node
)
10748 p
= &DECL_ATTRIBUTES (*decl_p
);
10749 /* DECL_ATTRIBUTES comes from copy_node in tsubst_decl, and is identical
10750 to our attributes parameter. */
10751 gcc_assert (*p
== attributes
);
10755 p
= &TYPE_ATTRIBUTES (*decl_p
);
10756 /* TYPE_ATTRIBUTES was set up (with abi_tag and may_alias) in
10757 lookup_template_class_1, and should be preserved. */
10758 gcc_assert (*p
!= attributes
);
10760 p
= &TREE_CHAIN (*p
);
10763 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
10764 if (ATTR_IS_DEPENDENT (t
))
10767 attributes
= copy_list (attributes
);
10774 tree late_attrs
= NULL_TREE
;
10775 tree
*q
= &late_attrs
;
10780 if (ATTR_IS_DEPENDENT (t
))
10782 *p
= TREE_CHAIN (t
);
10783 TREE_CHAIN (t
) = NULL_TREE
;
10784 *q
= tsubst_attribute (t
, decl_p
, args
, complain
, in_decl
);
10786 q
= &TREE_CHAIN (*q
);
10789 p
= &TREE_CHAIN (t
);
10792 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
10796 /* Perform (or defer) access check for typedefs that were referenced
10797 from within the template TMPL code.
10798 This is a subroutine of instantiate_decl and instantiate_class_template.
10799 TMPL is the template to consider and TARGS is the list of arguments of
10803 perform_typedefs_access_check (tree tmpl
, tree targs
)
10805 location_t saved_location
;
10807 qualified_typedef_usage_t
*iter
;
10810 || (!CLASS_TYPE_P (tmpl
)
10811 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
10814 saved_location
= input_location
;
10815 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
10817 tree type_decl
= iter
->typedef_decl
;
10818 tree type_scope
= iter
->context
;
10820 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
10823 if (uses_template_parms (type_decl
))
10824 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
10825 if (uses_template_parms (type_scope
))
10826 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
10828 /* Make access check error messages point to the location
10829 of the use of the typedef. */
10830 input_location
= iter
->locus
;
10831 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
10832 type_decl
, type_decl
,
10833 tf_warning_or_error
);
10835 input_location
= saved_location
;
10839 instantiate_class_template_1 (tree type
)
10841 tree templ
, args
, pattern
, t
, member
;
10845 unsigned int saved_maximum_field_alignment
;
10848 if (type
== error_mark_node
)
10849 return error_mark_node
;
10851 if (COMPLETE_OR_OPEN_TYPE_P (type
)
10852 || uses_template_parms (type
))
10855 /* Figure out which template is being instantiated. */
10856 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
10857 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
10859 /* Mark the type as in the process of being defined. */
10860 TYPE_BEING_DEFINED (type
) = 1;
10862 /* We may be in the middle of deferred access check. Disable
10864 deferring_access_check_sentinel
acs (dk_no_deferred
);
10866 /* Determine what specialization of the original template to
10868 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
10869 if (t
== error_mark_node
)
10870 return error_mark_node
;
10873 /* This TYPE is actually an instantiation of a partial
10874 specialization. We replace the innermost set of ARGS with
10875 the arguments appropriate for substitution. For example,
10878 template <class T> struct S {};
10879 template <class T> struct S<T*> {};
10881 and supposing that we are instantiating S<int*>, ARGS will
10882 presently be {int*} -- but we need {int}. */
10883 pattern
= TREE_TYPE (t
);
10884 args
= TREE_PURPOSE (t
);
10888 pattern
= TREE_TYPE (templ
);
10889 args
= CLASSTYPE_TI_ARGS (type
);
10892 /* If the template we're instantiating is incomplete, then clearly
10893 there's nothing we can do. */
10894 if (!COMPLETE_TYPE_P (pattern
))
10896 /* We can try again later. */
10897 TYPE_BEING_DEFINED (type
) = 0;
10901 /* If we've recursively instantiated too many templates, stop. */
10902 if (! push_tinst_level (type
))
10905 int saved_unevaluated_operand
= cp_unevaluated_operand
;
10906 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10908 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
10909 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
10910 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
10911 fn_context
= error_mark_node
;
10913 push_to_top_level ();
10916 cp_unevaluated_operand
= 0;
10917 c_inhibit_evaluation_warnings
= 0;
10919 /* Use #pragma pack from the template context. */
10920 saved_maximum_field_alignment
= maximum_field_alignment
;
10921 maximum_field_alignment
= TYPE_PRECISION (pattern
);
10923 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
10925 /* Set the input location to the most specialized template definition.
10926 This is needed if tsubsting causes an error. */
10927 typedecl
= TYPE_MAIN_DECL (pattern
);
10928 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
10929 DECL_SOURCE_LOCATION (typedecl
);
10931 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
10932 SET_TYPE_ALIGN (type
, TYPE_ALIGN (pattern
));
10933 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
10934 CLASSTYPE_NON_AGGREGATE (type
) = CLASSTYPE_NON_AGGREGATE (pattern
);
10935 if (ANON_AGGR_TYPE_P (pattern
))
10936 SET_ANON_AGGR_TYPE_P (type
);
10937 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
10939 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
10940 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
10941 /* Adjust visibility for template arguments. */
10942 determine_visibility (TYPE_MAIN_DECL (type
));
10944 if (CLASS_TYPE_P (type
))
10945 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
10947 pbinfo
= TYPE_BINFO (pattern
);
10949 /* We should never instantiate a nested class before its enclosing
10950 class; we need to look up the nested class by name before we can
10951 instantiate it, and that lookup should instantiate the enclosing
10953 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
10954 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
10956 base_list
= NULL_TREE
;
10957 if (BINFO_N_BASE_BINFOS (pbinfo
))
10963 /* We must enter the scope containing the type, as that is where
10964 the accessibility of types named in dependent bases are
10966 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
10968 /* Substitute into each of the bases to determine the actual
10970 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
10973 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
10974 tree expanded_bases
= NULL_TREE
;
10977 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
10980 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
10981 args
, tf_error
, NULL_TREE
);
10982 if (expanded_bases
== error_mark_node
)
10985 len
= TREE_VEC_LENGTH (expanded_bases
);
10988 for (idx
= 0; idx
< len
; idx
++)
10990 if (expanded_bases
)
10991 /* Extract the already-expanded base class. */
10992 base
= TREE_VEC_ELT (expanded_bases
, idx
);
10994 /* Substitute to figure out the base class. */
10995 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
10998 if (base
== error_mark_node
)
11001 base_list
= tree_cons (access
, base
, base_list
);
11002 if (BINFO_VIRTUAL_P (pbase_binfo
))
11003 TREE_TYPE (base_list
) = integer_type_node
;
11007 /* The list is now in reverse order; correct that. */
11008 base_list
= nreverse (base_list
);
11011 pop_scope (pushed_scope
);
11013 /* Now call xref_basetypes to set up all the base-class
11015 xref_basetypes (type
, base_list
);
11017 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
11018 (int) ATTR_FLAG_TYPE_IN_PLACE
,
11019 args
, tf_error
, NULL_TREE
);
11020 fixup_attribute_variants (type
);
11022 /* Now that our base classes are set up, enter the scope of the
11023 class, so that name lookups into base classes, etc. will work
11024 correctly. This is precisely analogous to what we do in
11025 begin_class_definition when defining an ordinary non-template
11026 class, except we also need to push the enclosing classes. */
11027 push_nested_class (type
);
11029 /* Now members are processed in the order of declaration. */
11030 for (member
= CLASSTYPE_DECL_LIST (pattern
);
11031 member
; member
= TREE_CHAIN (member
))
11033 tree t
= TREE_VALUE (member
);
11035 if (TREE_PURPOSE (member
))
11039 if (LAMBDA_TYPE_P (t
))
11040 /* A closure type for a lambda in an NSDMI or default argument.
11041 Ignore it; it will be regenerated when needed. */
11044 /* Build new CLASSTYPE_NESTED_UTDS. */
11047 bool class_template_p
;
11049 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
11050 && TYPE_LANG_SPECIFIC (t
)
11051 && CLASSTYPE_IS_TEMPLATE (t
));
11052 /* If the member is a class template, then -- even after
11053 substitution -- there may be dependent types in the
11054 template argument list for the class. We increment
11055 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
11056 that function will assume that no types are dependent
11057 when outside of a template. */
11058 if (class_template_p
)
11059 ++processing_template_decl
;
11060 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
11061 if (class_template_p
)
11062 --processing_template_decl
;
11063 if (newtag
== error_mark_node
)
11066 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
11068 tree name
= TYPE_IDENTIFIER (t
);
11070 if (class_template_p
)
11071 /* Unfortunately, lookup_template_class sets
11072 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
11073 instantiation (i.e., for the type of a member
11074 template class nested within a template class.)
11075 This behavior is required for
11076 maybe_process_partial_specialization to work
11077 correctly, but is not accurate in this case;
11078 the TAG is not an instantiation of anything.
11079 (The corresponding TEMPLATE_DECL is an
11080 instantiation, but the TYPE is not.) */
11081 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
11083 /* Now, we call pushtag to put this NEWTAG into the scope of
11084 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
11085 pushtag calling push_template_decl. We don't have to do
11086 this for enums because it will already have been done in
11089 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
11090 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
11093 else if (DECL_DECLARES_FUNCTION_P (t
))
11097 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11098 ++processing_template_decl
;
11099 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
11100 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11101 --processing_template_decl
;
11102 set_current_access_from_decl (r
);
11103 finish_member_declaration (r
);
11104 /* Instantiate members marked with attribute used. */
11105 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
11107 if (TREE_CODE (r
) == FUNCTION_DECL
11108 && DECL_OMP_DECLARE_REDUCTION_P (r
))
11109 cp_check_omp_declare_reduction (r
);
11111 else if ((DECL_CLASS_TEMPLATE_P (t
) || DECL_IMPLICIT_TYPEDEF_P (t
))
11112 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
11113 /* A closure type for a lambda in an NSDMI or default argument.
11114 Ignore it; it will be regenerated when needed. */;
11117 /* Build new TYPE_FIELDS. */
11118 if (TREE_CODE (t
) == STATIC_ASSERT
)
11122 ++c_inhibit_evaluation_warnings
;
11124 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
11125 tf_warning_or_error
, NULL_TREE
,
11126 /*integral_constant_expression_p=*/true);
11127 --c_inhibit_evaluation_warnings
;
11129 finish_static_assert (condition
,
11130 STATIC_ASSERT_MESSAGE (t
),
11131 STATIC_ASSERT_SOURCE_LOCATION (t
),
11132 /*member_p=*/true);
11134 else if (TREE_CODE (t
) != CONST_DECL
)
11137 tree vec
= NULL_TREE
;
11140 /* The file and line for this declaration, to
11141 assist in error message reporting. Since we
11142 called push_tinst_level above, we don't need to
11144 input_location
= DECL_SOURCE_LOCATION (t
);
11146 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11147 ++processing_template_decl
;
11148 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
11149 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11150 --processing_template_decl
;
11152 if (TREE_CODE (r
) == TREE_VEC
)
11154 /* A capture pack became multiple fields. */
11156 len
= TREE_VEC_LENGTH (vec
);
11159 for (int i
= 0; i
< len
; ++i
)
11162 r
= TREE_VEC_ELT (vec
, i
);
11167 [t]he initialization (and any associated
11168 side-effects) of a static data member does
11169 not occur unless the static data member is
11170 itself used in a way that requires the
11171 definition of the static data member to
11174 Therefore, we do not substitute into the
11175 initialized for the static data member here. */
11176 finish_static_data_member_decl
11178 /*init=*/NULL_TREE
,
11179 /*init_const_expr_p=*/false,
11180 /*asmspec_tree=*/NULL_TREE
,
11182 /* Instantiate members marked with attribute used. */
11183 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
11186 else if (TREE_CODE (r
) == FIELD_DECL
)
11188 /* Determine whether R has a valid type and can be
11189 completed later. If R is invalid, then its type
11190 is replaced by error_mark_node. */
11191 tree rtype
= TREE_TYPE (r
);
11192 if (can_complete_type_without_circularity (rtype
))
11193 complete_type (rtype
);
11195 if (!complete_or_array_type_p (rtype
))
11197 /* If R's type couldn't be completed and
11198 it isn't a flexible array member (whose
11199 type is incomplete by definition) give
11201 cxx_incomplete_type_error (r
, rtype
);
11202 TREE_TYPE (r
) = error_mark_node
;
11204 else if (TREE_CODE (rtype
) == ARRAY_TYPE
11205 && TYPE_DOMAIN (rtype
) == NULL_TREE
11206 && (TREE_CODE (type
) == UNION_TYPE
11207 || TREE_CODE (type
) == QUAL_UNION_TYPE
))
11209 error ("flexible array member %qD in union", r
);
11210 TREE_TYPE (r
) = error_mark_node
;
11214 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
11215 such a thing will already have been added to the field
11216 list by tsubst_enum in finish_member_declaration in the
11217 CLASSTYPE_NESTED_UTDS case above. */
11218 if (!(TREE_CODE (r
) == TYPE_DECL
11219 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
11220 && DECL_ARTIFICIAL (r
)))
11222 set_current_access_from_decl (r
);
11223 finish_member_declaration (r
);
11231 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
11232 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
11234 /* Build new CLASSTYPE_FRIEND_CLASSES. */
11236 tree friend_type
= t
;
11237 bool adjust_processing_template_decl
= false;
11239 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
11241 /* template <class T> friend class C; */
11242 friend_type
= tsubst_friend_class (friend_type
, args
);
11243 adjust_processing_template_decl
= true;
11245 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
11247 /* template <class T> friend class C::D; */
11248 friend_type
= tsubst (friend_type
, args
,
11249 tf_warning_or_error
, NULL_TREE
);
11250 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
11251 friend_type
= TREE_TYPE (friend_type
);
11252 adjust_processing_template_decl
= true;
11254 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
11255 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
11257 /* This could be either
11261 when dependent_type_p is false or
11263 template <class U> friend class T::C;
11266 /* Bump processing_template_decl in case this is something like
11267 template <class T> friend struct A<T>::B. */
11268 ++processing_template_decl
;
11269 friend_type
= tsubst (friend_type
, args
,
11270 tf_warning_or_error
, NULL_TREE
);
11271 if (dependent_type_p (friend_type
))
11272 adjust_processing_template_decl
= true;
11273 --processing_template_decl
;
11275 else if (TREE_CODE (friend_type
) != BOUND_TEMPLATE_TEMPLATE_PARM
11276 && !CLASSTYPE_USE_TEMPLATE (friend_type
)
11277 && TYPE_HIDDEN_P (friend_type
))
11281 where C hasn't been declared yet. Let's lookup name
11282 from namespace scope directly, bypassing any name that
11283 come from dependent base class. */
11284 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
11286 /* The call to xref_tag_from_type does injection for friend
11288 push_nested_namespace (ns
);
11290 xref_tag_from_type (friend_type
, NULL_TREE
,
11291 /*tag_scope=*/ts_current
);
11292 pop_nested_namespace (ns
);
11294 else if (uses_template_parms (friend_type
))
11295 /* friend class C<T>; */
11296 friend_type
= tsubst (friend_type
, args
,
11297 tf_warning_or_error
, NULL_TREE
);
11302 where C is already declared or
11304 friend class C<int>;
11306 We don't have to do anything in these cases. */
11308 if (adjust_processing_template_decl
)
11309 /* Trick make_friend_class into realizing that the friend
11310 we're adding is a template, not an ordinary class. It's
11311 important that we use make_friend_class since it will
11312 perform some error-checking and output cross-reference
11314 ++processing_template_decl
;
11316 if (friend_type
!= error_mark_node
)
11317 make_friend_class (type
, friend_type
, /*complain=*/false);
11319 if (adjust_processing_template_decl
)
11320 --processing_template_decl
;
11324 /* Build new DECL_FRIENDLIST. */
11327 /* The file and line for this declaration, to
11328 assist in error message reporting. Since we
11329 called push_tinst_level above, we don't need to
11331 input_location
= DECL_SOURCE_LOCATION (t
);
11333 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11335 ++processing_template_decl
;
11336 push_deferring_access_checks (dk_no_check
);
11339 r
= tsubst_friend_function (t
, args
);
11340 add_friend (type
, r
, /*complain=*/false);
11341 if (TREE_CODE (t
) == TEMPLATE_DECL
)
11343 pop_deferring_access_checks ();
11344 --processing_template_decl
;
11352 /* Restore these before substituting into the lambda capture
11354 cp_unevaluated_operand
= saved_unevaluated_operand
;
11355 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
11358 /* Set the file and line number information to whatever is given for
11359 the class itself. This puts error messages involving generated
11360 implicit functions at a predictable point, and the same point
11361 that would be used for non-template classes. */
11362 input_location
= DECL_SOURCE_LOCATION (typedecl
);
11364 unreverse_member_declarations (type
);
11365 finish_struct_1 (type
);
11366 TYPE_BEING_DEFINED (type
) = 0;
11368 /* We don't instantiate default arguments for member functions. 14.7.1:
11370 The implicit instantiation of a class template specialization causes
11371 the implicit instantiation of the declarations, but not of the
11372 definitions or default arguments, of the class member functions,
11373 member classes, static data members and member templates.... */
11375 /* Some typedefs referenced from within the template code need to be access
11376 checked at template instantiation time, i.e now. These types were
11377 added to the template at parsing time. Let's get those and perform
11378 the access checks then. */
11379 perform_typedefs_access_check (pattern
, args
);
11380 perform_deferred_access_checks (tf_warning_or_error
);
11381 pop_nested_class ();
11382 maximum_field_alignment
= saved_maximum_field_alignment
;
11384 pop_from_top_level ();
11385 pop_tinst_level ();
11387 /* The vtable for a template class can be emitted in any translation
11388 unit in which the class is instantiated. When there is no key
11389 method, however, finish_struct_1 will already have added TYPE to
11390 the keyed_classes. */
11391 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
11392 vec_safe_push (keyed_classes
, type
);
11397 /* Wrapper for instantiate_class_template_1. */
11400 instantiate_class_template (tree type
)
11403 timevar_push (TV_TEMPLATE_INST
);
11404 ret
= instantiate_class_template_1 (type
);
11405 timevar_pop (TV_TEMPLATE_INST
);
11410 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11416 else if (TYPE_P (t
))
11417 r
= tsubst (t
, args
, complain
, in_decl
);
11420 if (!(complain
& tf_warning
))
11421 ++c_inhibit_evaluation_warnings
;
11422 r
= tsubst_expr (t
, args
, complain
, in_decl
,
11423 /*integral_constant_expression_p=*/true);
11424 if (!(complain
& tf_warning
))
11425 --c_inhibit_evaluation_warnings
;
11430 /* Given a function parameter pack TMPL_PARM and some function parameters
11431 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
11432 and set *SPEC_P to point at the next point in the list. */
11435 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
11437 /* Collect all of the extra "packed" parameters into an
11440 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
11441 tree spec_parm
= *spec_p
;
11444 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
11446 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
11449 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
11450 parmvec
= make_tree_vec (len
);
11451 spec_parm
= *spec_p
;
11452 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
11454 tree elt
= spec_parm
;
11455 if (DECL_PACK_P (elt
))
11456 elt
= make_pack_expansion (elt
);
11457 TREE_VEC_ELT (parmvec
, i
) = elt
;
11460 /* Build the argument packs. */
11461 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
11462 *spec_p
= spec_parm
;
11467 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
11468 NONTYPE_ARGUMENT_PACK. */
11471 make_fnparm_pack (tree spec_parm
)
11473 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
11476 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
11477 pack expansion with no extra args, 2 if it has extra args, or 0
11478 if it is not a pack expansion. */
11481 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
11483 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
11484 if (i
>= TREE_VEC_LENGTH (vec
))
11486 tree elt
= TREE_VEC_ELT (vec
, i
);
11488 /* A decl pack is itself an expansion. */
11489 elt
= TREE_TYPE (elt
);
11490 if (!PACK_EXPANSION_P (elt
))
11492 if (PACK_EXPANSION_EXTRA_ARGS (elt
))
11498 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
11501 make_argument_pack_select (tree arg_pack
, unsigned index
)
11503 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
11505 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
11506 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
11511 /* This is a subroutine of tsubst_pack_expansion.
11513 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
11514 mechanism to store the (non complete list of) arguments of the
11515 substitution and return a non substituted pack expansion, in order
11516 to wait for when we have enough arguments to really perform the
11520 use_pack_expansion_extra_args_p (tree parm_packs
,
11522 bool has_empty_arg
)
11524 /* If one pack has an expansion and another pack has a normal
11525 argument or if one pack has an empty argument and an another
11526 one hasn't then tsubst_pack_expansion cannot perform the
11527 substitution and need to fall back on the
11528 PACK_EXPANSION_EXTRA mechanism. */
11529 if (parm_packs
== NULL_TREE
)
11531 else if (has_empty_arg
)
11534 bool has_expansion_arg
= false;
11535 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
11537 bool has_non_expansion_arg
= false;
11538 for (tree parm_pack
= parm_packs
;
11540 parm_pack
= TREE_CHAIN (parm_pack
))
11542 tree arg
= TREE_VALUE (parm_pack
);
11544 int exp
= argument_pack_element_is_expansion_p (arg
, i
);
11546 /* We can't substitute a pack expansion with extra args into
11550 has_expansion_arg
= true;
11552 has_non_expansion_arg
= true;
11555 if (has_expansion_arg
&& has_non_expansion_arg
)
11561 /* [temp.variadic]/6 says that:
11563 The instantiation of a pack expansion [...]
11564 produces a list E1,E2, ..., En, where N is the number of elements
11565 in the pack expansion parameters.
11567 This subroutine of tsubst_pack_expansion produces one of these Ei.
11569 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
11570 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
11571 PATTERN, and each TREE_VALUE is its corresponding argument pack.
11572 INDEX is the index 'i' of the element Ei to produce. ARGS,
11573 COMPLAIN, and IN_DECL are the same parameters as for the
11574 tsubst_pack_expansion function.
11576 The function returns the resulting Ei upon successful completion,
11577 or error_mark_node.
11579 Note that this function possibly modifies the ARGS parameter, so
11580 it's the responsibility of the caller to restore it. */
11583 gen_elem_of_pack_expansion_instantiation (tree pattern
,
11586 tree args
/* This parm gets
11588 tsubst_flags_t complain
,
11592 bool ith_elem_is_expansion
= false;
11594 /* For each parameter pack, change the substitution of the parameter
11595 pack to the ith argument in its argument pack, then expand the
11597 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
11599 tree parm
= TREE_PURPOSE (pack
);
11600 tree arg_pack
= TREE_VALUE (pack
);
11601 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
11603 ith_elem_is_expansion
|=
11604 argument_pack_element_is_expansion_p (arg_pack
, index
);
11606 /* Select the Ith argument from the pack. */
11607 if (TREE_CODE (parm
) == PARM_DECL
11609 || TREE_CODE (parm
) == FIELD_DECL
)
11613 aps
= make_argument_pack_select (arg_pack
, index
);
11614 if (!mark_used (parm
, complain
) && !(complain
& tf_error
))
11615 return error_mark_node
;
11616 register_local_specialization (aps
, parm
);
11619 aps
= retrieve_local_specialization (parm
);
11624 template_parm_level_and_index (parm
, &level
, &idx
);
11628 aps
= make_argument_pack_select (arg_pack
, index
);
11629 /* Update the corresponding argument. */
11630 TMPL_ARG (args
, level
, idx
) = aps
;
11633 /* Re-use the ARGUMENT_PACK_SELECT. */
11634 aps
= TMPL_ARG (args
, level
, idx
);
11636 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
11639 /* Substitute into the PATTERN with the (possibly altered)
11641 if (pattern
== in_decl
)
11642 /* Expanding a fixed parameter pack from
11643 coerce_template_parameter_pack. */
11644 t
= tsubst_decl (pattern
, args
, complain
);
11645 else if (pattern
== error_mark_node
)
11646 t
= error_mark_node
;
11647 else if (constraint_p (pattern
))
11649 if (processing_template_decl
)
11650 t
= tsubst_constraint (pattern
, args
, complain
, in_decl
);
11652 t
= (constraints_satisfied_p (pattern
, args
)
11653 ? boolean_true_node
: boolean_false_node
);
11655 else if (!TYPE_P (pattern
))
11656 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
11657 /*integral_constant_expression_p=*/false);
11659 t
= tsubst (pattern
, args
, complain
, in_decl
);
11661 /* If the Ith argument pack element is a pack expansion, then
11662 the Ith element resulting from the substituting is going to
11663 be a pack expansion as well. */
11664 if (ith_elem_is_expansion
)
11665 t
= make_pack_expansion (t
, complain
);
11670 /* When the unexpanded parameter pack in a fold expression expands to an empty
11671 sequence, the value of the expression is as follows; the program is
11672 ill-formed if the operator is not listed in this table.
11679 expand_empty_fold (tree t
, tsubst_flags_t complain
)
11681 tree_code code
= (tree_code
)TREE_INT_CST_LOW (TREE_OPERAND (t
, 0));
11682 if (!FOLD_EXPR_MODIFY_P (t
))
11685 case TRUTH_ANDIF_EXPR
:
11686 return boolean_true_node
;
11687 case TRUTH_ORIF_EXPR
:
11688 return boolean_false_node
;
11689 case COMPOUND_EXPR
:
11695 if (complain
& tf_error
)
11696 error_at (location_of (t
),
11697 "fold of empty expansion over %O", code
);
11698 return error_mark_node
;
11701 /* Given a fold-expression T and a current LEFT and RIGHT operand,
11702 form an expression that combines the two terms using the
11706 fold_expression (tree t
, tree left
, tree right
, tsubst_flags_t complain
)
11708 tree op
= FOLD_EXPR_OP (t
);
11709 tree_code code
= (tree_code
)TREE_INT_CST_LOW (op
);
11711 // Handle compound assignment operators.
11712 if (FOLD_EXPR_MODIFY_P (t
))
11713 return build_x_modify_expr (input_location
, left
, code
, right
, complain
);
11717 case COMPOUND_EXPR
:
11718 return build_x_compound_expr (input_location
, left
, right
, complain
);
11720 return build_m_component_ref (left
, right
, complain
);
11722 return build_x_binary_op (input_location
, code
,
11723 left
, TREE_CODE (left
),
11724 right
, TREE_CODE (right
),
11730 /* Substitute ARGS into the pack of a fold expression T. */
11733 tsubst_fold_expr_pack (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11735 return tsubst_pack_expansion (FOLD_EXPR_PACK (t
), args
, complain
, in_decl
);
11738 /* Substitute ARGS into the pack of a fold expression T. */
11741 tsubst_fold_expr_init (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11743 return tsubst_expr (FOLD_EXPR_INIT (t
), args
, complain
, in_decl
, false);
11746 /* Expand a PACK of arguments into a grouped as left fold.
11747 Given a pack containing elements A0, A1, ..., An and an
11748 operator @, this builds the expression:
11750 ((A0 @ A1) @ A2) ... @ An
11752 Note that PACK must not be empty.
11754 The operator is defined by the original fold expression T. */
11757 expand_left_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11759 tree left
= TREE_VEC_ELT (pack
, 0);
11760 for (int i
= 1; i
< TREE_VEC_LENGTH (pack
); ++i
)
11762 tree right
= TREE_VEC_ELT (pack
, i
);
11763 left
= fold_expression (t
, left
, right
, complain
);
11768 /* Substitute into a unary left fold expression. */
11771 tsubst_unary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11774 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11775 if (pack
== error_mark_node
)
11776 return error_mark_node
;
11777 if (PACK_EXPANSION_P (pack
))
11779 tree r
= copy_node (t
);
11780 FOLD_EXPR_PACK (r
) = pack
;
11783 if (TREE_VEC_LENGTH (pack
) == 0)
11784 return expand_empty_fold (t
, complain
);
11786 return expand_left_fold (t
, pack
, complain
);
11789 /* Substitute into a binary left fold expression.
11791 Do ths by building a single (non-empty) vector of argumnts and
11792 building the expression from those elements. */
11795 tsubst_binary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11798 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11799 if (pack
== error_mark_node
)
11800 return error_mark_node
;
11801 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
11802 if (init
== error_mark_node
)
11803 return error_mark_node
;
11805 if (PACK_EXPANSION_P (pack
))
11807 tree r
= copy_node (t
);
11808 FOLD_EXPR_PACK (r
) = pack
;
11809 FOLD_EXPR_INIT (r
) = init
;
11813 tree vec
= make_tree_vec (TREE_VEC_LENGTH (pack
) + 1);
11814 TREE_VEC_ELT (vec
, 0) = init
;
11815 for (int i
= 0; i
< TREE_VEC_LENGTH (pack
); ++i
)
11816 TREE_VEC_ELT (vec
, i
+ 1) = TREE_VEC_ELT (pack
, i
);
11818 return expand_left_fold (t
, vec
, complain
);
11821 /* Expand a PACK of arguments into a grouped as right fold.
11822 Given a pack containing elementns A0, A1, ..., and an
11823 operator @, this builds the expression:
11825 A0@ ... (An-2 @ (An-1 @ An))
11827 Note that PACK must not be empty.
11829 The operator is defined by the original fold expression T. */
11832 expand_right_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11834 // Build the expression.
11835 int n
= TREE_VEC_LENGTH (pack
);
11836 tree right
= TREE_VEC_ELT (pack
, n
- 1);
11837 for (--n
; n
!= 0; --n
)
11839 tree left
= TREE_VEC_ELT (pack
, n
- 1);
11840 right
= fold_expression (t
, left
, right
, complain
);
11845 /* Substitute into a unary right fold expression. */
11848 tsubst_unary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
11851 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11852 if (pack
== error_mark_node
)
11853 return error_mark_node
;
11854 if (PACK_EXPANSION_P (pack
))
11856 tree r
= copy_node (t
);
11857 FOLD_EXPR_PACK (r
) = pack
;
11860 if (TREE_VEC_LENGTH (pack
) == 0)
11861 return expand_empty_fold (t
, complain
);
11863 return expand_right_fold (t
, pack
, complain
);
11866 /* Substitute into a binary right fold expression.
11868 Do ths by building a single (non-empty) vector of arguments and
11869 building the expression from those elements. */
11872 tsubst_binary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
11875 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11876 if (pack
== error_mark_node
)
11877 return error_mark_node
;
11878 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
11879 if (init
== error_mark_node
)
11880 return error_mark_node
;
11882 if (PACK_EXPANSION_P (pack
))
11884 tree r
= copy_node (t
);
11885 FOLD_EXPR_PACK (r
) = pack
;
11886 FOLD_EXPR_INIT (r
) = init
;
11890 int n
= TREE_VEC_LENGTH (pack
);
11891 tree vec
= make_tree_vec (n
+ 1);
11892 for (int i
= 0; i
< n
; ++i
)
11893 TREE_VEC_ELT (vec
, i
) = TREE_VEC_ELT (pack
, i
);
11894 TREE_VEC_ELT (vec
, n
) = init
;
11896 return expand_right_fold (t
, vec
, complain
);
11899 /* Walk through the pattern of a pack expansion, adding everything in
11900 local_specializations to a list. */
11904 hash_set
<tree
> internal
;
11906 tsubst_flags_t complain
;
11908 el_data (tsubst_flags_t c
)
11909 : extra (NULL_TREE
), complain (c
) {}
11912 extract_locals_r (tree
*tp
, int */
*walk_subtrees*/
, void *data_
)
11914 el_data
&data
= *reinterpret_cast<el_data
*>(data_
);
11915 tree
*extra
= &data
.extra
;
11916 tsubst_flags_t complain
= data
.complain
;
11918 if (TYPE_P (*tp
) && typedef_variant_p (*tp
))
11919 /* Remember local typedefs (85214). */
11920 tp
= &TYPE_NAME (*tp
);
11922 if (TREE_CODE (*tp
) == DECL_EXPR
)
11923 data
.internal
.add (DECL_EXPR_DECL (*tp
));
11924 else if (tree spec
= retrieve_local_specialization (*tp
))
11926 if (data
.internal
.contains (*tp
))
11927 /* Don't mess with variables declared within the pattern. */
11929 if (TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
)
11931 /* Maybe pull out the PARM_DECL for a partial instantiation. */
11932 tree args
= ARGUMENT_PACK_ARGS (spec
);
11933 if (TREE_VEC_LENGTH (args
) == 1)
11935 tree elt
= TREE_VEC_ELT (args
, 0);
11936 if (PACK_EXPANSION_P (elt
))
11937 elt
= PACK_EXPANSION_PATTERN (elt
);
11938 if (DECL_PACK_P (elt
))
11941 if (TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
)
11943 /* Handle lambda capture here, since we aren't doing any
11944 substitution now, and so tsubst_copy won't call
11945 process_outer_var_ref. */
11946 tree args
= ARGUMENT_PACK_ARGS (spec
);
11947 int len
= TREE_VEC_LENGTH (args
);
11948 for (int i
= 0; i
< len
; ++i
)
11950 tree arg
= TREE_VEC_ELT (args
, i
);
11952 if (outer_automatic_var_p (arg
))
11953 carg
= process_outer_var_ref (arg
, complain
);
11956 /* Make a new NONTYPE_ARGUMENT_PACK of the capture
11960 spec
= copy_node (spec
);
11961 args
= copy_node (args
);
11962 SET_ARGUMENT_PACK_ARGS (spec
, args
);
11963 register_local_specialization (spec
, *tp
);
11965 TREE_VEC_ELT (args
, i
) = carg
;
11970 if (outer_automatic_var_p (spec
))
11971 spec
= process_outer_var_ref (spec
, complain
);
11972 *extra
= tree_cons (*tp
, spec
, *extra
);
11977 extract_local_specs (tree pattern
, tsubst_flags_t complain
)
11979 el_data
data (complain
);
11980 cp_walk_tree_without_duplicates (&pattern
, extract_locals_r
, &data
);
11984 /* Extract any uses of local_specializations from PATTERN and add them to ARGS
11985 for use in PACK_EXPANSION_EXTRA_ARGS. */
11988 build_extra_args (tree pattern
, tree args
, tsubst_flags_t complain
)
11991 if (local_specializations
)
11992 if (tree locals
= extract_local_specs (pattern
, complain
))
11993 extra
= tree_cons (NULL_TREE
, extra
, locals
);
11997 /* Apply any local specializations from PACK_EXPANSION_EXTRA_ARGS and add the
11998 normal template args to ARGS. */
12001 add_extra_args (tree extra
, tree args
)
12003 if (extra
&& TREE_CODE (extra
) == TREE_LIST
)
12005 for (tree elt
= TREE_CHAIN (extra
); elt
; elt
= TREE_CHAIN (elt
))
12007 /* The partial instantiation involved local declarations collected in
12008 extract_local_specs; map from the general template to our local
12010 tree gen
= TREE_PURPOSE (elt
);
12011 tree inst
= TREE_VALUE (elt
);
12013 if (tree local
= retrieve_local_specialization (inst
))
12015 /* else inst is already a full instantiation of the pack. */
12016 register_local_specialization (inst
, gen
);
12018 gcc_assert (!TREE_PURPOSE (extra
));
12019 extra
= TREE_VALUE (extra
);
12021 return add_to_template_args (extra
, args
);
12024 /* Substitute ARGS into T, which is an pack expansion
12025 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
12026 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
12027 (if only a partial substitution could be performed) or
12028 ERROR_MARK_NODE if there was an error. */
12030 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
12034 tree pack
, packs
= NULL_TREE
;
12035 bool unsubstituted_packs
= false;
12036 bool unsubstituted_fn_pack
= false;
12039 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
12040 bool need_local_specializations
= false;
12043 gcc_assert (PACK_EXPANSION_P (t
));
12044 pattern
= PACK_EXPANSION_PATTERN (t
);
12046 /* Add in any args remembered from an earlier partial instantiation. */
12047 args
= add_extra_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
12049 levels
= TMPL_ARGS_DEPTH (args
);
12051 /* Determine the argument packs that will instantiate the parameter
12052 packs used in the expansion expression. While we're at it,
12053 compute the number of arguments to be expanded and make sure it
12055 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
12056 pack
= TREE_CHAIN (pack
))
12058 tree parm_pack
= TREE_VALUE (pack
);
12059 tree arg_pack
= NULL_TREE
;
12060 tree orig_arg
= NULL_TREE
;
12063 if (TREE_CODE (parm_pack
) == BASES
)
12065 gcc_assert (parm_pack
== pattern
);
12066 if (BASES_DIRECT (parm_pack
))
12067 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
12072 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
12073 args
, complain
, in_decl
,
12076 else if (builtin_pack_call_p (parm_pack
))
12078 if (parm_pack
!= pattern
)
12080 if (complain
& tf_error
)
12081 sorry ("%qE is not the entire pattern of the pack expansion",
12083 return error_mark_node
;
12085 return expand_builtin_pack_call (parm_pack
, args
,
12086 complain
, in_decl
);
12088 else if (TREE_CODE (parm_pack
) == PARM_DECL
)
12090 /* We know we have correct local_specializations if this
12091 expansion is at function scope, or if we're dealing with a
12092 local parameter in a requires expression; for the latter,
12093 tsubst_requires_expr set it up appropriately. */
12094 if (PACK_EXPANSION_LOCAL_P (t
) || CONSTRAINT_VAR_P (parm_pack
))
12095 arg_pack
= retrieve_local_specialization (parm_pack
);
12097 /* We can't rely on local_specializations for a parameter
12098 name used later in a function declaration (such as in a
12099 late-specified return type). Even if it exists, it might
12100 have the wrong value for a recursive call. */
12101 need_local_specializations
= true;
12105 /* This parameter pack was used in an unevaluated context. Just
12106 make a dummy decl, since it's only used for its type. */
12107 ++cp_unevaluated_operand
;
12108 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
12109 --cp_unevaluated_operand
;
12110 if (arg_pack
&& DECL_PACK_P (arg_pack
))
12111 /* Partial instantiation of the parm_pack, we can't build
12112 up an argument pack yet. */
12113 arg_pack
= NULL_TREE
;
12115 arg_pack
= make_fnparm_pack (arg_pack
);
12117 else if (argument_pack_element_is_expansion_p (arg_pack
, 0))
12118 /* This argument pack isn't fully instantiated yet. We set this
12119 flag rather than clear arg_pack because we do want to do the
12120 optimization below, and we don't want to substitute directly
12121 into the pattern (as that would expose a NONTYPE_ARGUMENT_PACK
12122 where it isn't expected). */
12123 unsubstituted_fn_pack
= true;
12125 else if (is_normal_capture_proxy (parm_pack
))
12127 arg_pack
= retrieve_local_specialization (parm_pack
);
12128 if (argument_pack_element_is_expansion_p (arg_pack
, 0))
12129 unsubstituted_fn_pack
= true;
12134 template_parm_level_and_index (parm_pack
, &level
, &idx
);
12136 if (level
<= levels
)
12137 arg_pack
= TMPL_ARG (args
, level
, idx
);
12140 orig_arg
= arg_pack
;
12141 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
12142 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
12144 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
12145 /* This can only happen if we forget to expand an argument
12146 pack somewhere else. Just return an error, silently. */
12148 result
= make_tree_vec (1);
12149 TREE_VEC_ELT (result
, 0) = error_mark_node
;
12156 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
12158 /* Don't bother trying to do a partial substitution with
12159 incomplete packs; we'll try again after deduction. */
12160 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
12165 else if (len
!= my_len
12166 && !unsubstituted_fn_pack
)
12168 if (!(complain
& tf_error
))
12169 /* Fail quietly. */;
12170 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
12171 error ("mismatched argument pack lengths while expanding %qT",
12174 error ("mismatched argument pack lengths while expanding %qE",
12176 return error_mark_node
;
12179 /* Keep track of the parameter packs and their corresponding
12181 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
12182 TREE_TYPE (packs
) = orig_arg
;
12186 /* We can't substitute for this parameter pack. We use a flag as
12187 well as the missing_level counter because function parameter
12188 packs don't have a level. */
12189 gcc_assert (processing_template_decl
|| is_auto (parm_pack
));
12190 unsubstituted_packs
= true;
12194 /* If the expansion is just T..., return the matching argument pack, unless
12195 we need to call convert_from_reference on all the elements. This is an
12196 important optimization; see c++/68422. */
12197 if (!unsubstituted_packs
12198 && TREE_PURPOSE (packs
) == pattern
)
12200 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
12202 /* If the argument pack is a single pack expansion, pull it out. */
12203 if (TREE_VEC_LENGTH (args
) == 1
12204 && pack_expansion_args_count (args
))
12205 return TREE_VEC_ELT (args
, 0);
12207 /* Types need no adjustment, nor does sizeof..., and if we still have
12208 some pack expansion args we won't do anything yet. */
12209 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
12210 || PACK_EXPANSION_SIZEOF_P (t
)
12211 || pack_expansion_args_count (args
))
12213 /* Also optimize expression pack expansions if we can tell that the
12214 elements won't have reference type. */
12215 tree type
= TREE_TYPE (pattern
);
12216 if (type
&& !TYPE_REF_P (type
)
12217 && !PACK_EXPANSION_P (type
)
12218 && !WILDCARD_TYPE_P (type
))
12220 /* Otherwise use the normal path so we get convert_from_reference. */
12223 /* We cannot expand this expansion expression, because we don't have
12224 all of the argument packs we need. */
12225 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
12227 /* We got some full packs, but we can't substitute them in until we
12228 have values for all the packs. So remember these until then. */
12230 t
= make_pack_expansion (pattern
, complain
);
12231 PACK_EXPANSION_EXTRA_ARGS (t
)
12232 = build_extra_args (pattern
, args
, complain
);
12235 else if (unsubstituted_packs
)
12237 /* There were no real arguments, we're just replacing a parameter
12238 pack with another version of itself. Substitute into the
12239 pattern and return a PACK_EXPANSION_*. The caller will need to
12241 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
12242 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
12243 /*integral_constant_expression_p=*/false);
12245 t
= tsubst (pattern
, args
, complain
, in_decl
);
12246 t
= make_pack_expansion (t
, complain
);
12250 gcc_assert (len
>= 0);
12252 if (need_local_specializations
)
12254 /* We're in a late-specified return type, so create our own local
12255 specializations map; the current map is either NULL or (in the
12256 case of recursive unification) might have bindings that we don't
12257 want to use or alter. */
12258 saved_local_specializations
= local_specializations
;
12259 local_specializations
= new hash_map
<tree
, tree
>;
12262 /* For each argument in each argument pack, substitute into the
12264 result
= make_tree_vec (len
);
12265 tree elem_args
= copy_template_args (args
);
12266 for (i
= 0; i
< len
; ++i
)
12268 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
12270 elem_args
, complain
,
12272 TREE_VEC_ELT (result
, i
) = t
;
12273 if (t
== error_mark_node
)
12275 result
= error_mark_node
;
12280 /* Update ARGS to restore the substitution from parameter packs to
12281 their argument packs. */
12282 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12284 tree parm
= TREE_PURPOSE (pack
);
12286 if (TREE_CODE (parm
) == PARM_DECL
12288 || TREE_CODE (parm
) == FIELD_DECL
)
12289 register_local_specialization (TREE_TYPE (pack
), parm
);
12294 if (TREE_VALUE (pack
) == NULL_TREE
)
12297 template_parm_level_and_index (parm
, &level
, &idx
);
12299 /* Update the corresponding argument. */
12300 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
12301 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
12304 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
12308 if (need_local_specializations
)
12310 delete local_specializations
;
12311 local_specializations
= saved_local_specializations
;
12314 /* If the dependent pack arguments were such that we end up with only a
12315 single pack expansion again, there's no need to keep it in a TREE_VEC. */
12316 if (len
== 1 && TREE_CODE (result
) == TREE_VEC
12317 && PACK_EXPANSION_P (TREE_VEC_ELT (result
, 0)))
12318 return TREE_VEC_ELT (result
, 0);
12323 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
12324 TMPL. We do this using DECL_PARM_INDEX, which should work even with
12325 parameter packs; all parms generated from a function parameter pack will
12326 have the same DECL_PARM_INDEX. */
12329 get_pattern_parm (tree parm
, tree tmpl
)
12331 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
12334 if (DECL_ARTIFICIAL (parm
))
12336 for (patparm
= DECL_ARGUMENTS (pattern
);
12337 patparm
; patparm
= DECL_CHAIN (patparm
))
12338 if (DECL_ARTIFICIAL (patparm
)
12339 && DECL_NAME (parm
) == DECL_NAME (patparm
))
12344 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
12345 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
12346 gcc_assert (DECL_PARM_INDEX (patparm
)
12347 == DECL_PARM_INDEX (parm
));
12353 /* Make an argument pack out of the TREE_VEC VEC. */
12356 make_argument_pack (tree vec
)
12359 tree elt
= TREE_VEC_ELT (vec
, 0);
12361 pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
12364 pack
= make_node (NONTYPE_ARGUMENT_PACK
);
12365 TREE_CONSTANT (pack
) = 1;
12367 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
12371 /* Return an exact copy of template args T that can be modified
12375 copy_template_args (tree t
)
12377 if (t
== error_mark_node
)
12380 int len
= TREE_VEC_LENGTH (t
);
12381 tree new_vec
= make_tree_vec (len
);
12383 for (int i
= 0; i
< len
; ++i
)
12385 tree elt
= TREE_VEC_ELT (t
, i
);
12386 if (elt
&& TREE_CODE (elt
) == TREE_VEC
)
12387 elt
= copy_template_args (elt
);
12388 TREE_VEC_ELT (new_vec
, i
) = elt
;
12391 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_vec
)
12392 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
12397 /* Substitute ARGS into the vector or list of template arguments T. */
12400 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12403 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
12406 if (t
== error_mark_node
)
12407 return error_mark_node
;
12409 len
= TREE_VEC_LENGTH (t
);
12410 elts
= XALLOCAVEC (tree
, len
);
12412 for (i
= 0; i
< len
; i
++)
12414 tree orig_arg
= TREE_VEC_ELT (t
, i
);
12417 if (TREE_CODE (orig_arg
) == TREE_VEC
)
12418 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
12419 else if (PACK_EXPANSION_P (orig_arg
))
12421 /* Substitute into an expansion expression. */
12422 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
12424 if (TREE_CODE (new_arg
) == TREE_VEC
)
12425 /* Add to the expanded length adjustment the number of
12426 expanded arguments. We subtract one from this
12427 measurement, because the argument pack expression
12428 itself is already counted as 1 in
12429 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
12430 the argument pack is empty. */
12431 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
12433 else if (ARGUMENT_PACK_P (orig_arg
))
12435 /* Substitute into each of the arguments. */
12436 new_arg
= TYPE_P (orig_arg
)
12437 ? cxx_make_type (TREE_CODE (orig_arg
))
12438 : make_node (TREE_CODE (orig_arg
));
12440 tree pack_args
= tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
12441 args
, complain
, in_decl
);
12442 if (pack_args
== error_mark_node
)
12443 new_arg
= error_mark_node
;
12445 SET_ARGUMENT_PACK_ARGS (new_arg
, pack_args
);
12447 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
)
12448 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
12451 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
12453 if (new_arg
== error_mark_node
)
12454 return error_mark_node
;
12457 if (new_arg
!= orig_arg
)
12464 /* Make space for the expanded arguments coming from template
12466 t
= make_tree_vec (len
+ expanded_len_adjust
);
12467 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
12468 arguments for a member template.
12469 In that case each TREE_VEC in ORIG_T represents a level of template
12470 arguments, and ORIG_T won't carry any non defaulted argument count.
12471 It will rather be the nested TREE_VECs that will carry one.
12472 In other words, ORIG_T carries a non defaulted argument count only
12473 if it doesn't contain any nested TREE_VEC. */
12474 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
12476 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
12477 count
+= expanded_len_adjust
;
12478 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
12480 for (i
= 0, out
= 0; i
< len
; i
++)
12482 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
12483 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
12484 && TREE_CODE (elts
[i
]) == TREE_VEC
)
12488 /* Now expand the template argument pack "in place". */
12489 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
12490 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
12494 TREE_VEC_ELT (t
, out
) = elts
[i
];
12502 /* Substitute ARGS into one level PARMS of template parameters. */
12505 tsubst_template_parms_level (tree parms
, tree args
, tsubst_flags_t complain
)
12507 if (parms
== error_mark_node
)
12508 return error_mark_node
;
12510 tree new_vec
= make_tree_vec (TREE_VEC_LENGTH (parms
));
12512 for (int i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
12514 tree tuple
= TREE_VEC_ELT (parms
, i
);
12516 if (tuple
== error_mark_node
)
12519 TREE_VEC_ELT (new_vec
, i
) =
12520 tsubst_template_parm (tuple
, args
, complain
);
12526 /* Return the result of substituting ARGS into the template parameters
12527 given by PARMS. If there are m levels of ARGS and m + n levels of
12528 PARMS, then the result will contain n levels of PARMS. For
12529 example, if PARMS is `template <class T> template <class U>
12530 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
12531 result will be `template <int*, double, class V>'. */
12534 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
12536 tree r
= NULL_TREE
;
12539 /* When substituting into a template, we must set
12540 PROCESSING_TEMPLATE_DECL as the template parameters may be
12541 dependent if they are based on one-another, and the dependency
12542 predicates are short-circuit outside of templates. */
12543 ++processing_template_decl
;
12545 for (new_parms
= &r
;
12546 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
12547 new_parms
= &(TREE_CHAIN (*new_parms
)),
12548 parms
= TREE_CHAIN (parms
))
12550 tree new_vec
= tsubst_template_parms_level (TREE_VALUE (parms
),
12553 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
12554 - TMPL_ARGS_DEPTH (args
)),
12555 new_vec
, NULL_TREE
);
12558 --processing_template_decl
;
12563 /* Return the result of substituting ARGS into one template parameter
12564 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
12565 parameter and which TREE_PURPOSE is the default argument of the
12566 template parameter. */
12569 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
12571 tree default_value
, parm_decl
;
12573 if (args
== NULL_TREE
12575 || t
== error_mark_node
)
12578 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
12580 default_value
= TREE_PURPOSE (t
);
12581 parm_decl
= TREE_VALUE (t
);
12583 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
12584 if (TREE_CODE (parm_decl
) == PARM_DECL
12585 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
12586 parm_decl
= error_mark_node
;
12587 default_value
= tsubst_template_arg (default_value
, args
,
12588 complain
, NULL_TREE
);
12590 return build_tree_list (default_value
, parm_decl
);
12593 /* Substitute the ARGS into the indicated aggregate (or enumeration)
12594 type T. If T is not an aggregate or enumeration type, it is
12595 handled as if by tsubst. IN_DECL is as for tsubst. If
12596 ENTERING_SCOPE is nonzero, T is the context for a template which
12597 we are presently tsubst'ing. Return the substituted value. */
12600 tsubst_aggr_type (tree t
,
12602 tsubst_flags_t complain
,
12604 int entering_scope
)
12606 if (t
== NULL_TREE
)
12609 switch (TREE_CODE (t
))
12612 if (TYPE_PTRMEMFUNC_P (t
))
12613 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
12615 /* Fall through. */
12616 case ENUMERAL_TYPE
:
12618 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
12623 int saved_unevaluated_operand
;
12624 int saved_inhibit_evaluation_warnings
;
12626 /* In "sizeof(X<I>)" we need to evaluate "I". */
12627 saved_unevaluated_operand
= cp_unevaluated_operand
;
12628 cp_unevaluated_operand
= 0;
12629 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
12630 c_inhibit_evaluation_warnings
= 0;
12632 /* First, determine the context for the type we are looking
12634 context
= TYPE_CONTEXT (t
);
12635 if (context
&& TYPE_P (context
))
12637 context
= tsubst_aggr_type (context
, args
, complain
,
12638 in_decl
, /*entering_scope=*/1);
12639 /* If context is a nested class inside a class template,
12640 it may still need to be instantiated (c++/33959). */
12641 context
= complete_type (context
);
12644 /* Then, figure out what arguments are appropriate for the
12645 type we are trying to find. For example, given:
12647 template <class T> struct S;
12648 template <class T, class U> void f(T, U) { S<U> su; }
12650 and supposing that we are instantiating f<int, double>,
12651 then our ARGS will be {int, double}, but, when looking up
12652 S we only want {double}. */
12653 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
12654 complain
, in_decl
);
12655 if (argvec
== error_mark_node
)
12656 r
= error_mark_node
;
12659 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
12660 entering_scope
, complain
);
12661 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12664 cp_unevaluated_operand
= saved_unevaluated_operand
;
12665 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
12670 /* This is not a template type, so there's nothing to do. */
12674 return tsubst (t
, args
, complain
, in_decl
);
12678 static GTY((cache
)) tree_cache_map
*defarg_inst
;
12680 /* Substitute into the default argument ARG (a default argument for
12681 FN), which has the indicated TYPE. */
12684 tsubst_default_argument (tree fn
, int parmnum
, tree type
, tree arg
,
12685 tsubst_flags_t complain
)
12687 int errs
= errorcount
+ sorrycount
;
12689 /* This can happen in invalid code. */
12690 if (TREE_CODE (arg
) == DEFAULT_ARG
)
12693 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
12694 parm
= chain_index (parmnum
, parm
);
12695 tree parmtype
= TREE_TYPE (parm
);
12696 if (DECL_BY_REFERENCE (parm
))
12697 parmtype
= TREE_TYPE (parmtype
);
12698 if (parmtype
== error_mark_node
)
12699 return error_mark_node
;
12701 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, parmtype
));
12704 if (defarg_inst
&& (slot
= defarg_inst
->get (parm
)))
12707 /* This default argument came from a template. Instantiate the
12708 default argument here, not in tsubst. In the case of
12717 we must be careful to do name lookup in the scope of S<T>,
12718 rather than in the current class. */
12719 push_to_top_level ();
12720 push_access_scope (fn
);
12721 start_lambda_scope (parm
);
12723 /* The default argument expression may cause implicitly defined
12724 member functions to be synthesized, which will result in garbage
12725 collection. We must treat this situation as if we were within
12726 the body of function so as to avoid collecting live data on the
12729 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
12730 complain
, NULL_TREE
,
12731 /*integral_constant_expression_p=*/false);
12734 finish_lambda_scope ();
12736 if (errorcount
+sorrycount
> errs
12737 && (complain
& tf_warning_or_error
))
12738 inform (input_location
,
12739 " when instantiating default argument for call to %qD", fn
);
12741 /* Make sure the default argument is reasonable. */
12742 arg
= check_default_argument (type
, arg
, complain
);
12744 pop_access_scope (fn
);
12745 pop_from_top_level ();
12747 if (arg
!= error_mark_node
&& !cp_unevaluated_operand
)
12750 defarg_inst
= tree_cache_map::create_ggc (37);
12751 defarg_inst
->put (parm
, arg
);
12757 /* Substitute into all the default arguments for FN. */
12760 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
12765 tmpl_args
= DECL_TI_ARGS (fn
);
12767 /* If this function is not yet instantiated, we certainly don't need
12768 its default arguments. */
12769 if (uses_template_parms (tmpl_args
))
12771 /* Don't do this again for clones. */
12772 if (DECL_CLONED_FUNCTION_P (fn
))
12776 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
12778 arg
= TREE_CHAIN (arg
), ++i
)
12779 if (TREE_PURPOSE (arg
))
12780 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
, i
,
12782 TREE_PURPOSE (arg
),
12786 /* Subroutine of tsubst_decl for the case when T is a FUNCTION_DECL. */
12789 tsubst_function_decl (tree t
, tree args
, tsubst_flags_t complain
,
12790 tree lambda_fntype
)
12792 tree gen_tmpl
, argvec
;
12793 hashval_t hash
= 0;
12796 /* Nobody should be tsubst'ing into non-template functions. */
12797 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
12799 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
12801 /* If T is not dependent, just return it. */
12802 if (!uses_template_parms (DECL_TI_ARGS (t
)))
12805 /* Calculate the most general template of which R is a
12807 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
12809 /* We're substituting a lambda function under tsubst_lambda_expr but not
12810 directly from it; find the matching function we're already inside.
12811 But don't do this if T is a generic lambda with a single level of
12812 template parms, as in that case we're doing a normal instantiation. */
12813 if (LAMBDA_FUNCTION_P (t
) && !lambda_fntype
12814 && (!generic_lambda_fn_p (t
)
12815 || TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
)) > 1))
12816 return enclosing_instantiation_of (t
);
12818 /* Calculate the complete set of arguments used to
12820 argvec
= tsubst_template_args (DECL_TI_ARGS
12821 (DECL_TEMPLATE_RESULT
12822 (DECL_TI_TEMPLATE (t
))),
12823 args
, complain
, in_decl
);
12824 if (argvec
== error_mark_node
)
12825 return error_mark_node
;
12827 /* Check to see if we already have this specialization. */
12828 if (!lambda_fntype
)
12830 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
12831 if (tree spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
))
12835 /* We can see more levels of arguments than parameters if
12836 there was a specialization of a member template, like
12839 template <class T> struct S { template <class U> void f(); }
12840 template <> template <class U> void S<int>::f(U);
12842 Here, we'll be substituting into the specialization,
12843 because that's where we can find the code we actually
12844 want to generate, but we'll have enough arguments for
12845 the most general template.
12847 We also deal with the peculiar case:
12849 template <class T> struct S {
12850 template <class U> friend void f();
12852 template <class U> void f() {}
12854 template void f<double>();
12856 Here, the ARGS for the instantiation of will be {int,
12857 double}. But, we only need as many ARGS as there are
12858 levels of template parameters in CODE_PATTERN. We are
12859 careful not to get fooled into reducing the ARGS in
12862 template <class T> struct S { template <class U> void f(U); }
12863 template <class T> template <> void S<T>::f(int) {}
12865 which we can spot because the pattern will be a
12866 specialization in this case. */
12867 int args_depth
= TMPL_ARGS_DEPTH (args
);
12869 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
12871 if (args_depth
> parms_depth
&& !DECL_TEMPLATE_SPECIALIZATION (t
))
12872 args
= get_innermost_template_args (args
, parms_depth
);
12876 /* This special case arises when we have something like this:
12878 template <class T> struct S {
12879 friend void f<int>(int, double);
12882 Here, the DECL_TI_TEMPLATE for the friend declaration
12883 will be an IDENTIFIER_NODE. We are being called from
12884 tsubst_friend_function, and we want only to create a
12885 new decl (R) with appropriate types so that we can call
12886 determine_specialization. */
12887 gen_tmpl
= NULL_TREE
;
12888 argvec
= NULL_TREE
;
12891 tree closure
= (lambda_fntype
? TYPE_METHOD_BASETYPE (lambda_fntype
)
12893 tree ctx
= closure
? closure
: DECL_CONTEXT (t
);
12894 bool member
= ctx
&& TYPE_P (ctx
);
12896 if (member
&& !closure
)
12897 ctx
= tsubst_aggr_type (ctx
, args
,
12898 complain
, t
, /*entering_scope=*/1);
12900 tree type
= (lambda_fntype
? lambda_fntype
12901 : tsubst (TREE_TYPE (t
), args
,
12902 complain
| tf_fndecl_type
, in_decl
));
12903 if (type
== error_mark_node
)
12904 return error_mark_node
;
12906 /* If we hit excessive deduction depth, the type is bogus even if
12907 it isn't error_mark_node, so don't build a decl. */
12908 if (excessive_deduction_depth
)
12909 return error_mark_node
;
12911 /* We do NOT check for matching decls pushed separately at this
12912 point, as they may not represent instantiations of this
12913 template, and in any case are considered separate under the
12915 tree r
= copy_decl (t
);
12916 DECL_USE_TEMPLATE (r
) = 0;
12917 TREE_TYPE (r
) = type
;
12918 /* Clear out the mangled name and RTL for the instantiation. */
12919 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
12920 SET_DECL_RTL (r
, NULL
);
12921 /* Leave DECL_INITIAL set on deleted instantiations. */
12922 if (!DECL_DELETED_FN (r
))
12923 DECL_INITIAL (r
) = NULL_TREE
;
12924 DECL_CONTEXT (r
) = ctx
;
12926 /* OpenMP UDRs have the only argument a reference to the declared
12927 type. We want to diagnose if the declared type is a reference,
12928 which is invalid, but as references to references are usually
12929 quietly merged, diagnose it here. */
12930 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
12933 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
12934 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
12935 if (TYPE_REF_P (argtype
))
12936 error_at (DECL_SOURCE_LOCATION (t
),
12937 "reference type %qT in "
12938 "%<#pragma omp declare reduction%>", argtype
);
12939 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
12940 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
12944 if (member
&& DECL_CONV_FN_P (r
))
12945 /* Type-conversion operator. Reconstruct the name, in
12946 case it's the name of one of the template's parameters. */
12947 DECL_NAME (r
) = make_conv_op_name (TREE_TYPE (type
));
12949 tree parms
= DECL_ARGUMENTS (t
);
12951 parms
= DECL_CHAIN (parms
);
12952 parms
= tsubst (parms
, args
, complain
, t
);
12953 for (tree parm
= parms
; parm
; parm
= DECL_CHAIN (parm
))
12954 DECL_CONTEXT (parm
) = r
;
12957 tree tparm
= build_this_parm (r
, closure
, type_memfn_quals (type
));
12958 DECL_CHAIN (tparm
) = parms
;
12961 DECL_ARGUMENTS (r
) = parms
;
12962 DECL_RESULT (r
) = NULL_TREE
;
12964 TREE_STATIC (r
) = 0;
12965 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
12966 DECL_EXTERNAL (r
) = 1;
12967 /* If this is an instantiation of a function with internal
12968 linkage, we already know what object file linkage will be
12969 assigned to the instantiation. */
12970 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
12971 DECL_DEFER_OUTPUT (r
) = 0;
12972 DECL_CHAIN (r
) = NULL_TREE
;
12973 DECL_PENDING_INLINE_INFO (r
) = 0;
12974 DECL_PENDING_INLINE_P (r
) = 0;
12975 DECL_SAVED_TREE (r
) = NULL_TREE
;
12976 DECL_STRUCT_FUNCTION (r
) = NULL
;
12978 /* We'll re-clone as appropriate in instantiate_template. */
12979 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
12981 /* If we aren't complaining now, return on error before we register
12982 the specialization so that we'll complain eventually. */
12983 if ((complain
& tf_error
) == 0
12984 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
12985 && !grok_op_properties (r
, /*complain=*/false))
12986 return error_mark_node
;
12988 /* When instantiating a constrained member, substitute
12989 into the constraints to create a new constraint. */
12990 if (tree ci
= get_constraints (t
))
12993 ci
= tsubst_constraint_info (ci
, argvec
, complain
, NULL_TREE
);
12994 set_constraints (r
, ci
);
12997 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
12998 this in the special friend case mentioned above where
12999 GEN_TMPL is NULL. */
13000 if (gen_tmpl
&& !closure
)
13002 DECL_TEMPLATE_INFO (r
)
13003 = build_template_info (gen_tmpl
, argvec
);
13004 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13007 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
13009 /* We instantiated this while substituting into
13010 the type earlier (template/friend54.C). */
13013 /* We're not supposed to instantiate default arguments
13014 until they are called, for a template. But, for a
13017 template <class T> void f ()
13018 { extern void g(int i = T()); }
13020 we should do the substitution when the template is
13021 instantiated. We handle the member function case in
13022 instantiate_class_template since the default arguments
13023 might refer to other members of the class. */
13025 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
13026 && !uses_template_parms (argvec
))
13027 tsubst_default_arguments (r
, complain
);
13030 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13032 /* Copy the list of befriending classes. */
13033 for (tree
*friends
= &DECL_BEFRIENDING_CLASSES (r
);
13035 friends
= &TREE_CHAIN (*friends
))
13037 *friends
= copy_node (*friends
);
13038 TREE_VALUE (*friends
)
13039 = tsubst (TREE_VALUE (*friends
), args
, complain
, in_decl
);
13042 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
13044 maybe_retrofit_in_chrg (r
);
13045 if (DECL_CONSTRUCTOR_P (r
) && !grok_ctor_properties (ctx
, r
))
13046 return error_mark_node
;
13047 /* If this is an instantiation of a member template, clone it.
13048 If it isn't, that'll be handled by
13049 clone_constructors_and_destructors. */
13050 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
13051 clone_function_decl (r
, /*update_methods=*/false);
13053 else if ((complain
& tf_error
) != 0
13054 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
13055 && !grok_op_properties (r
, /*complain=*/true))
13056 return error_mark_node
;
13058 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
13059 SET_DECL_FRIEND_CONTEXT (r
,
13060 tsubst (DECL_FRIEND_CONTEXT (t
),
13061 args
, complain
, in_decl
));
13063 /* Possibly limit visibility based on template args. */
13064 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
13065 if (DECL_VISIBILITY_SPECIFIED (t
))
13067 DECL_VISIBILITY_SPECIFIED (r
) = 0;
13068 DECL_ATTRIBUTES (r
)
13069 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
13071 determine_visibility (r
);
13072 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
13073 && !processing_template_decl
)
13074 defaulted_late_check (r
);
13076 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
13077 args
, complain
, in_decl
);
13081 /* Subroutine of tsubst_decl for the case when T is a TEMPLATE_DECL. */
13084 tsubst_template_decl (tree t
, tree args
, tsubst_flags_t complain
,
13085 tree lambda_fntype
)
13087 /* We can get here when processing a member function template,
13088 member class template, or template template parameter. */
13089 tree decl
= DECL_TEMPLATE_RESULT (t
);
13095 hashval_t hash
= 0;
13097 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
13099 /* Template template parameter is treated here. */
13100 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13101 if (new_type
== error_mark_node
)
13102 r
= error_mark_node
;
13103 /* If we get a real template back, return it. This can happen in
13104 the context of most_specialized_partial_spec. */
13105 else if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
13108 /* The new TEMPLATE_DECL was built in
13109 reduce_template_parm_level. */
13110 r
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (new_type
);
13114 if (!lambda_fntype
)
13116 /* We might already have an instance of this template.
13117 The ARGS are for the surrounding class type, so the
13118 full args contain the tsubst'd args for the context,
13119 plus the innermost args from the template decl. */
13120 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
13121 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
13122 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
13123 /* Because this is a template, the arguments will still be
13124 dependent, even after substitution. If
13125 PROCESSING_TEMPLATE_DECL is not set, the dependency
13126 predicates will short-circuit. */
13127 ++processing_template_decl
;
13128 full_args
= tsubst_template_args (tmpl_args
, args
,
13129 complain
, in_decl
);
13130 --processing_template_decl
;
13131 if (full_args
== error_mark_node
)
13132 return error_mark_node
;
13134 /* If this is a default template template argument,
13135 tsubst might not have changed anything. */
13136 if (full_args
== tmpl_args
)
13139 hash
= hash_tmpl_and_args (t
, full_args
);
13140 spec
= retrieve_specialization (t
, full_args
, hash
);
13141 if (spec
!= NULL_TREE
)
13145 /* Make a new template decl. It will be similar to the
13146 original, but will record the current template arguments.
13147 We also create a new function declaration, which is just
13148 like the old one, but points to this new template, rather
13149 than the old one. */
13151 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
13152 DECL_CHAIN (r
) = NULL_TREE
;
13154 // Build new template info linking to the original template decl.
13155 if (!lambda_fntype
)
13157 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
13158 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13161 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13163 /* The template parameters for this new template are all the
13164 template parameters for the old template, except the
13165 outermost level of parameters. */
13166 DECL_TEMPLATE_PARMS (r
)
13167 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
13170 if (TREE_CODE (decl
) == TYPE_DECL
13171 && !TYPE_DECL_ALIAS_P (decl
))
13174 ++processing_template_decl
;
13175 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13176 --processing_template_decl
;
13177 if (new_type
== error_mark_node
)
13178 return error_mark_node
;
13180 TREE_TYPE (r
) = new_type
;
13181 /* For a partial specialization, we need to keep pointing to
13182 the primary template. */
13183 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
13184 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
13185 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
13186 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
13187 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
13192 ++processing_template_decl
;
13193 if (TREE_CODE (decl
) == FUNCTION_DECL
)
13194 new_decl
= tsubst_function_decl (decl
, args
, complain
, lambda_fntype
);
13196 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
13197 --processing_template_decl
;
13198 if (new_decl
== error_mark_node
)
13199 return error_mark_node
;
13201 DECL_TEMPLATE_RESULT (r
) = new_decl
;
13202 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
13203 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
13206 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (r
));
13207 DECL_TEMPLATE_INFO (new_decl
) = build_template_info (r
, args
);
13211 DECL_TI_TEMPLATE (new_decl
) = r
;
13212 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
13216 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
13217 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
13219 if (PRIMARY_TEMPLATE_P (t
))
13220 DECL_PRIMARY_TEMPLATE (r
) = r
;
13222 if (TREE_CODE (decl
) != TYPE_DECL
&& !VAR_P (decl
)
13224 /* Record this non-type partial instantiation. */
13225 register_specialization (r
, t
,
13226 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
13232 /* True if FN is the op() for a lambda in an uninstantiated template. */
13235 lambda_fn_in_template_p (tree fn
)
13237 if (!fn
|| !LAMBDA_FUNCTION_P (fn
))
13239 tree closure
= DECL_CONTEXT (fn
);
13240 return CLASSTYPE_TEMPLATE_INFO (closure
) != NULL_TREE
;
13243 /* We're instantiating a variable from template function TCTX. Return the
13244 corresponding current enclosing scope. This gets complicated because lambda
13245 functions in templates are regenerated rather than instantiated, but generic
13246 lambda functions are subsequently instantiated. */
13249 enclosing_instantiation_of (tree otctx
)
13252 tree fn
= current_function_decl
;
13253 int lambda_count
= 0;
13255 for (; tctx
&& lambda_fn_in_template_p (tctx
);
13256 tctx
= decl_function_context (tctx
))
13258 for (; fn
; fn
= decl_function_context (fn
))
13261 int flambda_count
= 0;
13262 for (; flambda_count
< lambda_count
&& fn
&& LAMBDA_FUNCTION_P (fn
);
13263 fn
= decl_function_context (fn
))
13265 if ((fn
&& DECL_TEMPLATE_INFO (fn
))
13266 ? most_general_template (fn
) != most_general_template (tctx
)
13269 gcc_assert (DECL_NAME (ofn
) == DECL_NAME (otctx
)
13270 || DECL_CONV_FN_P (ofn
));
13273 gcc_unreachable ();
13276 /* Substitute the ARGS into the T, which is a _DECL. Return the
13277 result of the substitution. Issue error and warning messages under
13278 control of COMPLAIN. */
13281 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
13283 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13284 location_t saved_loc
;
13285 tree r
= NULL_TREE
;
13287 hashval_t hash
= 0;
13289 /* Set the filename and linenumber to improve error-reporting. */
13290 saved_loc
= input_location
;
13291 input_location
= DECL_SOURCE_LOCATION (t
);
13293 switch (TREE_CODE (t
))
13295 case TEMPLATE_DECL
:
13296 r
= tsubst_template_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
13299 case FUNCTION_DECL
:
13300 r
= tsubst_function_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
13305 tree type
= NULL_TREE
;
13307 tree expanded_types
= NULL_TREE
;
13308 tree prev_r
= NULL_TREE
;
13309 tree first_r
= NULL_TREE
;
13311 if (DECL_PACK_P (t
))
13313 /* If there is a local specialization that isn't a
13314 parameter pack, it means that we're doing a "simple"
13315 substitution from inside tsubst_pack_expansion. Just
13316 return the local specialization (which will be a single
13318 tree spec
= retrieve_local_specialization (t
);
13320 && TREE_CODE (spec
) == PARM_DECL
13321 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
13324 /* Expand the TYPE_PACK_EXPANSION that provides the types for
13325 the parameters in this function parameter pack. */
13326 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
13327 complain
, in_decl
);
13328 if (TREE_CODE (expanded_types
) == TREE_VEC
)
13330 len
= TREE_VEC_LENGTH (expanded_types
);
13332 /* Zero-length parameter packs are boring. Just substitute
13335 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
13340 /* All we did was update the type. Make a note of that. */
13341 type
= expanded_types
;
13342 expanded_types
= NULL_TREE
;
13346 /* Loop through all of the parameters we'll build. When T is
13347 a function parameter pack, LEN is the number of expanded
13348 types in EXPANDED_TYPES; otherwise, LEN is 1. */
13350 for (i
= 0; i
< len
; ++i
)
13354 if (DECL_TEMPLATE_PARM_P (t
))
13355 SET_DECL_TEMPLATE_PARM_P (r
);
13357 if (expanded_types
)
13358 /* We're on the Ith parameter of the function parameter
13361 /* Get the Ith type. */
13362 type
= TREE_VEC_ELT (expanded_types
, i
);
13364 /* Rename the parameter to include the index. */
13366 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
13369 /* We're dealing with a normal parameter. */
13370 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13372 type
= type_decays_to (type
);
13373 TREE_TYPE (r
) = type
;
13374 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13376 if (DECL_INITIAL (r
))
13378 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
13379 DECL_INITIAL (r
) = TREE_TYPE (r
);
13381 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
13382 complain
, in_decl
);
13385 DECL_CONTEXT (r
) = NULL_TREE
;
13387 if (!DECL_TEMPLATE_PARM_P (r
))
13388 DECL_ARG_TYPE (r
) = type_passed_as (type
);
13390 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
13391 args
, complain
, in_decl
);
13393 /* Keep track of the first new parameter we
13394 generate. That's what will be returned to the
13399 /* Build a proper chain of parameters when substituting
13400 into a function parameter pack. */
13402 DECL_CHAIN (prev_r
) = r
;
13405 /* If cp_unevaluated_operand is set, we're just looking for a
13406 single dummy parameter, so don't keep going. */
13407 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
13408 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
13409 complain
, DECL_CHAIN (t
));
13411 /* FIRST_R contains the start of the chain we've built. */
13418 tree type
= NULL_TREE
;
13419 tree vec
= NULL_TREE
;
13420 tree expanded_types
= NULL_TREE
;
13423 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
13425 /* This field is a lambda capture pack. Return a TREE_VEC of
13426 the expanded fields to instantiate_class_template_1. */
13427 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
13428 complain
, in_decl
);
13429 if (TREE_CODE (expanded_types
) == TREE_VEC
)
13431 len
= TREE_VEC_LENGTH (expanded_types
);
13432 vec
= make_tree_vec (len
);
13436 /* All we did was update the type. Make a note of that. */
13437 type
= expanded_types
;
13438 expanded_types
= NULL_TREE
;
13442 for (int i
= 0; i
< len
; ++i
)
13445 if (expanded_types
)
13447 type
= TREE_VEC_ELT (expanded_types
, i
);
13449 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
13452 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13454 if (type
== error_mark_node
)
13455 RETURN (error_mark_node
);
13456 TREE_TYPE (r
) = type
;
13457 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13459 if (DECL_C_BIT_FIELD (r
))
13460 /* For bit-fields, DECL_BIT_FIELD_REPRESENTATIVE gives the
13462 DECL_BIT_FIELD_REPRESENTATIVE (r
)
13463 = tsubst_expr (DECL_BIT_FIELD_REPRESENTATIVE (t
), args
,
13465 /*integral_constant_expression_p=*/true);
13466 if (DECL_INITIAL (t
))
13468 /* Set up DECL_TEMPLATE_INFO so that we can get at the
13469 NSDMI in perform_member_init. Still set DECL_INITIAL
13470 so that we know there is one. */
13471 DECL_INITIAL (r
) = void_node
;
13472 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
13473 retrofit_lang_decl (r
);
13474 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
13476 /* We don't have to set DECL_CONTEXT here; it is set by
13477 finish_member_declaration. */
13478 DECL_CHAIN (r
) = NULL_TREE
;
13480 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
13481 args
, complain
, in_decl
);
13484 TREE_VEC_ELT (vec
, i
) = r
;
13493 /* We reach here only for member using decls. We also need to check
13494 uses_template_parms because DECL_DEPENDENT_P is not set for a
13495 using-declaration that designates a member of the current
13496 instantiation (c++/53549). */
13497 if (DECL_DEPENDENT_P (t
)
13498 || uses_template_parms (USING_DECL_SCOPE (t
)))
13500 tree scope
= USING_DECL_SCOPE (t
);
13501 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
13502 if (PACK_EXPANSION_P (scope
))
13504 tree vec
= tsubst_pack_expansion (scope
, args
, complain
, in_decl
);
13505 int len
= TREE_VEC_LENGTH (vec
);
13506 r
= make_tree_vec (len
);
13507 for (int i
= 0; i
< len
; ++i
)
13509 tree escope
= TREE_VEC_ELT (vec
, i
);
13510 tree elt
= do_class_using_decl (escope
, name
);
13513 r
= error_mark_node
;
13518 TREE_PROTECTED (elt
) = TREE_PROTECTED (t
);
13519 TREE_PRIVATE (elt
) = TREE_PRIVATE (t
);
13521 TREE_VEC_ELT (r
, i
) = elt
;
13526 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
13527 complain
, in_decl
);
13528 r
= do_class_using_decl (inst_scope
, name
);
13530 r
= error_mark_node
;
13533 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
13534 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
13541 DECL_CHAIN (r
) = NULL_TREE
;
13548 tree argvec
= NULL_TREE
;
13549 tree gen_tmpl
= NULL_TREE
;
13551 tree tmpl
= NULL_TREE
;
13553 tree type
= NULL_TREE
;
13556 if (TREE_TYPE (t
) == error_mark_node
)
13557 RETURN (error_mark_node
);
13559 if (TREE_CODE (t
) == TYPE_DECL
13560 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
13562 /* If this is the canonical decl, we don't have to
13563 mess with instantiations, and often we can't (for
13564 typename, template type parms and such). Note that
13565 TYPE_NAME is not correct for the above test if
13566 we've copied the type for a typedef. */
13567 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13568 if (type
== error_mark_node
)
13569 RETURN (error_mark_node
);
13570 r
= TYPE_NAME (type
);
13574 /* Check to see if we already have the specialization we
13577 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
13579 /* T is a static data member or namespace-scope entity.
13580 We have to substitute into namespace-scope variables
13581 (not just variable templates) because of cases like:
13583 template <class T> void f() { extern T t; }
13585 where the entity referenced is not known until
13586 instantiation time. */
13588 ctx
= DECL_CONTEXT (t
);
13589 if (DECL_CLASS_SCOPE_P (t
))
13591 ctx
= tsubst_aggr_type (ctx
, args
,
13593 in_decl
, /*entering_scope=*/1);
13594 /* If CTX is unchanged, then T is in fact the
13595 specialization we want. That situation occurs when
13596 referencing a static data member within in its own
13597 class. We can use pointer equality, rather than
13598 same_type_p, because DECL_CONTEXT is always
13600 if (ctx
== DECL_CONTEXT (t
)
13601 /* ... unless T is a member template; in which
13602 case our caller can be willing to create a
13603 specialization of that template represented
13605 && !(DECL_TI_TEMPLATE (t
)
13606 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
13612 tmpl
= DECL_TI_TEMPLATE (t
);
13613 gen_tmpl
= most_general_template (tmpl
);
13614 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
13615 if (argvec
!= error_mark_node
)
13616 argvec
= (coerce_innermost_template_parms
13617 (DECL_TEMPLATE_PARMS (gen_tmpl
),
13618 argvec
, t
, complain
,
13619 /*all*/true, /*defarg*/true));
13620 if (argvec
== error_mark_node
)
13621 RETURN (error_mark_node
);
13622 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
13623 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
13628 /* A local variable. */
13630 /* Subsequent calls to pushdecl will fill this in. */
13632 /* Unless this is a reference to a static variable from an
13633 enclosing function, in which case we need to fill it in now. */
13634 if (TREE_STATIC (t
))
13636 tree fn
= enclosing_instantiation_of (DECL_CONTEXT (t
));
13637 if (fn
!= current_function_decl
)
13640 spec
= retrieve_local_specialization (t
);
13642 /* If we already have the specialization we need, there is
13643 nothing more to do. */
13650 /* Create a new node for the specialization we need. */
13651 if (type
== NULL_TREE
)
13653 if (is_typedef_decl (t
))
13654 type
= DECL_ORIGINAL_TYPE (t
);
13656 type
= TREE_TYPE (t
);
13658 && VAR_HAD_UNKNOWN_BOUND (t
)
13659 && type
!= error_mark_node
)
13660 type
= strip_array_domain (type
);
13661 tree sub_args
= args
;
13662 if (tree auto_node
= type_uses_auto (type
))
13664 /* Mask off any template args past the variable's context so we
13665 don't replace the auto with an unrelated argument. */
13666 int nouter
= TEMPLATE_TYPE_LEVEL (auto_node
) - 1;
13667 int extra
= TMPL_ARGS_DEPTH (args
) - nouter
;
13669 /* This should never happen with the new lambda instantiation
13670 model, but keep the handling just in case. */
13671 gcc_assert (!CHECKING_P
),
13672 sub_args
= strip_innermost_template_args (args
, extra
);
13674 type
= tsubst (type
, sub_args
, complain
, in_decl
);
13675 /* Substituting the type might have recursively instantiated this
13676 same alias (c++/86171). */
13677 if (gen_tmpl
&& DECL_ALIAS_TEMPLATE_P (gen_tmpl
)
13678 && (spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
)))
13687 DECL_INITIALIZED_P (r
) = 0;
13688 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
13689 if (type
== error_mark_node
)
13690 RETURN (error_mark_node
);
13691 if (TREE_CODE (type
) == FUNCTION_TYPE
)
13693 /* It may seem that this case cannot occur, since:
13698 declares a function, not a variable. However:
13701 template <typename T> void g() { T t; }
13702 template void g<f>();
13704 is an attempt to declare a variable with function
13706 error ("variable %qD has function type",
13707 /* R is not yet sufficiently initialized, so we
13708 just use its name. */
13710 RETURN (error_mark_node
);
13712 type
= complete_type (type
);
13713 /* Wait until cp_finish_decl to set this again, to handle
13714 circular dependency (template/instantiate6.C). */
13715 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
13716 type
= check_var_type (DECL_NAME (r
), type
);
13718 if (DECL_HAS_VALUE_EXPR_P (t
))
13720 tree ve
= DECL_VALUE_EXPR (t
);
13721 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
13722 /*constant_expression_p=*/false);
13723 if (REFERENCE_REF_P (ve
))
13725 gcc_assert (TYPE_REF_P (type
));
13726 ve
= TREE_OPERAND (ve
, 0);
13728 SET_DECL_VALUE_EXPR (r
, ve
);
13730 if (CP_DECL_THREAD_LOCAL_P (r
)
13731 && !processing_template_decl
)
13732 set_decl_tls_model (r
, decl_default_tls_model (r
));
13734 else if (DECL_SELF_REFERENCE_P (t
))
13735 SET_DECL_SELF_REFERENCE_P (r
);
13736 TREE_TYPE (r
) = type
;
13737 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13738 DECL_CONTEXT (r
) = ctx
;
13739 /* Clear out the mangled name and RTL for the instantiation. */
13740 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
13741 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
13742 SET_DECL_RTL (r
, NULL
);
13743 /* The initializer must not be expanded until it is required;
13744 see [temp.inst]. */
13745 DECL_INITIAL (r
) = NULL_TREE
;
13746 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
13749 if (DECL_LANG_SPECIFIC (r
))
13750 SET_DECL_DEPENDENT_INIT_P (r
, false);
13752 SET_DECL_MODE (r
, VOIDmode
);
13754 /* Possibly limit visibility based on template args. */
13755 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
13756 if (DECL_VISIBILITY_SPECIFIED (t
))
13758 DECL_VISIBILITY_SPECIFIED (r
) = 0;
13759 DECL_ATTRIBUTES (r
)
13760 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
13762 determine_visibility (r
);
13767 /* A static data member declaration is always marked
13768 external when it is declared in-class, even if an
13769 initializer is present. We mimic the non-template
13770 processing here. */
13771 DECL_EXTERNAL (r
) = 1;
13772 if (DECL_NAMESPACE_SCOPE_P (t
))
13773 DECL_NOT_REALLY_EXTERN (r
) = 1;
13775 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
13776 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13777 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
13781 if (DECL_LANG_SPECIFIC (r
))
13782 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13783 if (!cp_unevaluated_operand
)
13784 register_local_specialization (r
, t
);
13787 DECL_CHAIN (r
) = NULL_TREE
;
13789 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
13791 args
, complain
, in_decl
);
13793 /* Preserve a typedef that names a type. */
13794 if (is_typedef_decl (r
) && type
!= error_mark_node
)
13796 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
13797 set_underlying_type (r
);
13798 if (TYPE_DECL_ALIAS_P (r
))
13799 /* An alias template specialization can be dependent
13800 even if its underlying type is not. */
13801 TYPE_DEPENDENT_P_VALID (TREE_TYPE (r
)) = false;
13804 layout_decl (r
, 0);
13809 gcc_unreachable ();
13814 /* Restore the file and line information. */
13815 input_location
= saved_loc
;
13820 /* Substitute into the ARG_TYPES of a function type.
13821 If END is a TREE_CHAIN, leave it and any following types
13825 tsubst_arg_types (tree arg_types
,
13828 tsubst_flags_t complain
,
13831 tree remaining_arg_types
;
13832 tree type
= NULL_TREE
;
13834 tree expanded_args
= NULL_TREE
;
13837 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
13840 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
13841 args
, end
, complain
, in_decl
);
13842 if (remaining_arg_types
== error_mark_node
)
13843 return error_mark_node
;
13845 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
13847 /* For a pack expansion, perform substitution on the
13848 entire expression. Later on, we'll handle the arguments
13850 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
13851 args
, complain
, in_decl
);
13853 if (TREE_CODE (expanded_args
) == TREE_VEC
)
13854 /* So that we'll spin through the parameters, one by one. */
13855 i
= TREE_VEC_LENGTH (expanded_args
);
13858 /* We only partially substituted into the parameter
13859 pack. Our type is TYPE_PACK_EXPANSION. */
13860 type
= expanded_args
;
13861 expanded_args
= NULL_TREE
;
13869 type
= TREE_VEC_ELT (expanded_args
, i
);
13871 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
13873 if (type
== error_mark_node
)
13874 return error_mark_node
;
13875 if (VOID_TYPE_P (type
))
13877 if (complain
& tf_error
)
13879 error ("invalid parameter type %qT", type
);
13881 error ("in declaration %q+D", in_decl
);
13883 return error_mark_node
;
13886 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
13887 return error_mark_node
;
13889 /* Do array-to-pointer, function-to-pointer conversion, and ignore
13890 top-level qualifiers as required. */
13891 type
= cv_unqualified (type_decays_to (type
));
13893 /* We do not substitute into default arguments here. The standard
13894 mandates that they be instantiated only when needed, which is
13895 done in build_over_call. */
13896 default_arg
= TREE_PURPOSE (arg_types
);
13898 /* Except that we do substitute default arguments under tsubst_lambda_expr,
13899 since the new op() won't have any associated template arguments for us
13900 to refer to later. */
13901 if (lambda_fn_in_template_p (in_decl
))
13902 default_arg
= tsubst_copy_and_build (default_arg
, args
, complain
, in_decl
,
13903 false/*fn*/, false/*constexpr*/);
13905 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
13907 /* We've instantiated a template before its default arguments
13908 have been parsed. This can happen for a nested template
13909 class, and is not an error unless we require the default
13910 argument in a call of this function. */
13911 remaining_arg_types
=
13912 tree_cons (default_arg
, type
, remaining_arg_types
);
13913 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
13916 remaining_arg_types
=
13917 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
13920 return remaining_arg_types
;
13923 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
13924 *not* handle the exception-specification for FNTYPE, because the
13925 initial substitution of explicitly provided template parameters
13926 during argument deduction forbids substitution into the
13927 exception-specification:
13931 All references in the function type of the function template to the
13932 corresponding template parameters are replaced by the specified tem-
13933 plate argument values. If a substitution in a template parameter or
13934 in the function type of the function template results in an invalid
13935 type, type deduction fails. [Note: The equivalent substitution in
13936 exception specifications is done only when the function is instanti-
13937 ated, at which point a program is ill-formed if the substitution
13938 results in an invalid type.] */
13941 tsubst_function_type (tree t
,
13943 tsubst_flags_t complain
,
13947 tree arg_types
= NULL_TREE
;
13950 /* The TYPE_CONTEXT is not used for function/method types. */
13951 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
13953 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
13955 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
13957 if (late_return_type_p
)
13959 /* Substitute the argument types. */
13960 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
13961 complain
, in_decl
);
13962 if (arg_types
== error_mark_node
)
13963 return error_mark_node
;
13965 tree save_ccp
= current_class_ptr
;
13966 tree save_ccr
= current_class_ref
;
13967 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
13968 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
13969 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
13972 /* DR 1207: 'this' is in scope in the trailing return type. */
13973 inject_this_parameter (this_type
, cp_type_quals (this_type
));
13976 /* Substitute the return type. */
13977 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13981 current_class_ptr
= save_ccp
;
13982 current_class_ref
= save_ccr
;
13986 /* Substitute the return type. */
13987 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13989 if (return_type
== error_mark_node
)
13990 return error_mark_node
;
13991 /* DR 486 clarifies that creation of a function type with an
13992 invalid return type is a deduction failure. */
13993 if (TREE_CODE (return_type
) == ARRAY_TYPE
13994 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
13996 if (complain
& tf_error
)
13998 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
13999 error ("function returning an array");
14001 error ("function returning a function");
14003 return error_mark_node
;
14006 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
14007 return error_mark_node
;
14009 if (!late_return_type_p
)
14011 /* Substitute the argument types. */
14012 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
14013 complain
, in_decl
);
14014 if (arg_types
== error_mark_node
)
14015 return error_mark_node
;
14018 /* Construct a new type node and return it. */
14019 if (TREE_CODE (t
) == FUNCTION_TYPE
)
14021 fntype
= build_function_type (return_type
, arg_types
);
14022 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (t
));
14026 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
14027 /* Don't pick up extra function qualifiers from the basetype. */
14028 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
14029 if (! MAYBE_CLASS_TYPE_P (r
))
14033 Type deduction may fail for any of the following
14036 -- Attempting to create "pointer to member of T" when T
14037 is not a class type. */
14038 if (complain
& tf_error
)
14039 error ("creating pointer to member function of non-class type %qT",
14041 return error_mark_node
;
14044 fntype
= build_method_type_directly (r
, return_type
,
14045 TREE_CHAIN (arg_types
));
14047 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
14049 /* See comment above. */
14050 tree raises
= NULL_TREE
;
14051 cp_ref_qualifier rqual
= type_memfn_rqual (t
);
14052 fntype
= build_cp_fntype_variant (fntype
, rqual
, raises
, late_return_type_p
);
14057 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
14058 ARGS into that specification, and return the substituted
14059 specification. If there is no specification, return NULL_TREE. */
14062 tsubst_exception_specification (tree fntype
,
14064 tsubst_flags_t complain
,
14071 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
14072 new_specs
= NULL_TREE
;
14073 if (specs
&& TREE_PURPOSE (specs
))
14075 /* A noexcept-specifier. */
14076 tree expr
= TREE_PURPOSE (specs
);
14077 if (TREE_CODE (expr
) == INTEGER_CST
)
14081 /* Defer instantiation of noexcept-specifiers to avoid
14082 excessive instantiations (c++/49107). */
14083 new_specs
= make_node (DEFERRED_NOEXCEPT
);
14084 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
14086 /* We already partially instantiated this member template,
14087 so combine the new args with the old. */
14088 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
14089 = DEFERRED_NOEXCEPT_PATTERN (expr
);
14090 DEFERRED_NOEXCEPT_ARGS (new_specs
)
14091 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
14095 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
14096 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
14100 new_specs
= tsubst_copy_and_build
14101 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
14102 /*integral_constant_expression_p=*/true);
14103 new_specs
= build_noexcept_spec (new_specs
, complain
);
14107 if (! TREE_VALUE (specs
))
14114 tree expanded_specs
= NULL_TREE
;
14116 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
14118 /* Expand the pack expansion type. */
14119 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
14123 if (expanded_specs
== error_mark_node
)
14124 return error_mark_node
;
14125 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
14126 len
= TREE_VEC_LENGTH (expanded_specs
);
14129 /* We're substituting into a member template, so
14130 we got a TYPE_PACK_EXPANSION back. Add that
14131 expansion and move on. */
14132 gcc_assert (TREE_CODE (expanded_specs
)
14133 == TYPE_PACK_EXPANSION
);
14134 new_specs
= add_exception_specifier (new_specs
,
14137 specs
= TREE_CHAIN (specs
);
14142 for (i
= 0; i
< len
; ++i
)
14144 if (expanded_specs
)
14145 spec
= TREE_VEC_ELT (expanded_specs
, i
);
14147 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
14148 if (spec
== error_mark_node
)
14150 new_specs
= add_exception_specifier (new_specs
, spec
,
14154 specs
= TREE_CHAIN (specs
);
14160 /* Take the tree structure T and replace template parameters used
14161 therein with the argument vector ARGS. IN_DECL is an associated
14162 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
14163 Issue error and warning messages under control of COMPLAIN. Note
14164 that we must be relatively non-tolerant of extensions here, in
14165 order to preserve conformance; if we allow substitutions that
14166 should not be allowed, we may allow argument deductions that should
14167 not succeed, and therefore report ambiguous overload situations
14168 where there are none. In theory, we could allow the substitution,
14169 but indicate that it should have failed, and allow our caller to
14170 make sure that the right thing happens, but we don't try to do this
14173 This function is used for dealing with types, decls and the like;
14174 for expressions, use tsubst_expr or tsubst_copy. */
14177 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14179 enum tree_code code
;
14180 tree type
, r
= NULL_TREE
;
14182 if (t
== NULL_TREE
|| t
== error_mark_node
14183 || t
== integer_type_node
14184 || t
== void_type_node
14185 || t
== char_type_node
14186 || t
== unknown_type_node
14187 || TREE_CODE (t
) == NAMESPACE_DECL
14188 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
14192 return tsubst_decl (t
, args
, complain
);
14194 if (args
== NULL_TREE
)
14197 code
= TREE_CODE (t
);
14199 if (code
== IDENTIFIER_NODE
)
14200 type
= IDENTIFIER_TYPE_VALUE (t
);
14202 type
= TREE_TYPE (t
);
14204 gcc_assert (type
!= unknown_type_node
);
14206 /* Reuse typedefs. We need to do this to handle dependent attributes,
14207 such as attribute aligned. */
14209 && typedef_variant_p (t
))
14211 tree decl
= TYPE_NAME (t
);
14213 if (alias_template_specialization_p (t
))
14215 /* DECL represents an alias template and we want to
14217 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
14218 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
14219 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
14221 else if (DECL_CLASS_SCOPE_P (decl
)
14222 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
14223 && uses_template_parms (DECL_CONTEXT (decl
)))
14225 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
14226 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
14227 r
= retrieve_specialization (tmpl
, gen_args
, 0);
14229 else if (DECL_FUNCTION_SCOPE_P (decl
)
14230 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
14231 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
14232 r
= retrieve_local_specialization (decl
);
14234 /* The typedef is from a non-template context. */
14240 r
= cp_build_qualified_type_real
14241 (r
, cp_type_quals (t
) | cp_type_quals (r
),
14242 complain
| tf_ignore_bad_quals
);
14247 /* We don't have an instantiation yet, so drop the typedef. */
14248 int quals
= cp_type_quals (t
);
14249 t
= DECL_ORIGINAL_TYPE (decl
);
14250 t
= cp_build_qualified_type_real (t
, quals
,
14251 complain
| tf_ignore_bad_quals
);
14255 bool fndecl_type
= (complain
& tf_fndecl_type
);
14256 complain
&= ~tf_fndecl_type
;
14259 && code
!= TYPENAME_TYPE
14260 && code
!= TEMPLATE_TYPE_PARM
14261 && code
!= TEMPLATE_PARM_INDEX
14262 && code
!= IDENTIFIER_NODE
14263 && code
!= FUNCTION_TYPE
14264 && code
!= METHOD_TYPE
)
14265 type
= tsubst (type
, args
, complain
, in_decl
);
14266 if (type
== error_mark_node
)
14267 return error_mark_node
;
14273 case ENUMERAL_TYPE
:
14274 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
14275 /*entering_scope=*/0);
14278 case IDENTIFIER_NODE
:
14289 if (t
== integer_type_node
)
14292 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
14293 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
14297 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
14299 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
14300 /*integral_constant_expression_p=*/false);
14302 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
14304 if (TREE_CODE (max
) == NOP_EXPR
14305 && TREE_SIDE_EFFECTS (omax
)
14306 && !TREE_TYPE (max
))
14307 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
14309 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
14310 with TREE_SIDE_EFFECTS that indicates this is not an integral
14311 constant expression. */
14312 if (processing_template_decl
14313 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
14315 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
14316 TREE_SIDE_EFFECTS (max
) = 1;
14319 return compute_array_index_type (NULL_TREE
, max
, complain
);
14322 case TEMPLATE_TYPE_PARM
:
14323 case TEMPLATE_TEMPLATE_PARM
:
14324 case BOUND_TEMPLATE_TEMPLATE_PARM
:
14325 case TEMPLATE_PARM_INDEX
:
14330 tree arg
= NULL_TREE
;
14332 /* Early in template argument deduction substitution, we don't
14333 want to reduce the level of 'auto', or it will be confused
14334 with a normal template parm in subsequent deduction. */
14335 if (is_auto (t
) && (complain
& tf_partial
))
14340 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
14341 template_parm_level_and_index (t
, &level
, &idx
);
14343 levels
= TMPL_ARGS_DEPTH (args
);
14344 if (level
<= levels
14345 && TREE_VEC_LENGTH (TMPL_ARGS_LEVEL (args
, level
)) > 0)
14347 arg
= TMPL_ARG (args
, level
, idx
);
14349 /* See through ARGUMENT_PACK_SELECT arguments. */
14350 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
14351 arg
= argument_pack_select_arg (arg
);
14354 if (arg
== error_mark_node
)
14355 return error_mark_node
;
14356 else if (arg
!= NULL_TREE
)
14358 if (ARGUMENT_PACK_P (arg
))
14359 /* If ARG is an argument pack, we don't actually want to
14360 perform a substitution here, because substitutions
14361 for argument packs are only done
14362 element-by-element. We can get to this point when
14363 substituting the type of a non-type template
14364 parameter pack, when that type actually contains
14365 template parameter packs from an outer template, e.g.,
14367 template<typename... Types> struct A {
14368 template<Types... Values> struct B { };
14372 if (code
== TEMPLATE_TYPE_PARM
)
14375 gcc_assert (TYPE_P (arg
));
14377 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
14379 return cp_build_qualified_type_real
14380 (arg
, quals
, complain
| tf_ignore_bad_quals
);
14382 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
14384 /* We are processing a type constructed from a
14385 template template parameter. */
14386 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
14387 args
, complain
, in_decl
);
14388 if (argvec
== error_mark_node
)
14389 return error_mark_node
;
14391 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
14392 || TREE_CODE (arg
) == TEMPLATE_DECL
14393 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
14395 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
14396 /* Consider this code:
14398 template <template <class> class Template>
14400 template <class Arg> using Bind = Template<Arg>;
14403 template <template <class> class Template, class Arg>
14404 using Instantiate = Template<Arg>; //#0
14406 template <template <class> class Template,
14409 Instantiate<Internal<Template>::template Bind,
14412 When #1 is parsed, the
14413 BOUND_TEMPLATE_TEMPLATE_PARM representing the
14414 parameter `Template' in #0 matches the
14415 UNBOUND_CLASS_TEMPLATE representing the argument
14416 `Internal<Template>::template Bind'; We then want
14417 to assemble the type `Bind<Argument>' that can't
14418 be fully created right now, because
14419 `Internal<Template>' not being complete, the Bind
14420 template cannot be looked up in that context. So
14421 we need to "store" `Bind<Argument>' for later
14422 when the context of Bind becomes complete. Let's
14423 store that in a TYPENAME_TYPE. */
14424 return make_typename_type (TYPE_CONTEXT (arg
),
14425 build_nt (TEMPLATE_ID_EXPR
,
14426 TYPE_IDENTIFIER (arg
),
14431 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
14432 are resolving nested-types in the signature of a
14433 member function templates. Otherwise ARG is a
14434 TEMPLATE_DECL and is the real template to be
14436 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
14437 arg
= TYPE_NAME (arg
);
14439 r
= lookup_template_class (arg
,
14441 DECL_CONTEXT (arg
),
14442 /*entering_scope=*/0,
14444 return cp_build_qualified_type_real
14445 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
14447 else if (code
== TEMPLATE_TEMPLATE_PARM
)
14450 /* TEMPLATE_PARM_INDEX. */
14451 return convert_from_reference (unshare_expr (arg
));
14455 /* This can happen during the attempted tsubst'ing in
14456 unify. This means that we don't yet have any information
14457 about the template parameter in question. */
14460 /* If we get here, we must have been looking at a parm for a
14461 more deeply nested template. Make a new version of this
14462 template parameter, but with a lower level. */
14465 case TEMPLATE_TYPE_PARM
:
14466 case TEMPLATE_TEMPLATE_PARM
:
14467 case BOUND_TEMPLATE_TEMPLATE_PARM
:
14468 if (cp_type_quals (t
))
14470 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
14471 r
= cp_build_qualified_type_real
14472 (r
, cp_type_quals (t
),
14473 complain
| (code
== TEMPLATE_TYPE_PARM
14474 ? tf_ignore_bad_quals
: 0));
14476 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
14477 && PLACEHOLDER_TYPE_CONSTRAINTS (t
)
14478 && (r
= (TEMPLATE_PARM_DESCENDANTS
14479 (TEMPLATE_TYPE_PARM_INDEX (t
))))
14480 && (r
= TREE_TYPE (r
))
14481 && !PLACEHOLDER_TYPE_CONSTRAINTS (r
))
14482 /* Break infinite recursion when substituting the constraints
14483 of a constrained placeholder. */;
14484 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
14485 && !PLACEHOLDER_TYPE_CONSTRAINTS (t
)
14486 && !CLASS_PLACEHOLDER_TEMPLATE (t
)
14487 && (arg
= TEMPLATE_TYPE_PARM_INDEX (t
),
14488 r
= TEMPLATE_PARM_DESCENDANTS (arg
))
14489 && (TEMPLATE_PARM_LEVEL (r
)
14490 == TEMPLATE_PARM_LEVEL (arg
) - levels
))
14491 /* Cache the simple case of lowering a type parameter. */
14496 TEMPLATE_TYPE_PARM_INDEX (r
)
14497 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
14498 r
, levels
, args
, complain
);
14499 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
14500 TYPE_MAIN_VARIANT (r
) = r
;
14501 TYPE_POINTER_TO (r
) = NULL_TREE
;
14502 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
14504 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
14506 /* Propagate constraints on placeholders. */
14507 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
14508 PLACEHOLDER_TYPE_CONSTRAINTS (r
)
14509 = tsubst_constraint (constr
, args
, complain
, in_decl
);
14510 else if (tree pl
= CLASS_PLACEHOLDER_TEMPLATE (t
))
14512 pl
= tsubst_copy (pl
, args
, complain
, in_decl
);
14513 CLASS_PLACEHOLDER_TEMPLATE (r
) = pl
;
14517 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
14518 /* We have reduced the level of the template
14519 template parameter, but not the levels of its
14520 template parameters, so canonical_type_parameter
14521 will not be able to find the canonical template
14522 template parameter for this level. Thus, we
14523 require structural equality checking to compare
14524 TEMPLATE_TEMPLATE_PARMs. */
14525 SET_TYPE_STRUCTURAL_EQUALITY (r
);
14526 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
14527 SET_TYPE_STRUCTURAL_EQUALITY (r
);
14529 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
14531 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
14533 tree tinfo
= TYPE_TEMPLATE_INFO (t
);
14534 /* We might need to substitute into the types of non-type
14535 template parameters. */
14536 tree tmpl
= tsubst (TI_TEMPLATE (tinfo
), args
,
14537 complain
, in_decl
);
14538 if (tmpl
== error_mark_node
)
14539 return error_mark_node
;
14540 tree argvec
= tsubst (TI_ARGS (tinfo
), args
,
14541 complain
, in_decl
);
14542 if (argvec
== error_mark_node
)
14543 return error_mark_node
;
14545 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
14546 = build_template_info (tmpl
, argvec
);
14551 case TEMPLATE_PARM_INDEX
:
14552 /* OK, now substitute the type of the non-type parameter. We
14553 couldn't do it earlier because it might be an auto parameter,
14554 and we wouldn't need to if we had an argument. */
14555 type
= tsubst (type
, args
, complain
, in_decl
);
14556 if (type
== error_mark_node
)
14557 return error_mark_node
;
14558 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
14562 gcc_unreachable ();
14570 tree purpose
, value
, chain
;
14572 if (t
== void_list_node
)
14575 purpose
= TREE_PURPOSE (t
);
14578 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
14579 if (purpose
== error_mark_node
)
14580 return error_mark_node
;
14582 value
= TREE_VALUE (t
);
14585 value
= tsubst (value
, args
, complain
, in_decl
);
14586 if (value
== error_mark_node
)
14587 return error_mark_node
;
14589 chain
= TREE_CHAIN (t
);
14590 if (chain
&& chain
!= void_type_node
)
14592 chain
= tsubst (chain
, args
, complain
, in_decl
);
14593 if (chain
== error_mark_node
)
14594 return error_mark_node
;
14596 if (purpose
== TREE_PURPOSE (t
)
14597 && value
== TREE_VALUE (t
)
14598 && chain
== TREE_CHAIN (t
))
14600 return hash_tree_cons (purpose
, value
, chain
);
14604 /* We should never be tsubsting a binfo. */
14605 gcc_unreachable ();
14608 /* A vector of template arguments. */
14609 gcc_assert (!type
);
14610 return tsubst_template_args (t
, args
, complain
, in_decl
);
14613 case REFERENCE_TYPE
:
14615 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
14620 Type deduction may fail for any of the following
14623 -- Attempting to create a pointer to reference type.
14624 -- Attempting to create a reference to a reference type or
14625 a reference to void.
14627 Core issue 106 says that creating a reference to a reference
14628 during instantiation is no longer a cause for failure. We
14629 only enforce this check in strict C++98 mode. */
14630 if ((TYPE_REF_P (type
)
14631 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
14632 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
14634 static location_t last_loc
;
14636 /* We keep track of the last time we issued this error
14637 message to avoid spewing a ton of messages during a
14638 single bad template instantiation. */
14639 if (complain
& tf_error
14640 && last_loc
!= input_location
)
14642 if (VOID_TYPE_P (type
))
14643 error ("forming reference to void");
14644 else if (code
== POINTER_TYPE
)
14645 error ("forming pointer to reference type %qT", type
);
14647 error ("forming reference to reference type %qT", type
);
14648 last_loc
= input_location
;
14651 return error_mark_node
;
14653 else if (TREE_CODE (type
) == FUNCTION_TYPE
14654 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
14655 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
14657 if (complain
& tf_error
)
14659 if (code
== POINTER_TYPE
)
14660 error ("forming pointer to qualified function type %qT",
14663 error ("forming reference to qualified function type %qT",
14666 return error_mark_node
;
14668 else if (code
== POINTER_TYPE
)
14670 r
= build_pointer_type (type
);
14671 if (TREE_CODE (type
) == METHOD_TYPE
)
14672 r
= build_ptrmemfunc_type (r
);
14674 else if (TYPE_REF_P (type
))
14675 /* In C++0x, during template argument substitution, when there is an
14676 attempt to create a reference to a reference type, reference
14677 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
14679 "If a template-argument for a template-parameter T names a type
14680 that is a reference to a type A, an attempt to create the type
14681 'lvalue reference to cv T' creates the type 'lvalue reference to
14682 A,' while an attempt to create the type type rvalue reference to
14683 cv T' creates the type T"
14685 r
= cp_build_reference_type
14687 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
14689 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
14690 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
14692 if (r
!= error_mark_node
)
14693 /* Will this ever be needed for TYPE_..._TO values? */
14700 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
14701 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
14705 Type deduction may fail for any of the following
14708 -- Attempting to create "pointer to member of T" when T
14709 is not a class type. */
14710 if (complain
& tf_error
)
14711 error ("creating pointer to member of non-class type %qT", r
);
14712 return error_mark_node
;
14714 if (TYPE_REF_P (type
))
14716 if (complain
& tf_error
)
14717 error ("creating pointer to member reference type %qT", type
);
14718 return error_mark_node
;
14720 if (VOID_TYPE_P (type
))
14722 if (complain
& tf_error
)
14723 error ("creating pointer to member of type void");
14724 return error_mark_node
;
14726 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
14727 if (TREE_CODE (type
) == FUNCTION_TYPE
)
14729 /* The type of the implicit object parameter gets its
14730 cv-qualifiers from the FUNCTION_TYPE. */
14733 = build_memfn_type (type
, r
, type_memfn_quals (type
),
14734 type_memfn_rqual (type
));
14735 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
14736 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
14740 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
14744 case FUNCTION_TYPE
:
14749 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
14750 if (fntype
== error_mark_node
)
14751 return error_mark_node
;
14753 /* Substitute the exception specification. */
14754 specs
= tsubst_exception_specification (t
, args
, complain
, in_decl
,
14755 /*defer_ok*/fndecl_type
);
14756 if (specs
== error_mark_node
)
14757 return error_mark_node
;
14759 fntype
= build_exception_variant (fntype
, specs
);
14764 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
14765 if (domain
== error_mark_node
)
14766 return error_mark_node
;
14768 /* As an optimization, we avoid regenerating the array type if
14769 it will obviously be the same as T. */
14770 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
14773 /* These checks should match the ones in create_array_type_for_decl.
14777 The deduction may fail for any of the following reasons:
14779 -- Attempting to create an array with an element type that
14780 is void, a function type, or a reference type, or [DR337]
14781 an abstract class type. */
14782 if (VOID_TYPE_P (type
)
14783 || TREE_CODE (type
) == FUNCTION_TYPE
14784 || (TREE_CODE (type
) == ARRAY_TYPE
14785 && TYPE_DOMAIN (type
) == NULL_TREE
)
14786 || TYPE_REF_P (type
))
14788 if (complain
& tf_error
)
14789 error ("creating array of %qT", type
);
14790 return error_mark_node
;
14793 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
14794 return error_mark_node
;
14796 r
= build_cplus_array_type (type
, domain
);
14798 if (!valid_array_size_p (input_location
, r
, in_decl
,
14799 (complain
& tf_error
)))
14800 return error_mark_node
;
14802 if (TYPE_USER_ALIGN (t
))
14804 SET_TYPE_ALIGN (r
, TYPE_ALIGN (t
));
14805 TYPE_USER_ALIGN (r
) = 1;
14811 case TYPENAME_TYPE
:
14813 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
14814 in_decl
, /*entering_scope=*/1);
14815 if (ctx
== error_mark_node
)
14816 return error_mark_node
;
14818 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
14819 complain
, in_decl
);
14820 if (f
== error_mark_node
)
14821 return error_mark_node
;
14823 if (!MAYBE_CLASS_TYPE_P (ctx
))
14825 if (complain
& tf_error
)
14826 error ("%qT is not a class, struct, or union type", ctx
);
14827 return error_mark_node
;
14829 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
14831 /* Normally, make_typename_type does not require that the CTX
14832 have complete type in order to allow things like:
14834 template <class T> struct S { typename S<T>::X Y; };
14836 But, such constructs have already been resolved by this
14837 point, so here CTX really should have complete type, unless
14838 it's a partial instantiation. */
14839 ctx
= complete_type (ctx
);
14840 if (!COMPLETE_TYPE_P (ctx
))
14842 if (complain
& tf_error
)
14843 cxx_incomplete_type_error (NULL_TREE
, ctx
);
14844 return error_mark_node
;
14848 f
= make_typename_type (ctx
, f
, typename_type
,
14849 complain
| tf_keep_type_decl
);
14850 if (f
== error_mark_node
)
14852 if (TREE_CODE (f
) == TYPE_DECL
)
14854 complain
|= tf_ignore_bad_quals
;
14858 if (TREE_CODE (f
) != TYPENAME_TYPE
)
14860 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
14862 if (complain
& tf_error
)
14863 error ("%qT resolves to %qT, which is not an enumeration type",
14866 return error_mark_node
;
14868 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
14870 if (complain
& tf_error
)
14871 error ("%qT resolves to %qT, which is is not a class type",
14874 return error_mark_node
;
14878 return cp_build_qualified_type_real
14879 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
14882 case UNBOUND_CLASS_TEMPLATE
:
14884 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
14885 in_decl
, /*entering_scope=*/1);
14886 tree name
= TYPE_IDENTIFIER (t
);
14887 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
14889 if (ctx
== error_mark_node
|| name
== error_mark_node
)
14890 return error_mark_node
;
14893 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
14894 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
14901 ++cp_unevaluated_operand
;
14902 ++c_inhibit_evaluation_warnings
;
14904 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
14906 /*integral_constant_expression_p=*/false);
14908 --cp_unevaluated_operand
;
14909 --c_inhibit_evaluation_warnings
;
14911 type
= finish_typeof (type
);
14912 return cp_build_qualified_type_real (type
,
14914 | cp_type_quals (type
),
14918 case DECLTYPE_TYPE
:
14922 ++cp_unevaluated_operand
;
14923 ++c_inhibit_evaluation_warnings
;
14925 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
14926 complain
|tf_decltype
, in_decl
,
14927 /*function_p*/false,
14928 /*integral_constant_expression*/false);
14930 if (DECLTYPE_FOR_INIT_CAPTURE (t
))
14932 if (type
== NULL_TREE
)
14934 if (complain
& tf_error
)
14935 error ("empty initializer in lambda init-capture");
14936 type
= error_mark_node
;
14938 else if (TREE_CODE (type
) == TREE_LIST
)
14939 type
= build_x_compound_expr_from_list (type
, ELK_INIT
, complain
);
14942 --cp_unevaluated_operand
;
14943 --c_inhibit_evaluation_warnings
;
14945 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
14946 type
= lambda_capture_field_type (type
,
14947 DECLTYPE_FOR_INIT_CAPTURE (t
),
14948 DECLTYPE_FOR_REF_CAPTURE (t
));
14949 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
14950 type
= lambda_proxy_type (type
);
14953 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
14954 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
14956 /* In a template ~id could be either a complement expression
14957 or an unqualified-id naming a destructor; if instantiating
14958 it produces an expression, it's not an id-expression or
14961 type
= finish_decltype_type (type
, id
, complain
);
14963 return cp_build_qualified_type_real (type
,
14965 | cp_type_quals (type
),
14966 complain
| tf_ignore_bad_quals
);
14969 case UNDERLYING_TYPE
:
14971 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
14972 complain
, in_decl
);
14973 return finish_underlying_type (type
);
14976 case TYPE_ARGUMENT_PACK
:
14977 case NONTYPE_ARGUMENT_PACK
:
14981 if (code
== NONTYPE_ARGUMENT_PACK
)
14982 r
= make_node (code
);
14984 r
= cxx_make_type (code
);
14986 tree pack_args
= ARGUMENT_PACK_ARGS (t
);
14987 pack_args
= tsubst_template_args (pack_args
, args
, complain
, in_decl
);
14988 SET_ARGUMENT_PACK_ARGS (r
, pack_args
);
15006 /* We should use one of the expression tsubsts for these codes. */
15007 gcc_unreachable ();
15010 sorry ("use of %qs in template", get_tree_code_name (code
));
15011 return error_mark_node
;
15015 /* tsubst a BASELINK. OBJECT_TYPE, if non-NULL, is the type of the
15016 expression on the left-hand side of the "." or "->" operator. We
15017 only do the lookup if we had a dependent BASELINK. Otherwise we
15018 adjust it onto the instantiated heirarchy. */
15021 tsubst_baselink (tree baselink
, tree object_type
,
15022 tree args
, tsubst_flags_t complain
, tree in_decl
)
15024 bool qualified_p
= BASELINK_QUALIFIED_P (baselink
);
15025 tree qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
15026 qualifying_scope
= tsubst (qualifying_scope
, args
, complain
, in_decl
);
15028 tree optype
= BASELINK_OPTYPE (baselink
);
15029 optype
= tsubst (optype
, args
, complain
, in_decl
);
15031 tree template_args
= NULL_TREE
;
15032 bool template_id_p
= false;
15033 tree fns
= BASELINK_FUNCTIONS (baselink
);
15034 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
15036 template_id_p
= true;
15037 template_args
= TREE_OPERAND (fns
, 1);
15038 fns
= TREE_OPERAND (fns
, 0);
15040 template_args
= tsubst_template_args (template_args
, args
,
15041 complain
, in_decl
);
15044 tree binfo_type
= BINFO_TYPE (BASELINK_BINFO (baselink
));
15045 binfo_type
= tsubst (binfo_type
, args
, complain
, in_decl
);
15046 bool dependent_p
= binfo_type
!= BINFO_TYPE (BASELINK_BINFO (baselink
));
15050 tree name
= OVL_NAME (fns
);
15051 if (IDENTIFIER_CONV_OP_P (name
))
15052 name
= make_conv_op_name (optype
);
15054 if (name
== complete_dtor_identifier
)
15055 /* Treat as-if non-dependent below. */
15056 dependent_p
= false;
15058 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
15061 if ((complain
& tf_error
)
15062 && constructor_name_p (name
, qualifying_scope
))
15063 error ("cannot call constructor %<%T::%D%> directly",
15064 qualifying_scope
, name
);
15065 return error_mark_node
;
15068 if (BASELINK_P (baselink
))
15069 fns
= BASELINK_FUNCTIONS (baselink
);
15072 /* We're going to overwrite pieces below, make a duplicate. */
15073 baselink
= copy_node (baselink
);
15075 /* If lookup found a single function, mark it as used at this point.
15076 (If lookup found multiple functions the one selected later by
15077 overload resolution will be marked as used at that point.) */
15078 if (!template_id_p
&& !really_overloaded_fn (fns
))
15080 tree fn
= OVL_FIRST (fns
);
15081 bool ok
= mark_used (fn
, complain
);
15082 if (!ok
&& !(complain
& tf_error
))
15083 return error_mark_node
;
15084 if (ok
&& BASELINK_P (baselink
))
15085 /* We might have instantiated an auto function. */
15086 TREE_TYPE (baselink
) = TREE_TYPE (fn
);
15089 if (BASELINK_P (baselink
))
15091 /* Add back the template arguments, if present. */
15093 BASELINK_FUNCTIONS (baselink
)
15094 = build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fns
, template_args
);
15096 /* Update the conversion operator type. */
15097 BASELINK_OPTYPE (baselink
) = optype
;
15101 object_type
= current_class_type
;
15103 if (qualified_p
|| !dependent_p
)
15105 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
15109 /* We need to call adjust_result_of_qualified_name_lookup in case the
15110 destructor names a base class, but we unset BASELINK_QUALIFIED_P
15111 so that we still get virtual function binding. */
15112 BASELINK_QUALIFIED_P (baselink
) = false;
15118 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
15119 true if the qualified-id will be a postfix-expression in-and-of
15120 itself; false if more of the postfix-expression follows the
15121 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
15125 tsubst_qualified_id (tree qualified_id
, tree args
,
15126 tsubst_flags_t complain
, tree in_decl
,
15127 bool done
, bool address_p
)
15133 tree template_args
;
15134 location_t loc
= UNKNOWN_LOCATION
;
15136 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
15138 /* Figure out what name to look up. */
15139 name
= TREE_OPERAND (qualified_id
, 1);
15140 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
15142 is_template
= true;
15143 loc
= EXPR_LOCATION (name
);
15144 template_args
= TREE_OPERAND (name
, 1);
15146 template_args
= tsubst_template_args (template_args
, args
,
15147 complain
, in_decl
);
15148 if (template_args
== error_mark_node
)
15149 return error_mark_node
;
15150 name
= TREE_OPERAND (name
, 0);
15154 is_template
= false;
15155 template_args
= NULL_TREE
;
15158 /* Substitute into the qualifying scope. When there are no ARGS, we
15159 are just trying to simplify a non-dependent expression. In that
15160 case the qualifying scope may be dependent, and, in any case,
15161 substituting will not help. */
15162 scope
= TREE_OPERAND (qualified_id
, 0);
15165 scope
= tsubst (scope
, args
, complain
, in_decl
);
15166 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
15171 if (dependent_scope_p (scope
))
15174 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
15175 tree r
= build_qualified_name (NULL_TREE
, scope
, expr
,
15176 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
15177 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (qualified_id
);
15181 if (!BASELINK_P (name
) && !DECL_P (expr
))
15183 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
15185 /* A BIT_NOT_EXPR is used to represent a destructor. */
15186 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
15188 error ("qualifying type %qT does not match destructor name ~%qT",
15189 scope
, TREE_OPERAND (expr
, 0));
15190 expr
= error_mark_node
;
15193 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
15194 /*is_type_p=*/0, false);
15197 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
15198 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
15199 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
15201 if (complain
& tf_error
)
15203 error ("dependent-name %qE is parsed as a non-type, but "
15204 "instantiation yields a type", qualified_id
);
15205 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
15207 return error_mark_node
;
15213 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
15215 /* Remember that there was a reference to this entity. */
15216 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
15217 return error_mark_node
;
15220 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
15222 if (complain
& tf_error
)
15223 qualified_name_lookup_error (scope
,
15224 TREE_OPERAND (qualified_id
, 1),
15225 expr
, input_location
);
15226 return error_mark_node
;
15231 /* We may be repeating a check already done during parsing, but
15232 if it was well-formed and passed then, it will pass again
15233 now, and if it didn't, we wouldn't have got here. The case
15234 we want to catch is when we couldn't tell then, and can now,
15235 namely when templ prior to substitution was an
15237 if (flag_concepts
&& check_auto_in_tmpl_args (expr
, template_args
))
15238 return error_mark_node
;
15240 if (variable_template_p (expr
))
15241 expr
= lookup_and_finish_template_variable (expr
, template_args
,
15244 expr
= lookup_template_function (expr
, template_args
);
15247 if (expr
== error_mark_node
&& complain
& tf_error
)
15248 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
15249 expr
, input_location
);
15250 else if (TYPE_P (scope
))
15252 expr
= (adjust_result_of_qualified_name_lookup
15253 (expr
, scope
, current_nonlambda_class_type ()));
15254 expr
= (finish_qualified_id_expr
15255 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
15256 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
15257 /*template_arg_p=*/false, complain
));
15260 /* Expressions do not generally have reference type. */
15261 if (TREE_CODE (expr
) != SCOPE_REF
15262 /* However, if we're about to form a pointer-to-member, we just
15263 want the referenced member referenced. */
15264 && TREE_CODE (expr
) != OFFSET_REF
)
15265 expr
= convert_from_reference (expr
);
15267 if (REF_PARENTHESIZED_P (qualified_id
))
15268 expr
= force_paren_expr (expr
);
15273 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
15274 initializer, DECL is the substituted VAR_DECL. Other arguments are as
15278 tsubst_init (tree init
, tree decl
, tree args
,
15279 tsubst_flags_t complain
, tree in_decl
)
15284 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
15286 if (!init
&& TREE_TYPE (decl
) != error_mark_node
)
15288 /* If we had an initializer but it
15289 instantiated to nothing,
15290 value-initialize the object. This will
15291 only occur when the initializer was a
15292 pack expansion where the parameter packs
15293 used in that expansion were of length
15295 init
= build_value_init (TREE_TYPE (decl
),
15297 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
15298 init
= get_target_expr_sfinae (init
, complain
);
15299 if (TREE_CODE (init
) == TARGET_EXPR
)
15300 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
15306 /* Like tsubst, but deals with expressions. This function just replaces
15307 template parms; to finish processing the resultant expression, use
15308 tsubst_copy_and_build or tsubst_expr. */
15311 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
15313 enum tree_code code
;
15316 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
15319 code
= TREE_CODE (t
);
15324 r
= retrieve_local_specialization (t
);
15326 if (r
== NULL_TREE
)
15328 /* We get here for a use of 'this' in an NSDMI. */
15329 if (DECL_NAME (t
) == this_identifier
&& current_class_ptr
)
15330 return current_class_ptr
;
15332 /* This can happen for a parameter name used later in a function
15333 declaration (such as in a late-specified return type). Just
15334 make a dummy decl, since it's only used for its type. */
15335 gcc_assert (cp_unevaluated_operand
!= 0);
15336 r
= tsubst_decl (t
, args
, complain
);
15337 /* Give it the template pattern as its context; its true context
15338 hasn't been instantiated yet and this is good enough for
15340 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
15343 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
15344 r
= argument_pack_select_arg (r
);
15345 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
15346 return error_mark_node
;
15354 if (DECL_TEMPLATE_PARM_P (t
))
15355 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
15356 /* There is no need to substitute into namespace-scope
15358 if (DECL_NAMESPACE_SCOPE_P (t
))
15360 /* If ARGS is NULL, then T is known to be non-dependent. */
15361 if (args
== NULL_TREE
)
15362 return scalar_constant_value (t
);
15364 /* Unfortunately, we cannot just call lookup_name here.
15367 template <int I> int f() {
15369 struct S { void g() { E e = a; } };
15372 When we instantiate f<7>::S::g(), say, lookup_name is not
15373 clever enough to find f<7>::a. */
15375 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
15376 /*entering_scope=*/0);
15378 for (v
= TYPE_VALUES (enum_type
);
15380 v
= TREE_CHAIN (v
))
15381 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
15382 return TREE_VALUE (v
);
15384 /* We didn't find the name. That should never happen; if
15385 name-lookup found it during preliminary parsing, we
15386 should find it again here during instantiation. */
15387 gcc_unreachable ();
15392 if (DECL_CONTEXT (t
))
15396 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
15397 /*entering_scope=*/1);
15398 if (ctx
!= DECL_CONTEXT (t
))
15400 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
15403 if (complain
& tf_error
)
15404 error ("using invalid field %qD", t
);
15405 return error_mark_node
;
15414 case FUNCTION_DECL
:
15415 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
15416 r
= tsubst (t
, args
, complain
, in_decl
);
15417 else if (local_variable_p (t
)
15418 && uses_template_parms (DECL_CONTEXT (t
)))
15420 r
= retrieve_local_specialization (t
);
15421 if (r
== NULL_TREE
)
15423 /* First try name lookup to find the instantiation. */
15424 r
= lookup_name (DECL_NAME (t
));
15425 if (r
&& !is_capture_proxy (r
))
15427 /* Make sure that the one we found is the one we want. */
15428 tree ctx
= enclosing_instantiation_of (DECL_CONTEXT (t
));
15429 if (ctx
!= DECL_CONTEXT (r
))
15437 /* This can happen for a variable used in a
15438 late-specified return type of a local lambda, or for a
15439 local static or constant. Building a new VAR_DECL
15440 should be OK in all those cases. */
15441 r
= tsubst_decl (t
, args
, complain
);
15442 if (local_specializations
)
15443 /* Avoid infinite recursion (79640). */
15444 register_local_specialization (r
, t
);
15445 if (decl_maybe_constant_var_p (r
))
15447 /* We can't call cp_finish_decl, so handle the
15448 initializer by hand. */
15449 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
15450 complain
, in_decl
);
15451 if (!processing_template_decl
)
15452 init
= maybe_constant_init (init
);
15453 if (processing_template_decl
15454 ? potential_constant_expression (init
)
15455 : reduced_constant_expression_p (init
))
15456 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
15457 = TREE_CONSTANT (r
) = true;
15458 DECL_INITIAL (r
) = init
;
15459 if (tree auto_node
= type_uses_auto (TREE_TYPE (r
)))
15461 = do_auto_deduction (TREE_TYPE (r
), init
, auto_node
,
15462 complain
, adc_variable_type
);
15464 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
15465 || decl_constant_var_p (r
)
15466 || errorcount
|| sorrycount
);
15467 if (!processing_template_decl
15468 && !TREE_STATIC (r
))
15469 r
= process_outer_var_ref (r
, complain
);
15471 /* Remember this for subsequent uses. */
15472 if (local_specializations
)
15473 register_local_specialization (r
, t
);
15475 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
15476 r
= argument_pack_select_arg (r
);
15480 if (!mark_used (r
, complain
))
15481 return error_mark_node
;
15484 case NAMESPACE_DECL
:
15488 /* An OVERLOAD will always be a non-dependent overload set; an
15489 overload set from function scope will just be represented with an
15490 IDENTIFIER_NODE, and from class scope with a BASELINK. */
15491 gcc_assert (!uses_template_parms (t
));
15492 /* We must have marked any lookups as persistent. */
15493 gcc_assert (!OVL_LOOKUP_P (t
) || OVL_USED_P (t
));
15497 return tsubst_baselink (t
, current_nonlambda_class_type (),
15498 args
, complain
, in_decl
);
15500 case TEMPLATE_DECL
:
15501 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
15502 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
15503 args
, complain
, in_decl
);
15504 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
15505 return tsubst (t
, args
, complain
, in_decl
);
15506 else if (DECL_CLASS_SCOPE_P (t
)
15507 && uses_template_parms (DECL_CONTEXT (t
)))
15509 /* Template template argument like the following example need
15512 template <template <class> class TT> struct C {};
15513 template <class T> struct D {
15514 template <class U> struct E {};
15519 We are processing the template argument `E' in #1 for
15520 the template instantiation #2. Originally, `E' is a
15521 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
15522 have to substitute this with one having context `D<int>'. */
15524 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
15525 if (dependent_scope_p (context
))
15527 /* When rewriting a constructor into a deduction guide, a
15528 non-dependent name can become dependent, so memtmpl<args>
15529 becomes context::template memtmpl<args>. */
15530 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15531 return build_qualified_name (type
, context
, DECL_NAME (t
),
15534 return lookup_field (context
, DECL_NAME(t
), 0, false);
15537 /* Ordinary template template argument. */
15540 case NON_LVALUE_EXPR
:
15541 case VIEW_CONVERT_EXPR
:
15543 /* Handle location wrappers by substituting the wrapped node
15544 first, *then* reusing the resulting type. Doing the type
15545 first ensures that we handle template parameters and
15546 parameter pack expansions. */
15547 gcc_assert (location_wrapper_p (t
));
15548 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15549 return maybe_wrap_with_location (op0
, EXPR_LOCATION (t
));
15553 case REINTERPRET_CAST_EXPR
:
15554 case CONST_CAST_EXPR
:
15555 case STATIC_CAST_EXPR
:
15556 case DYNAMIC_CAST_EXPR
:
15557 case IMPLICIT_CONV_EXPR
:
15561 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15562 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15563 return build1 (code
, type
, op0
);
15567 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
15568 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
15570 tree expanded
, op
= TREE_OPERAND (t
, 0);
15573 if (SIZEOF_EXPR_TYPE_P (t
))
15574 op
= TREE_TYPE (op
);
15576 ++cp_unevaluated_operand
;
15577 ++c_inhibit_evaluation_warnings
;
15578 /* We only want to compute the number of arguments. */
15579 if (PACK_EXPANSION_P (op
))
15580 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
15582 expanded
= tsubst_template_args (ARGUMENT_PACK_ARGS (op
),
15583 args
, complain
, in_decl
);
15584 --cp_unevaluated_operand
;
15585 --c_inhibit_evaluation_warnings
;
15587 if (TREE_CODE (expanded
) == TREE_VEC
)
15589 len
= TREE_VEC_LENGTH (expanded
);
15590 /* Set TREE_USED for the benefit of -Wunused. */
15591 for (int i
= 0; i
< len
; i
++)
15592 if (DECL_P (TREE_VEC_ELT (expanded
, i
)))
15593 TREE_USED (TREE_VEC_ELT (expanded
, i
)) = true;
15596 if (expanded
== error_mark_node
)
15597 return error_mark_node
;
15598 else if (PACK_EXPANSION_P (expanded
)
15599 || (TREE_CODE (expanded
) == TREE_VEC
15600 && pack_expansion_args_count (expanded
)))
15603 if (PACK_EXPANSION_P (expanded
))
15605 else if (TREE_VEC_LENGTH (expanded
) == 1)
15606 expanded
= TREE_VEC_ELT (expanded
, 0);
15608 expanded
= make_argument_pack (expanded
);
15610 if (TYPE_P (expanded
))
15611 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
15613 complain
& tf_error
);
15615 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
15616 complain
& tf_error
);
15619 return build_int_cst (size_type_node
, len
);
15621 if (SIZEOF_EXPR_TYPE_P (t
))
15623 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
15624 args
, complain
, in_decl
);
15625 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
15626 r
= build1 (SIZEOF_EXPR
,
15627 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
15628 SIZEOF_EXPR_TYPE_P (r
) = 1;
15635 case TRUTH_NOT_EXPR
:
15638 case UNARY_PLUS_EXPR
: /* Unary + */
15640 case AT_ENCODE_EXPR
:
15644 case REALPART_EXPR
:
15645 case IMAGPART_EXPR
:
15648 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15649 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15650 r
= build1 (code
, type
, op0
);
15651 if (code
== ALIGNOF_EXPR
)
15652 ALIGNOF_EXPR_STD_P (r
) = ALIGNOF_EXPR_STD_P (t
);
15656 case COMPONENT_REF
:
15661 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15662 name
= TREE_OPERAND (t
, 1);
15663 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
15665 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15666 complain
, in_decl
);
15667 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
15669 else if (TREE_CODE (name
) == SCOPE_REF
15670 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
15672 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15673 complain
, in_decl
);
15674 name
= TREE_OPERAND (name
, 1);
15675 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15676 complain
, in_decl
);
15677 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
15678 name
= build_qualified_name (/*type=*/NULL_TREE
,
15680 /*template_p=*/false);
15682 else if (BASELINK_P (name
))
15683 name
= tsubst_baselink (name
,
15684 non_reference (TREE_TYPE (object
)),
15688 name
= tsubst_copy (name
, args
, complain
, in_decl
);
15689 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
15695 case TRUNC_DIV_EXPR
:
15696 case CEIL_DIV_EXPR
:
15697 case FLOOR_DIV_EXPR
:
15698 case ROUND_DIV_EXPR
:
15699 case EXACT_DIV_EXPR
:
15703 case TRUNC_MOD_EXPR
:
15704 case FLOOR_MOD_EXPR
:
15705 case TRUTH_ANDIF_EXPR
:
15706 case TRUTH_ORIF_EXPR
:
15707 case TRUTH_AND_EXPR
:
15708 case TRUTH_OR_EXPR
:
15721 case COMPOUND_EXPR
:
15724 case PREDECREMENT_EXPR
:
15725 case PREINCREMENT_EXPR
:
15726 case POSTDECREMENT_EXPR
:
15727 case POSTINCREMENT_EXPR
:
15729 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15730 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15731 return build_nt (code
, op0
, op1
);
15736 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15737 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15738 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
15739 QUALIFIED_NAME_IS_TEMPLATE (t
));
15744 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15745 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15746 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
15751 int n
= VL_EXP_OPERAND_LENGTH (t
);
15752 tree result
= build_vl_exp (CALL_EXPR
, n
);
15754 for (i
= 0; i
< n
; i
++)
15755 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
15756 complain
, in_decl
);
15762 case PSEUDO_DTOR_EXPR
:
15763 case VEC_PERM_EXPR
:
15765 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15766 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15767 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15768 r
= build_nt (code
, op0
, op1
, op2
);
15769 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
15775 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15776 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15777 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15778 r
= build_nt (code
, op0
, op1
, op2
);
15779 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
15785 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15786 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15787 r
= build_nt (code
, op0
, op1
);
15788 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
15789 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
15793 case TEMPLATE_ID_EXPR
:
15795 /* Substituted template arguments */
15796 tree fn
= TREE_OPERAND (t
, 0);
15797 tree targs
= TREE_OPERAND (t
, 1);
15799 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
15801 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
15803 return lookup_template_function (fn
, targs
);
15808 tree purpose
, value
, chain
;
15810 if (t
== void_list_node
)
15813 purpose
= TREE_PURPOSE (t
);
15815 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
15816 value
= TREE_VALUE (t
);
15818 value
= tsubst_copy (value
, args
, complain
, in_decl
);
15819 chain
= TREE_CHAIN (t
);
15820 if (chain
&& chain
!= void_type_node
)
15821 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
15822 if (purpose
== TREE_PURPOSE (t
)
15823 && value
== TREE_VALUE (t
)
15824 && chain
== TREE_CHAIN (t
))
15826 return tree_cons (purpose
, value
, chain
);
15831 case ENUMERAL_TYPE
:
15833 case TEMPLATE_TYPE_PARM
:
15834 case TEMPLATE_TEMPLATE_PARM
:
15835 case BOUND_TEMPLATE_TEMPLATE_PARM
:
15836 case TEMPLATE_PARM_INDEX
:
15838 case REFERENCE_TYPE
:
15840 case FUNCTION_TYPE
:
15843 case TYPENAME_TYPE
:
15844 case UNBOUND_CLASS_TEMPLATE
:
15846 case DECLTYPE_TYPE
:
15848 return tsubst (t
, args
, complain
, in_decl
);
15852 /* Fall through. */
15853 case IDENTIFIER_NODE
:
15854 if (IDENTIFIER_CONV_OP_P (t
))
15856 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15857 return make_conv_op_name (new_type
);
15863 /* This is handled by tsubst_copy_and_build. */
15864 gcc_unreachable ();
15868 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15869 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15870 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
15873 case CLEANUP_POINT_EXPR
:
15874 /* We shouldn't have built any of these during initial template
15875 generation. Instead, they should be built during instantiation
15876 in response to the saved STMT_IS_FULL_EXPR_P setting. */
15877 gcc_unreachable ();
15881 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15882 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15883 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15884 r
= build2 (code
, type
, op0
, op1
);
15885 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
15886 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
15887 && !(complain
& tf_error
))
15888 return error_mark_node
;
15892 case EXPR_PACK_EXPANSION
:
15893 error ("invalid use of pack expansion expression");
15894 return error_mark_node
;
15896 case NONTYPE_ARGUMENT_PACK
:
15897 error ("use %<...%> to expand argument pack");
15898 return error_mark_node
;
15901 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
15909 /* Instantiate any typedefs in the type. */
15910 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15911 r
= fold_convert (type
, t
);
15912 gcc_assert (TREE_CODE (r
) == code
);
15917 /* These can sometimes show up in a partial instantiation, but never
15918 involve template parms. */
15919 gcc_assert (!uses_template_parms (t
));
15922 case UNARY_LEFT_FOLD_EXPR
:
15923 return tsubst_unary_left_fold (t
, args
, complain
, in_decl
);
15924 case UNARY_RIGHT_FOLD_EXPR
:
15925 return tsubst_unary_right_fold (t
, args
, complain
, in_decl
);
15926 case BINARY_LEFT_FOLD_EXPR
:
15927 return tsubst_binary_left_fold (t
, args
, complain
, in_decl
);
15928 case BINARY_RIGHT_FOLD_EXPR
:
15929 return tsubst_binary_right_fold (t
, args
, complain
, in_decl
);
15933 case DEBUG_BEGIN_STMT
:
15934 /* ??? There's no point in copying it for now, but maybe some
15935 day it will contain more information, such as a pointer back
15936 to the containing function, inlined copy or so. */
15940 /* We shouldn't get here, but keep going if !flag_checking. */
15942 gcc_unreachable ();
15947 /* Helper function for tsubst_omp_clauses, used for instantiation of
15948 OMP_CLAUSE_DECL of clauses. */
15951 tsubst_omp_clause_decl (tree decl
, tree args
, tsubst_flags_t complain
,
15954 if (decl
== NULL_TREE
)
15957 /* Handle an OpenMP array section represented as a TREE_LIST (or
15958 OMP_CLAUSE_DEPEND_KIND). An OMP_CLAUSE_DEPEND (with a depend
15959 kind of OMP_CLAUSE_DEPEND_SINK) can also be represented as a
15960 TREE_LIST. We can handle it exactly the same as an array section
15961 (purpose, value, and a chain), even though the nomenclature
15962 (low_bound, length, etc) is different. */
15963 if (TREE_CODE (decl
) == TREE_LIST
)
15966 = tsubst_expr (TREE_PURPOSE (decl
), args
, complain
, in_decl
,
15967 /*integral_constant_expression_p=*/false);
15968 tree length
= tsubst_expr (TREE_VALUE (decl
), args
, complain
, in_decl
,
15969 /*integral_constant_expression_p=*/false);
15970 tree chain
= tsubst_omp_clause_decl (TREE_CHAIN (decl
), args
, complain
,
15972 if (TREE_PURPOSE (decl
) == low_bound
15973 && TREE_VALUE (decl
) == length
15974 && TREE_CHAIN (decl
) == chain
)
15976 tree ret
= tree_cons (low_bound
, length
, chain
);
15977 OMP_CLAUSE_DEPEND_SINK_NEGATIVE (ret
)
15978 = OMP_CLAUSE_DEPEND_SINK_NEGATIVE (decl
);
15981 tree ret
= tsubst_expr (decl
, args
, complain
, in_decl
,
15982 /*integral_constant_expression_p=*/false);
15983 /* Undo convert_from_reference tsubst_expr could have called. */
15985 && REFERENCE_REF_P (ret
)
15986 && !REFERENCE_REF_P (decl
))
15987 ret
= TREE_OPERAND (ret
, 0);
15991 /* Like tsubst_copy, but specifically for OpenMP clauses. */
15994 tsubst_omp_clauses (tree clauses
, enum c_omp_region_type ort
,
15995 tree args
, tsubst_flags_t complain
, tree in_decl
)
15997 tree new_clauses
= NULL_TREE
, nc
, oc
;
15998 tree linear_no_step
= NULL_TREE
;
16000 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
16002 nc
= copy_node (oc
);
16003 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
16006 switch (OMP_CLAUSE_CODE (nc
))
16008 case OMP_CLAUSE_LASTPRIVATE
:
16009 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
16011 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
16012 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
16013 in_decl
, /*integral_constant_expression_p=*/false);
16014 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
16015 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
16018 case OMP_CLAUSE_PRIVATE
:
16019 case OMP_CLAUSE_SHARED
:
16020 case OMP_CLAUSE_FIRSTPRIVATE
:
16021 case OMP_CLAUSE_COPYIN
:
16022 case OMP_CLAUSE_COPYPRIVATE
:
16023 case OMP_CLAUSE_UNIFORM
:
16024 case OMP_CLAUSE_DEPEND
:
16025 case OMP_CLAUSE_FROM
:
16026 case OMP_CLAUSE_TO
:
16027 case OMP_CLAUSE_MAP
:
16028 case OMP_CLAUSE_USE_DEVICE_PTR
:
16029 case OMP_CLAUSE_IS_DEVICE_PTR
:
16030 OMP_CLAUSE_DECL (nc
)
16031 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16034 case OMP_CLAUSE_TILE
:
16035 case OMP_CLAUSE_IF
:
16036 case OMP_CLAUSE_NUM_THREADS
:
16037 case OMP_CLAUSE_SCHEDULE
:
16038 case OMP_CLAUSE_COLLAPSE
:
16039 case OMP_CLAUSE_FINAL
:
16040 case OMP_CLAUSE_DEVICE
:
16041 case OMP_CLAUSE_DIST_SCHEDULE
:
16042 case OMP_CLAUSE_NUM_TEAMS
:
16043 case OMP_CLAUSE_THREAD_LIMIT
:
16044 case OMP_CLAUSE_SAFELEN
:
16045 case OMP_CLAUSE_SIMDLEN
:
16046 case OMP_CLAUSE_NUM_TASKS
:
16047 case OMP_CLAUSE_GRAINSIZE
:
16048 case OMP_CLAUSE_PRIORITY
:
16049 case OMP_CLAUSE_ORDERED
:
16050 case OMP_CLAUSE_HINT
:
16051 case OMP_CLAUSE_NUM_GANGS
:
16052 case OMP_CLAUSE_NUM_WORKERS
:
16053 case OMP_CLAUSE_VECTOR_LENGTH
:
16054 case OMP_CLAUSE_WORKER
:
16055 case OMP_CLAUSE_VECTOR
:
16056 case OMP_CLAUSE_ASYNC
:
16057 case OMP_CLAUSE_WAIT
:
16058 OMP_CLAUSE_OPERAND (nc
, 0)
16059 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
16060 in_decl
, /*integral_constant_expression_p=*/false);
16062 case OMP_CLAUSE_REDUCTION
:
16063 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
16065 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
16066 if (TREE_CODE (placeholder
) == SCOPE_REF
)
16068 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
16069 complain
, in_decl
);
16070 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
16071 = build_qualified_name (NULL_TREE
, scope
,
16072 TREE_OPERAND (placeholder
, 1),
16076 gcc_assert (identifier_p (placeholder
));
16078 OMP_CLAUSE_DECL (nc
)
16079 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16082 case OMP_CLAUSE_GANG
:
16083 case OMP_CLAUSE_ALIGNED
:
16084 OMP_CLAUSE_DECL (nc
)
16085 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16087 OMP_CLAUSE_OPERAND (nc
, 1)
16088 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
16089 in_decl
, /*integral_constant_expression_p=*/false);
16091 case OMP_CLAUSE_LINEAR
:
16092 OMP_CLAUSE_DECL (nc
)
16093 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
16095 if (OMP_CLAUSE_LINEAR_STEP (oc
) == NULL_TREE
)
16097 gcc_assert (!linear_no_step
);
16098 linear_no_step
= nc
;
16100 else if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (oc
))
16101 OMP_CLAUSE_LINEAR_STEP (nc
)
16102 = tsubst_omp_clause_decl (OMP_CLAUSE_LINEAR_STEP (oc
), args
,
16103 complain
, in_decl
);
16105 OMP_CLAUSE_LINEAR_STEP (nc
)
16106 = tsubst_expr (OMP_CLAUSE_LINEAR_STEP (oc
), args
, complain
,
16108 /*integral_constant_expression_p=*/false);
16110 case OMP_CLAUSE_NOWAIT
:
16111 case OMP_CLAUSE_DEFAULT
:
16112 case OMP_CLAUSE_UNTIED
:
16113 case OMP_CLAUSE_MERGEABLE
:
16114 case OMP_CLAUSE_INBRANCH
:
16115 case OMP_CLAUSE_NOTINBRANCH
:
16116 case OMP_CLAUSE_PROC_BIND
:
16117 case OMP_CLAUSE_FOR
:
16118 case OMP_CLAUSE_PARALLEL
:
16119 case OMP_CLAUSE_SECTIONS
:
16120 case OMP_CLAUSE_TASKGROUP
:
16121 case OMP_CLAUSE_NOGROUP
:
16122 case OMP_CLAUSE_THREADS
:
16123 case OMP_CLAUSE_SIMD
:
16124 case OMP_CLAUSE_DEFAULTMAP
:
16125 case OMP_CLAUSE_INDEPENDENT
:
16126 case OMP_CLAUSE_AUTO
:
16127 case OMP_CLAUSE_SEQ
:
16128 case OMP_CLAUSE_IF_PRESENT
:
16129 case OMP_CLAUSE_FINALIZE
:
16132 gcc_unreachable ();
16134 if ((ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
)
16135 switch (OMP_CLAUSE_CODE (nc
))
16137 case OMP_CLAUSE_SHARED
:
16138 case OMP_CLAUSE_PRIVATE
:
16139 case OMP_CLAUSE_FIRSTPRIVATE
:
16140 case OMP_CLAUSE_LASTPRIVATE
:
16141 case OMP_CLAUSE_COPYPRIVATE
:
16142 case OMP_CLAUSE_LINEAR
:
16143 case OMP_CLAUSE_REDUCTION
:
16144 case OMP_CLAUSE_USE_DEVICE_PTR
:
16145 case OMP_CLAUSE_IS_DEVICE_PTR
:
16146 /* tsubst_expr on SCOPE_REF results in returning
16147 finish_non_static_data_member result. Undo that here. */
16148 if (TREE_CODE (OMP_CLAUSE_DECL (oc
)) == SCOPE_REF
16149 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (oc
), 1))
16150 == IDENTIFIER_NODE
))
16152 tree t
= OMP_CLAUSE_DECL (nc
);
16155 switch (TREE_CODE (v
))
16157 case COMPONENT_REF
:
16161 case POINTER_PLUS_EXPR
:
16162 v
= TREE_OPERAND (v
, 0);
16165 if (DECL_CONTEXT (v
) == current_function_decl
16166 && DECL_ARTIFICIAL (v
)
16167 && DECL_NAME (v
) == this_identifier
)
16168 OMP_CLAUSE_DECL (nc
) = TREE_OPERAND (t
, 1);
16175 else if (VAR_P (OMP_CLAUSE_DECL (oc
))
16176 && DECL_HAS_VALUE_EXPR_P (OMP_CLAUSE_DECL (oc
))
16177 && DECL_ARTIFICIAL (OMP_CLAUSE_DECL (oc
))
16178 && DECL_LANG_SPECIFIC (OMP_CLAUSE_DECL (oc
))
16179 && DECL_OMP_PRIVATIZED_MEMBER (OMP_CLAUSE_DECL (oc
)))
16181 tree decl
= OMP_CLAUSE_DECL (nc
);
16184 retrofit_lang_decl (decl
);
16185 DECL_OMP_PRIVATIZED_MEMBER (decl
) = 1;
16194 new_clauses
= nreverse (new_clauses
);
16195 if (ort
!= C_ORT_OMP_DECLARE_SIMD
)
16197 new_clauses
= finish_omp_clauses (new_clauses
, ort
);
16198 if (linear_no_step
)
16199 for (nc
= new_clauses
; nc
; nc
= OMP_CLAUSE_CHAIN (nc
))
16200 if (nc
== linear_no_step
)
16202 OMP_CLAUSE_LINEAR_STEP (nc
) = NULL_TREE
;
16206 return new_clauses
;
16209 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
16212 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
16215 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
16217 tree purpose
, value
, chain
;
16222 if (TREE_CODE (t
) != TREE_LIST
)
16223 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
16224 /*function_p=*/false,
16225 /*integral_constant_expression_p=*/false);
16227 if (t
== void_list_node
)
16230 purpose
= TREE_PURPOSE (t
);
16232 purpose
= RECUR (purpose
);
16233 value
= TREE_VALUE (t
);
16236 if (TREE_CODE (value
) != LABEL_DECL
)
16237 value
= RECUR (value
);
16240 value
= lookup_label (DECL_NAME (value
));
16241 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
16242 TREE_USED (value
) = 1;
16245 chain
= TREE_CHAIN (t
);
16246 if (chain
&& chain
!= void_type_node
)
16247 chain
= RECUR (chain
);
16248 return tree_cons (purpose
, value
, chain
);
16252 /* Used to temporarily communicate the list of #pragma omp parallel
16253 clauses to #pragma omp for instantiation if they are combined
16256 static tree
*omp_parallel_combined_clauses
;
16258 /* Substitute one OMP_FOR iterator. */
16261 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree orig_declv
,
16262 tree initv
, tree condv
, tree incrv
, tree
*clauses
,
16263 tree args
, tsubst_flags_t complain
, tree in_decl
,
16264 bool integral_constant_expression_p
)
16266 #define RECUR(NODE) \
16267 tsubst_expr ((NODE), args, complain, in_decl, \
16268 integral_constant_expression_p)
16269 tree decl
, init
, cond
, incr
;
16271 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
16272 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
16274 if (orig_declv
&& OMP_FOR_ORIG_DECLS (t
))
16276 tree o
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t
), i
);
16277 if (TREE_CODE (o
) == TREE_LIST
)
16278 TREE_VEC_ELT (orig_declv
, i
)
16279 = tree_cons (RECUR (TREE_PURPOSE (o
)),
16280 RECUR (TREE_VALUE (o
)), NULL_TREE
);
16282 TREE_VEC_ELT (orig_declv
, i
) = RECUR (o
);
16285 decl
= TREE_OPERAND (init
, 0);
16286 init
= TREE_OPERAND (init
, 1);
16287 tree decl_expr
= NULL_TREE
;
16288 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
16290 /* We need to jump through some hoops to handle declarations in the
16291 init-statement, since we might need to handle auto deduction,
16292 but we need to keep control of initialization. */
16294 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
16295 decl
= tsubst_decl (decl
, args
, complain
);
16299 if (TREE_CODE (decl
) == SCOPE_REF
)
16301 decl
= RECUR (decl
);
16302 if (TREE_CODE (decl
) == COMPONENT_REF
)
16306 switch (TREE_CODE (v
))
16308 case COMPONENT_REF
:
16312 case POINTER_PLUS_EXPR
:
16313 v
= TREE_OPERAND (v
, 0);
16316 if (DECL_CONTEXT (v
) == current_function_decl
16317 && DECL_ARTIFICIAL (v
)
16318 && DECL_NAME (v
) == this_identifier
)
16320 decl
= TREE_OPERAND (decl
, 1);
16321 decl
= omp_privatize_field (decl
, false);
16331 decl
= RECUR (decl
);
16333 init
= RECUR (init
);
16335 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
16336 if (auto_node
&& init
)
16338 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
, complain
);
16340 gcc_assert (!type_dependent_expression_p (decl
));
16342 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
16346 /* Declare the variable, but don't let that initialize it. */
16347 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
16348 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
16350 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
16353 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
16354 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
16355 if (TREE_CODE (incr
) == MODIFY_EXPR
)
16357 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16358 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
16359 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
16360 NOP_EXPR
, rhs
, complain
);
16363 incr
= RECUR (incr
);
16364 TREE_VEC_ELT (declv
, i
) = decl
;
16365 TREE_VEC_ELT (initv
, i
) = init
;
16366 TREE_VEC_ELT (condv
, i
) = cond
;
16367 TREE_VEC_ELT (incrv
, i
) = incr
;
16373 /* Declare and initialize the variable. */
16381 for (j
= (omp_parallel_combined_clauses
== NULL
? 1 : 0); j
< 2; j
++)
16383 for (pc
= j
? clauses
: omp_parallel_combined_clauses
; *pc
; )
16385 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
16386 && OMP_CLAUSE_DECL (*pc
) == decl
)
16388 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_LASTPRIVATE
16389 && OMP_CLAUSE_DECL (*pc
) == decl
)
16393 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
16395 *pc
= OMP_CLAUSE_CHAIN (c
);
16396 OMP_CLAUSE_CHAIN (c
) = *clauses
;
16399 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_FIRSTPRIVATE
16400 && OMP_CLAUSE_DECL (*pc
) == decl
)
16402 error ("iteration variable %qD should not be firstprivate",
16404 *pc
= OMP_CLAUSE_CHAIN (*pc
);
16406 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_REDUCTION
16407 && OMP_CLAUSE_DECL (*pc
) == decl
)
16409 error ("iteration variable %qD should not be reduction",
16411 *pc
= OMP_CLAUSE_CHAIN (*pc
);
16414 pc
= &OMP_CLAUSE_CHAIN (*pc
);
16419 if (*pc
== NULL_TREE
)
16421 tree c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
16422 OMP_CLAUSE_DECL (c
) = decl
;
16423 c
= finish_omp_clauses (c
, C_ORT_OMP
);
16426 OMP_CLAUSE_CHAIN (c
) = *clauses
;
16431 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
16432 if (COMPARISON_CLASS_P (cond
))
16434 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
16435 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
16436 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
16439 cond
= RECUR (cond
);
16440 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
16441 switch (TREE_CODE (incr
))
16443 case PREINCREMENT_EXPR
:
16444 case PREDECREMENT_EXPR
:
16445 case POSTINCREMENT_EXPR
:
16446 case POSTDECREMENT_EXPR
:
16447 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
16448 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
16451 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
16452 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
16454 tree rhs
= TREE_OPERAND (incr
, 1);
16455 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16456 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
16457 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
16458 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
16459 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
16463 incr
= RECUR (incr
);
16466 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
16467 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
16469 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16470 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
16471 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
16472 TREE_TYPE (decl
), lhs
,
16473 RECUR (TREE_OPERAND (incr
, 2))));
16475 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
16476 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
16477 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
16479 tree rhs
= TREE_OPERAND (incr
, 2);
16480 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
16481 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
16482 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
16483 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
16484 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
16488 incr
= RECUR (incr
);
16491 incr
= RECUR (incr
);
16495 TREE_VEC_ELT (declv
, i
) = decl
;
16496 TREE_VEC_ELT (initv
, i
) = init
;
16497 TREE_VEC_ELT (condv
, i
) = cond
;
16498 TREE_VEC_ELT (incrv
, i
) = incr
;
16502 /* Helper function of tsubst_expr, find OMP_TEAMS inside
16503 of OMP_TARGET's body. */
16506 tsubst_find_omp_teams (tree
*tp
, int *walk_subtrees
, void *)
16508 *walk_subtrees
= 0;
16509 switch (TREE_CODE (*tp
))
16514 case STATEMENT_LIST
:
16515 *walk_subtrees
= 1;
16523 /* Helper function for tsubst_expr. For decomposition declaration
16524 artificial base DECL, which is tsubsted PATTERN_DECL, tsubst
16525 also the corresponding decls representing the identifiers
16526 of the decomposition declaration. Return DECL if successful
16527 or error_mark_node otherwise, set *FIRST to the first decl
16528 in the list chained through DECL_CHAIN and *CNT to the number
16532 tsubst_decomp_names (tree decl
, tree pattern_decl
, tree args
,
16533 tsubst_flags_t complain
, tree in_decl
, tree
*first
,
16536 tree decl2
, decl3
, prev
= decl
;
16538 gcc_assert (DECL_NAME (decl
) == NULL_TREE
);
16539 for (decl2
= DECL_CHAIN (pattern_decl
);
16542 && DECL_DECOMPOSITION_P (decl2
)
16543 && DECL_NAME (decl2
);
16544 decl2
= DECL_CHAIN (decl2
))
16546 if (TREE_TYPE (decl2
) == error_mark_node
&& *cnt
== 0)
16548 gcc_assert (errorcount
);
16549 return error_mark_node
;
16552 gcc_assert (DECL_DECOMP_BASE (decl2
) == pattern_decl
);
16553 gcc_assert (DECL_HAS_VALUE_EXPR_P (decl2
));
16554 tree v
= DECL_VALUE_EXPR (decl2
);
16555 DECL_HAS_VALUE_EXPR_P (decl2
) = 0;
16556 SET_DECL_VALUE_EXPR (decl2
, NULL_TREE
);
16557 decl3
= tsubst (decl2
, args
, complain
, in_decl
);
16558 SET_DECL_VALUE_EXPR (decl2
, v
);
16559 DECL_HAS_VALUE_EXPR_P (decl2
) = 1;
16561 DECL_TEMPLATE_INSTANTIATED (decl3
) = 1;
16564 gcc_assert (errorcount
);
16565 decl
= error_mark_node
;
16568 maybe_push_decl (decl3
);
16569 if (error_operand_p (decl3
))
16570 decl
= error_mark_node
;
16571 else if (decl
!= error_mark_node
16572 && DECL_CHAIN (decl3
) != prev
16575 gcc_assert (errorcount
);
16576 decl
= error_mark_node
;
16585 /* Like tsubst_copy for expressions, etc. but also does semantic
16589 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
16590 bool integral_constant_expression_p
)
16592 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
16593 #define RECUR(NODE) \
16594 tsubst_expr ((NODE), args, complain, in_decl, \
16595 integral_constant_expression_p)
16601 if (t
== NULL_TREE
|| t
== error_mark_node
)
16604 loc
= input_location
;
16605 if (location_t eloc
= cp_expr_location (t
))
16606 input_location
= eloc
;
16607 if (STATEMENT_CODE_P (TREE_CODE (t
)))
16608 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
16610 switch (TREE_CODE (t
))
16612 case STATEMENT_LIST
:
16614 tree_stmt_iterator i
;
16615 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
16616 RECUR (tsi_stmt (i
));
16620 case CTOR_INITIALIZER
:
16621 finish_mem_initializers (tsubst_initializer_list
16622 (TREE_OPERAND (t
, 0), args
));
16626 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
16630 tmp
= RECUR (EXPR_STMT_EXPR (t
));
16631 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
16632 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
16634 finish_expr_stmt (tmp
);
16638 finish_local_using_directive (USING_STMT_NAMESPACE (t
),
16639 /*attribs=*/NULL_TREE
);
16644 tree decl
, pattern_decl
;
16647 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
16648 if (TREE_CODE (decl
) == LABEL_DECL
)
16649 finish_label_decl (DECL_NAME (decl
));
16650 else if (TREE_CODE (decl
) == USING_DECL
)
16652 tree scope
= USING_DECL_SCOPE (decl
);
16653 tree name
= DECL_NAME (decl
);
16655 scope
= tsubst (scope
, args
, complain
, in_decl
);
16656 decl
= lookup_qualified_name (scope
, name
,
16657 /*is_type_p=*/false,
16658 /*complain=*/false);
16659 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
16660 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
16662 finish_local_using_decl (decl
, scope
, name
);
16664 else if (is_capture_proxy (decl
)
16665 && !DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
16667 /* We're in tsubst_lambda_expr, we've already inserted a new
16668 capture proxy, so look it up and register it. */
16670 if (DECL_PACK_P (decl
))
16672 inst
= (retrieve_local_specialization
16673 (DECL_CAPTURED_VARIABLE (decl
)));
16674 gcc_assert (TREE_CODE (inst
) == NONTYPE_ARGUMENT_PACK
);
16678 inst
= lookup_name_real (DECL_NAME (decl
), 0, 0,
16679 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
16680 gcc_assert (inst
!= decl
&& is_capture_proxy (inst
));
16682 register_local_specialization (inst
, decl
);
16685 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
16686 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
16687 /* Don't copy the old closure; we'll create a new one in
16688 tsubst_lambda_expr. */
16692 init
= DECL_INITIAL (decl
);
16693 decl
= tsubst (decl
, args
, complain
, in_decl
);
16694 if (decl
!= error_mark_node
)
16696 /* By marking the declaration as instantiated, we avoid
16697 trying to instantiate it. Since instantiate_decl can't
16698 handle local variables, and since we've already done
16699 all that needs to be done, that's the right thing to
16702 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
16703 if (VAR_P (decl
) && !DECL_NAME (decl
)
16704 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
16705 /* Anonymous aggregates are a special case. */
16706 finish_anon_union (decl
);
16707 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
16709 DECL_CONTEXT (decl
) = current_function_decl
;
16710 if (DECL_NAME (decl
) == this_identifier
)
16712 tree lam
= DECL_CONTEXT (current_function_decl
);
16713 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
16714 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
16716 insert_capture_proxy (decl
);
16718 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
16719 /* We already did a pushtag. */;
16720 else if (TREE_CODE (decl
) == FUNCTION_DECL
16721 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
16722 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
16724 DECL_CONTEXT (decl
) = NULL_TREE
;
16726 DECL_CONTEXT (decl
) = current_function_decl
;
16727 cp_check_omp_declare_reduction (decl
);
16731 int const_init
= false;
16732 maybe_push_decl (decl
);
16734 && DECL_PRETTY_FUNCTION_P (decl
))
16736 /* For __PRETTY_FUNCTION__ we have to adjust the
16738 const char *const name
16739 = cxx_printable_name (current_function_decl
, 2);
16740 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
16743 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
16746 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
16749 && DECL_DECOMPOSITION_P (decl
)
16750 && TREE_TYPE (pattern_decl
) != error_mark_node
)
16755 = tsubst_decomp_names (decl
, pattern_decl
, args
,
16756 complain
, in_decl
, &first
, &cnt
);
16757 if (ndecl
!= error_mark_node
)
16758 cp_maybe_mangle_decomp (ndecl
, first
, cnt
);
16759 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
16760 if (ndecl
!= error_mark_node
)
16761 cp_finish_decomp (ndecl
, first
, cnt
);
16764 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
16773 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
16774 RECUR (FOR_INIT_STMT (t
));
16775 finish_init_stmt (stmt
);
16776 tmp
= RECUR (FOR_COND (t
));
16777 finish_for_cond (tmp
, stmt
, false, 0);
16778 tmp
= RECUR (FOR_EXPR (t
));
16779 finish_for_expr (tmp
, stmt
);
16781 bool prev
= note_iteration_stmt_body_start ();
16782 RECUR (FOR_BODY (t
));
16783 note_iteration_stmt_body_end (prev
);
16785 finish_for_stmt (stmt
);
16788 case RANGE_FOR_STMT
:
16790 /* Construct another range_for, if this is not a final
16791 substitution (for inside inside a generic lambda of a
16792 template). Otherwise convert to a regular for. */
16794 stmt
= (processing_template_decl
16795 ? begin_range_for_stmt (NULL_TREE
, NULL_TREE
)
16796 : begin_for_stmt (NULL_TREE
, NULL_TREE
));
16797 decl
= RANGE_FOR_DECL (t
);
16798 decl
= tsubst (decl
, args
, complain
, in_decl
);
16799 maybe_push_decl (decl
);
16800 expr
= RECUR (RANGE_FOR_EXPR (t
));
16802 tree decomp_first
= NULL_TREE
;
16803 unsigned decomp_cnt
= 0;
16804 if (VAR_P (decl
) && DECL_DECOMPOSITION_P (decl
))
16805 decl
= tsubst_decomp_names (decl
, RANGE_FOR_DECL (t
), args
,
16807 &decomp_first
, &decomp_cnt
);
16809 if (processing_template_decl
)
16811 RANGE_FOR_IVDEP (stmt
) = RANGE_FOR_IVDEP (t
);
16812 RANGE_FOR_UNROLL (stmt
) = RANGE_FOR_UNROLL (t
);
16813 finish_range_for_decl (stmt
, decl
, expr
);
16817 unsigned short unroll
= (RANGE_FOR_UNROLL (t
)
16818 ? tree_to_uhwi (RANGE_FOR_UNROLL (t
)) : 0);
16819 stmt
= cp_convert_range_for (stmt
, decl
, expr
,
16820 decomp_first
, decomp_cnt
,
16821 RANGE_FOR_IVDEP (t
), unroll
);
16824 bool prev
= note_iteration_stmt_body_start ();
16825 RECUR (RANGE_FOR_BODY (t
));
16826 note_iteration_stmt_body_end (prev
);
16827 finish_for_stmt (stmt
);
16832 stmt
= begin_while_stmt ();
16833 tmp
= RECUR (WHILE_COND (t
));
16834 finish_while_stmt_cond (tmp
, stmt
, false, 0);
16836 bool prev
= note_iteration_stmt_body_start ();
16837 RECUR (WHILE_BODY (t
));
16838 note_iteration_stmt_body_end (prev
);
16840 finish_while_stmt (stmt
);
16844 stmt
= begin_do_stmt ();
16846 bool prev
= note_iteration_stmt_body_start ();
16847 RECUR (DO_BODY (t
));
16848 note_iteration_stmt_body_end (prev
);
16850 finish_do_body (stmt
);
16851 tmp
= RECUR (DO_COND (t
));
16852 finish_do_stmt (tmp
, stmt
, false, 0);
16856 stmt
= begin_if_stmt ();
16857 IF_STMT_CONSTEXPR_P (stmt
) = IF_STMT_CONSTEXPR_P (t
);
16858 if (IF_STMT_CONSTEXPR_P (t
))
16859 args
= add_extra_args (IF_STMT_EXTRA_ARGS (t
), args
);
16860 tmp
= RECUR (IF_COND (t
));
16861 tmp
= finish_if_stmt_cond (tmp
, stmt
);
16862 if (IF_STMT_CONSTEXPR_P (t
)
16863 && instantiation_dependent_expression_p (tmp
))
16865 /* We're partially instantiating a generic lambda, but the condition
16866 of the constexpr if is still dependent. Don't substitute into the
16867 branches now, just remember the template arguments. */
16868 do_poplevel (IF_SCOPE (stmt
));
16869 IF_COND (stmt
) = IF_COND (t
);
16870 THEN_CLAUSE (stmt
) = THEN_CLAUSE (t
);
16871 ELSE_CLAUSE (stmt
) = ELSE_CLAUSE (t
);
16872 IF_STMT_EXTRA_ARGS (stmt
) = build_extra_args (t
, args
, complain
);
16876 if (IF_STMT_CONSTEXPR_P (t
) && integer_zerop (tmp
))
16877 /* Don't instantiate the THEN_CLAUSE. */;
16880 tree folded
= fold_non_dependent_expr (tmp
, complain
);
16881 bool inhibit
= integer_zerop (folded
);
16883 ++c_inhibit_evaluation_warnings
;
16884 RECUR (THEN_CLAUSE (t
));
16886 --c_inhibit_evaluation_warnings
;
16888 finish_then_clause (stmt
);
16890 if (IF_STMT_CONSTEXPR_P (t
) && integer_nonzerop (tmp
))
16891 /* Don't instantiate the ELSE_CLAUSE. */;
16892 else if (ELSE_CLAUSE (t
))
16894 tree folded
= fold_non_dependent_expr (tmp
, complain
);
16895 bool inhibit
= integer_nonzerop (folded
);
16896 begin_else_clause (stmt
);
16898 ++c_inhibit_evaluation_warnings
;
16899 RECUR (ELSE_CLAUSE (t
));
16901 --c_inhibit_evaluation_warnings
;
16902 finish_else_clause (stmt
);
16905 finish_if_stmt (stmt
);
16909 if (BIND_EXPR_BODY_BLOCK (t
))
16910 stmt
= begin_function_body ();
16912 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
16913 ? BCS_TRY_BLOCK
: 0);
16915 RECUR (BIND_EXPR_BODY (t
));
16917 if (BIND_EXPR_BODY_BLOCK (t
))
16918 finish_function_body (stmt
);
16920 finish_compound_stmt (stmt
);
16924 finish_break_stmt ();
16927 case CONTINUE_STMT
:
16928 finish_continue_stmt ();
16932 stmt
= begin_switch_stmt ();
16933 tmp
= RECUR (SWITCH_STMT_COND (t
));
16934 finish_switch_cond (tmp
, stmt
);
16935 RECUR (SWITCH_STMT_BODY (t
));
16936 finish_switch_stmt (stmt
);
16939 case CASE_LABEL_EXPR
:
16941 tree low
= RECUR (CASE_LOW (t
));
16942 tree high
= RECUR (CASE_HIGH (t
));
16943 tree l
= finish_case_label (EXPR_LOCATION (t
), low
, high
);
16944 if (l
&& TREE_CODE (l
) == CASE_LABEL_EXPR
)
16945 FALLTHROUGH_LABEL_P (CASE_LABEL (l
))
16946 = FALLTHROUGH_LABEL_P (CASE_LABEL (t
));
16952 tree decl
= LABEL_EXPR_LABEL (t
);
16955 label
= finish_label_stmt (DECL_NAME (decl
));
16956 if (TREE_CODE (label
) == LABEL_DECL
)
16957 FALLTHROUGH_LABEL_P (label
) = FALLTHROUGH_LABEL_P (decl
);
16958 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
16959 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
16964 tmp
= GOTO_DESTINATION (t
);
16965 if (TREE_CODE (tmp
) != LABEL_DECL
)
16966 /* Computed goto's must be tsubst'd into. On the other hand,
16967 non-computed gotos must not be; the identifier in question
16968 will have no binding. */
16971 tmp
= DECL_NAME (tmp
);
16972 finish_goto_stmt (tmp
);
16977 tree string
= RECUR (ASM_STRING (t
));
16978 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
16979 complain
, in_decl
);
16980 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
16981 complain
, in_decl
);
16982 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
16983 complain
, in_decl
);
16984 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
16985 complain
, in_decl
);
16986 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
16988 tree asm_expr
= tmp
;
16989 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
16990 asm_expr
= TREE_OPERAND (asm_expr
, 0);
16991 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
16998 stmt
= begin_try_block ();
16999 RECUR (TRY_STMTS (t
));
17000 finish_cleanup_try_block (stmt
);
17001 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
17005 tree compound_stmt
= NULL_TREE
;
17007 if (FN_TRY_BLOCK_P (t
))
17008 stmt
= begin_function_try_block (&compound_stmt
);
17010 stmt
= begin_try_block ();
17012 RECUR (TRY_STMTS (t
));
17014 if (FN_TRY_BLOCK_P (t
))
17015 finish_function_try_block (stmt
);
17017 finish_try_block (stmt
);
17019 RECUR (TRY_HANDLERS (t
));
17020 if (FN_TRY_BLOCK_P (t
))
17021 finish_function_handler_sequence (stmt
, compound_stmt
);
17023 finish_handler_sequence (stmt
);
17029 tree decl
= HANDLER_PARMS (t
);
17033 decl
= tsubst (decl
, args
, complain
, in_decl
);
17034 /* Prevent instantiate_decl from trying to instantiate
17035 this variable. We've already done all that needs to be
17037 if (decl
!= error_mark_node
)
17038 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
17040 stmt
= begin_handler ();
17041 finish_handler_parms (decl
, stmt
);
17042 RECUR (HANDLER_BODY (t
));
17043 finish_handler (stmt
);
17048 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
17049 if (CLASS_TYPE_P (tmp
))
17051 /* Local classes are not independent templates; they are
17052 instantiated along with their containing function. And this
17053 way we don't have to deal with pushing out of one local class
17054 to instantiate a member of another local class. */
17055 /* Closures are handled by the LAMBDA_EXPR. */
17056 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
17057 complete_type (tmp
);
17058 for (tree fld
= TYPE_FIELDS (tmp
); fld
; fld
= DECL_CHAIN (fld
))
17060 || (TREE_CODE (fld
) == FUNCTION_DECL
17061 && !DECL_ARTIFICIAL (fld
)))
17062 && DECL_TEMPLATE_INSTANTIATION (fld
))
17063 instantiate_decl (fld
, /*defer_ok=*/false,
17064 /*expl_inst_class=*/false);
17068 case STATIC_ASSERT
:
17072 ++c_inhibit_evaluation_warnings
;
17074 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
17077 /*integral_constant_expression_p=*/true);
17078 --c_inhibit_evaluation_warnings
;
17080 finish_static_assert (condition
,
17081 STATIC_ASSERT_MESSAGE (t
),
17082 STATIC_ASSERT_SOURCE_LOCATION (t
),
17083 /*member_p=*/false);
17088 case OACC_PARALLEL
:
17089 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_ACC
, args
, complain
,
17091 stmt
= begin_omp_parallel ();
17092 RECUR (OMP_BODY (t
));
17093 finish_omp_construct (TREE_CODE (t
), stmt
, tmp
);
17097 r
= push_omp_privatization_clauses (OMP_PARALLEL_COMBINED (t
));
17098 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), C_ORT_OMP
, args
,
17099 complain
, in_decl
);
17100 if (OMP_PARALLEL_COMBINED (t
))
17101 omp_parallel_combined_clauses
= &tmp
;
17102 stmt
= begin_omp_parallel ();
17103 RECUR (OMP_PARALLEL_BODY (t
));
17104 gcc_assert (omp_parallel_combined_clauses
== NULL
);
17105 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
17106 = OMP_PARALLEL_COMBINED (t
);
17107 pop_omp_privatization_clauses (r
);
17111 r
= push_omp_privatization_clauses (false);
17112 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), C_ORT_OMP
, args
,
17113 complain
, in_decl
);
17114 stmt
= begin_omp_task ();
17115 RECUR (OMP_TASK_BODY (t
));
17116 finish_omp_task (tmp
, stmt
);
17117 pop_omp_privatization_clauses (r
);
17122 case OMP_DISTRIBUTE
:
17126 tree clauses
, body
, pre_body
;
17127 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
17128 tree orig_declv
= NULL_TREE
;
17129 tree incrv
= NULL_TREE
;
17130 enum c_omp_region_type ort
= C_ORT_OMP
;
17133 if (TREE_CODE (t
) == OACC_LOOP
)
17136 r
= push_omp_privatization_clauses (OMP_FOR_INIT (t
) == NULL_TREE
);
17137 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), ort
, args
, complain
,
17139 if (OMP_FOR_INIT (t
) != NULL_TREE
)
17141 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17142 if (OMP_FOR_ORIG_DECLS (t
))
17143 orig_declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17144 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17145 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17146 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
17149 stmt
= begin_omp_structured_block ();
17151 pre_body
= push_stmt_list ();
17152 RECUR (OMP_FOR_PRE_BODY (t
));
17153 pre_body
= pop_stmt_list (pre_body
);
17155 if (OMP_FOR_INIT (t
) != NULL_TREE
)
17156 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
17157 tsubst_omp_for_iterator (t
, i
, declv
, orig_declv
, initv
, condv
,
17158 incrv
, &clauses
, args
, complain
, in_decl
,
17159 integral_constant_expression_p
);
17160 omp_parallel_combined_clauses
= NULL
;
17162 body
= push_stmt_list ();
17163 RECUR (OMP_FOR_BODY (t
));
17164 body
= pop_stmt_list (body
);
17166 if (OMP_FOR_INIT (t
) != NULL_TREE
)
17167 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
,
17168 orig_declv
, initv
, condv
, incrv
, body
, pre_body
,
17172 t
= make_node (TREE_CODE (t
));
17173 TREE_TYPE (t
) = void_type_node
;
17174 OMP_FOR_BODY (t
) = body
;
17175 OMP_FOR_PRE_BODY (t
) = pre_body
;
17176 OMP_FOR_CLAUSES (t
) = clauses
;
17177 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
17181 add_stmt (finish_omp_structured_block (stmt
));
17182 pop_omp_privatization_clauses (r
);
17187 omp_parallel_combined_clauses
= NULL
;
17192 r
= push_omp_privatization_clauses (TREE_CODE (t
) == OMP_TEAMS
17193 && OMP_TEAMS_COMBINED (t
));
17194 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_OMP
, args
, complain
,
17196 stmt
= push_stmt_list ();
17197 RECUR (OMP_BODY (t
));
17198 stmt
= pop_stmt_list (stmt
);
17201 OMP_BODY (t
) = stmt
;
17202 OMP_CLAUSES (t
) = tmp
;
17204 pop_omp_privatization_clauses (r
);
17208 case OMP_TARGET_DATA
:
17210 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), (TREE_CODE (t
) == OACC_DATA
)
17211 ? C_ORT_ACC
: C_ORT_OMP
, args
, complain
,
17213 keep_next_level (true);
17214 stmt
= begin_omp_structured_block ();
17216 RECUR (OMP_BODY (t
));
17217 stmt
= finish_omp_structured_block (stmt
);
17220 OMP_BODY (t
) = stmt
;
17221 OMP_CLAUSES (t
) = tmp
;
17222 if (TREE_CODE (t
) == OMP_TARGET
&& OMP_TARGET_COMBINED (t
))
17224 tree teams
= cp_walk_tree (&stmt
, tsubst_find_omp_teams
, NULL
, NULL
);
17227 /* For combined target teams, ensure the num_teams and
17228 thread_limit clause expressions are evaluated on the host,
17229 before entering the target construct. */
17231 for (c
= OMP_TEAMS_CLAUSES (teams
);
17232 c
; c
= OMP_CLAUSE_CHAIN (c
))
17233 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
17234 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
17235 && TREE_CODE (OMP_CLAUSE_OPERAND (c
, 0)) != INTEGER_CST
)
17237 tree expr
= OMP_CLAUSE_OPERAND (c
, 0);
17238 expr
= force_target_expr (TREE_TYPE (expr
), expr
, tf_none
);
17239 if (expr
== error_mark_node
)
17241 tmp
= TARGET_EXPR_SLOT (expr
);
17243 OMP_CLAUSE_OPERAND (c
, 0) = expr
;
17244 tree tc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
17245 OMP_CLAUSE_FIRSTPRIVATE
);
17246 OMP_CLAUSE_DECL (tc
) = tmp
;
17247 OMP_CLAUSE_CHAIN (tc
) = OMP_TARGET_CLAUSES (t
);
17248 OMP_TARGET_CLAUSES (t
) = tc
;
17257 tmp
= tsubst_omp_clauses (OACC_DECLARE_CLAUSES (t
), C_ORT_ACC
, args
,
17258 complain
, in_decl
);
17259 OACC_DECLARE_CLAUSES (t
) = tmp
;
17263 case OMP_TARGET_UPDATE
:
17264 case OMP_TARGET_ENTER_DATA
:
17265 case OMP_TARGET_EXIT_DATA
:
17266 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_OMP
, args
,
17267 complain
, in_decl
);
17269 OMP_STANDALONE_CLAUSES (t
) = tmp
;
17273 case OACC_ENTER_DATA
:
17274 case OACC_EXIT_DATA
:
17276 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_ACC
, args
,
17277 complain
, in_decl
);
17279 OMP_STANDALONE_CLAUSES (t
) = tmp
;
17284 tmp
= tsubst_omp_clauses (OMP_ORDERED_CLAUSES (t
), C_ORT_OMP
, args
,
17285 complain
, in_decl
);
17286 stmt
= push_stmt_list ();
17287 RECUR (OMP_BODY (t
));
17288 stmt
= pop_stmt_list (stmt
);
17291 OMP_BODY (t
) = stmt
;
17292 OMP_ORDERED_CLAUSES (t
) = tmp
;
17298 case OMP_TASKGROUP
:
17299 stmt
= push_stmt_list ();
17300 RECUR (OMP_BODY (t
));
17301 stmt
= pop_stmt_list (stmt
);
17304 OMP_BODY (t
) = stmt
;
17309 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
17310 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
17312 tree op1
= TREE_OPERAND (t
, 1);
17313 tree rhs1
= NULL_TREE
;
17315 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
17317 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
17318 op1
= TREE_OPERAND (op1
, 1);
17320 lhs
= RECUR (TREE_OPERAND (op1
, 0));
17321 rhs
= RECUR (TREE_OPERAND (op1
, 1));
17322 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
17323 NULL_TREE
, NULL_TREE
, rhs1
,
17324 OMP_ATOMIC_SEQ_CST (t
));
17328 tree op1
= TREE_OPERAND (t
, 1);
17329 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
17330 tree rhs1
= NULL_TREE
;
17331 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
17332 enum tree_code opcode
= NOP_EXPR
;
17333 if (code
== OMP_ATOMIC_READ
)
17335 v
= RECUR (TREE_OPERAND (op1
, 0));
17336 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
17338 else if (code
== OMP_ATOMIC_CAPTURE_OLD
17339 || code
== OMP_ATOMIC_CAPTURE_NEW
)
17341 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
17342 v
= RECUR (TREE_OPERAND (op1
, 0));
17343 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
17344 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
17346 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
17347 op11
= TREE_OPERAND (op11
, 1);
17349 lhs
= RECUR (TREE_OPERAND (op11
, 0));
17350 rhs
= RECUR (TREE_OPERAND (op11
, 1));
17351 opcode
= TREE_CODE (op11
);
17352 if (opcode
== MODIFY_EXPR
)
17358 lhs
= RECUR (TREE_OPERAND (op1
, 0));
17359 rhs
= RECUR (TREE_OPERAND (op1
, 1));
17361 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
17362 OMP_ATOMIC_SEQ_CST (t
));
17366 case TRANSACTION_EXPR
:
17369 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
17370 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
17372 if (TRANSACTION_EXPR_IS_STMT (t
))
17374 tree body
= TRANSACTION_EXPR_BODY (t
);
17375 tree noex
= NULL_TREE
;
17376 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
17378 noex
= MUST_NOT_THROW_COND (body
);
17379 if (noex
== NULL_TREE
)
17380 noex
= boolean_true_node
;
17381 body
= TREE_OPERAND (body
, 0);
17383 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
17385 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
17389 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
17390 RECUR (TRANSACTION_EXPR_BODY (t
)),
17397 case MUST_NOT_THROW_EXPR
:
17399 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17400 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
17401 RETURN (build_must_not_throw_expr (op0
, cond
));
17404 case EXPR_PACK_EXPANSION
:
17405 error ("invalid use of pack expansion expression");
17406 RETURN (error_mark_node
);
17408 case NONTYPE_ARGUMENT_PACK
:
17409 error ("use %<...%> to expand argument pack");
17410 RETURN (error_mark_node
);
17412 case COMPOUND_EXPR
:
17413 tmp
= RECUR (TREE_OPERAND (t
, 0));
17414 if (tmp
== NULL_TREE
)
17415 /* If the first operand was a statement, we're done with it. */
17416 RETURN (RECUR (TREE_OPERAND (t
, 1)));
17417 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
17418 RECUR (TREE_OPERAND (t
, 1)),
17421 case ANNOTATE_EXPR
:
17422 tmp
= RECUR (TREE_OPERAND (t
, 0));
17423 RETURN (build3_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
17424 TREE_TYPE (tmp
), tmp
,
17425 RECUR (TREE_OPERAND (t
, 1)),
17426 RECUR (TREE_OPERAND (t
, 2))));
17429 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
17431 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
17432 /*function_p=*/false,
17433 integral_constant_expression_p
));
17436 RETURN (NULL_TREE
);
17438 input_location
= loc
;
17444 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
17445 function. For description of the body see comment above
17446 cp_parser_omp_declare_reduction_exprs. */
17449 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
17451 if (t
== NULL_TREE
|| t
== error_mark_node
)
17454 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
17456 tree_stmt_iterator tsi
;
17459 memset (stmts
, 0, sizeof stmts
);
17460 for (i
= 0, tsi
= tsi_start (t
);
17461 i
< 7 && !tsi_end_p (tsi
);
17462 i
++, tsi_next (&tsi
))
17463 stmts
[i
] = tsi_stmt (tsi
);
17464 gcc_assert (tsi_end_p (tsi
));
17468 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
17469 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
17470 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
17471 args
, complain
, in_decl
);
17472 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
17473 args
, complain
, in_decl
);
17474 DECL_CONTEXT (omp_out
) = current_function_decl
;
17475 DECL_CONTEXT (omp_in
) = current_function_decl
;
17476 keep_next_level (true);
17477 tree block
= begin_omp_structured_block ();
17478 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
17479 block
= finish_omp_structured_block (block
);
17480 block
= maybe_cleanup_point_expr_void (block
);
17481 add_decl_expr (omp_out
);
17482 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
17483 TREE_NO_WARNING (omp_out
) = 1;
17484 add_decl_expr (omp_in
);
17485 finish_expr_stmt (block
);
17489 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
17490 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
17491 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
17492 args
, complain
, in_decl
);
17493 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
17494 args
, complain
, in_decl
);
17495 DECL_CONTEXT (omp_priv
) = current_function_decl
;
17496 DECL_CONTEXT (omp_orig
) = current_function_decl
;
17497 keep_next_level (true);
17498 tree block
= begin_omp_structured_block ();
17499 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
17500 block
= finish_omp_structured_block (block
);
17501 block
= maybe_cleanup_point_expr_void (block
);
17502 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
17503 add_decl_expr (omp_priv
);
17504 add_decl_expr (omp_orig
);
17505 finish_expr_stmt (block
);
17507 add_decl_expr (omp_orig
);
17511 /* T is a postfix-expression that is not being used in a function
17512 call. Return the substituted version of T. */
17515 tsubst_non_call_postfix_expression (tree t
, tree args
,
17516 tsubst_flags_t complain
,
17519 if (TREE_CODE (t
) == SCOPE_REF
)
17520 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
17521 /*done=*/false, /*address_p=*/false);
17523 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
17524 /*function_p=*/false,
17525 /*integral_constant_expression_p=*/false);
17530 /* T is a LAMBDA_EXPR. Generate a new LAMBDA_EXPR for the current
17531 instantiation context. Instantiating a pack expansion containing a lambda
17532 might result in multiple lambdas all based on the same lambda in the
17536 tsubst_lambda_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
17538 tree oldfn
= lambda_function (t
);
17541 tree r
= build_lambda_expr ();
17543 LAMBDA_EXPR_LOCATION (r
)
17544 = LAMBDA_EXPR_LOCATION (t
);
17545 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
17546 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
17547 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
17549 if (LAMBDA_EXPR_EXTRA_SCOPE (t
) == NULL_TREE
)
17550 /* A lambda in a default argument outside a class gets no
17551 LAMBDA_EXPR_EXTRA_SCOPE, as specified by the ABI. But
17552 tsubst_default_argument calls start_lambda_scope, so we need to
17553 specifically ignore it here, and use the global scope. */
17554 record_null_lambda_scope (r
);
17556 record_lambda_scope (r
);
17558 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
17559 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
17561 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
); cap
;
17562 cap
= TREE_CHAIN (cap
))
17564 tree field
= TREE_PURPOSE (cap
);
17565 if (PACK_EXPANSION_P (field
))
17566 field
= PACK_EXPANSION_PATTERN (field
);
17567 field
= tsubst_decl (field
, args
, complain
);
17569 if (field
== error_mark_node
)
17570 return error_mark_node
;
17572 tree init
= TREE_VALUE (cap
);
17573 if (PACK_EXPANSION_P (init
))
17574 init
= tsubst_pack_expansion (init
, args
, complain
, in_decl
);
17576 init
= tsubst_copy_and_build (init
, args
, complain
, in_decl
,
17577 /*fn*/false, /*constexpr*/false);
17579 if (TREE_CODE (field
) == TREE_VEC
)
17581 int len
= TREE_VEC_LENGTH (field
);
17582 gcc_assert (TREE_CODE (init
) == TREE_VEC
17583 && TREE_VEC_LENGTH (init
) == len
);
17584 for (int i
= 0; i
< len
; ++i
)
17585 LAMBDA_EXPR_CAPTURE_LIST (r
)
17586 = tree_cons (TREE_VEC_ELT (field
, i
),
17587 TREE_VEC_ELT (init
, i
),
17588 LAMBDA_EXPR_CAPTURE_LIST (r
));
17592 LAMBDA_EXPR_CAPTURE_LIST (r
)
17593 = tree_cons (field
, init
, LAMBDA_EXPR_CAPTURE_LIST (r
));
17595 if (id_equal (DECL_NAME (field
), "__this"))
17596 LAMBDA_EXPR_THIS_CAPTURE (r
) = field
;
17600 tree type
= begin_lambda_type (r
);
17601 if (type
== error_mark_node
)
17602 return error_mark_node
;
17604 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
17605 determine_visibility (TYPE_NAME (type
));
17607 register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (r
));
17609 tree oldtmpl
= (generic_lambda_fn_p (oldfn
)
17610 ? DECL_TI_TEMPLATE (oldfn
)
17613 tree fntype
= static_fn_type (oldfn
);
17615 ++processing_template_decl
;
17616 fntype
= tsubst (fntype
, args
, complain
, in_decl
);
17618 --processing_template_decl
;
17620 if (fntype
== error_mark_node
)
17621 r
= error_mark_node
;
17624 /* Fix the type of 'this'. */
17625 fntype
= build_memfn_type (fntype
, type
,
17626 type_memfn_quals (fntype
),
17627 type_memfn_rqual (fntype
));
17631 tmpl
= tsubst_template_decl (oldtmpl
, args
, complain
, fntype
);
17632 fn
= DECL_TEMPLATE_RESULT (tmpl
);
17633 finish_member_declaration (tmpl
);
17638 fn
= tsubst_function_decl (oldfn
, args
, complain
, fntype
);
17639 finish_member_declaration (fn
);
17642 /* Let finish_function set this. */
17643 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
17645 bool nested
= cfun
;
17647 push_function_context ();
17649 /* Still increment function_depth so that we don't GC in the
17650 middle of an expression. */
17653 local_specialization_stack
s (lss_copy
);
17655 tree body
= start_lambda_function (fn
, r
);
17657 register_parameter_specializations (oldfn
, fn
);
17661 /* We might not partially instantiate some parts of the function, so
17662 copy these flags from the original template. */
17663 language_function
*ol
= DECL_STRUCT_FUNCTION (oldfn
)->language
;
17664 current_function_returns_value
= ol
->returns_value
;
17665 current_function_returns_null
= ol
->returns_null
;
17666 current_function_returns_abnormally
= ol
->returns_abnormally
;
17667 current_function_infinite_loop
= ol
->infinite_loop
;
17670 tsubst_expr (DECL_SAVED_TREE (oldfn
), args
, complain
, r
,
17671 /*constexpr*/false);
17673 finish_lambda_function (body
);
17676 pop_function_context ();
17680 /* The capture list was built up in reverse order; fix that now. */
17681 LAMBDA_EXPR_CAPTURE_LIST (r
)
17682 = nreverse (LAMBDA_EXPR_CAPTURE_LIST (r
));
17684 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
17686 maybe_add_lambda_conv_op (type
);
17689 finish_struct (type
, /*attr*/NULL_TREE
);
17691 insert_pending_capture_proxies ();
17696 /* Like tsubst but deals with expressions and performs semantic
17697 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
17700 tsubst_copy_and_build (tree t
,
17702 tsubst_flags_t complain
,
17705 bool integral_constant_expression_p
)
17707 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
17708 #define RECUR(NODE) \
17709 tsubst_copy_and_build (NODE, args, complain, in_decl, \
17710 /*function_p=*/false, \
17711 integral_constant_expression_p)
17716 if (t
== NULL_TREE
|| t
== error_mark_node
)
17719 loc
= input_location
;
17720 if (location_t eloc
= cp_expr_location (t
))
17721 input_location
= eloc
;
17723 /* N3276 decltype magic only applies to calls at the top level or on the
17724 right side of a comma. */
17725 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
17726 complain
&= ~tf_decltype
;
17728 switch (TREE_CODE (t
))
17732 /* Fall through. */
17733 case IDENTIFIER_NODE
:
17737 bool non_integral_constant_expression_p
;
17738 const char *error_msg
;
17740 if (IDENTIFIER_CONV_OP_P (t
))
17742 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17743 t
= make_conv_op_name (new_type
);
17746 /* Look up the name. */
17747 decl
= lookup_name (t
);
17749 /* By convention, expressions use ERROR_MARK_NODE to indicate
17750 failure, not NULL_TREE. */
17751 if (decl
== NULL_TREE
)
17752 decl
= error_mark_node
;
17754 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
17756 integral_constant_expression_p
,
17757 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
17758 &non_integral_constant_expression_p
,
17759 /*template_p=*/false,
17761 /*address_p=*/false,
17762 /*template_arg_p=*/false,
17767 if (!function_p
&& identifier_p (decl
))
17769 if (complain
& tf_error
)
17770 unqualified_name_lookup_error (decl
);
17771 decl
= error_mark_node
;
17776 case TEMPLATE_ID_EXPR
:
17779 tree templ
= RECUR (TREE_OPERAND (t
, 0));
17780 tree targs
= TREE_OPERAND (t
, 1);
17783 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
17784 if (targs
== error_mark_node
)
17785 RETURN (error_mark_node
);
17787 if (TREE_CODE (templ
) == SCOPE_REF
)
17789 tree name
= TREE_OPERAND (templ
, 1);
17790 tree tid
= lookup_template_function (name
, targs
);
17791 TREE_OPERAND (templ
, 1) = tid
;
17795 if (variable_template_p (templ
))
17796 RETURN (lookup_and_finish_template_variable (templ
, targs
, complain
));
17798 if (TREE_CODE (templ
) == COMPONENT_REF
)
17800 object
= TREE_OPERAND (templ
, 0);
17801 templ
= TREE_OPERAND (templ
, 1);
17804 object
= NULL_TREE
;
17805 templ
= lookup_template_function (templ
, targs
);
17808 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
17809 object
, templ
, NULL_TREE
));
17811 RETURN (baselink_for_fns (templ
));
17816 tree r
= RECUR (TREE_OPERAND (t
, 0));
17818 if (REFERENCE_REF_P (t
))
17820 /* A type conversion to reference type will be enclosed in
17821 such an indirect ref, but the substitution of the cast
17822 will have also added such an indirect ref. */
17823 r
= convert_from_reference (r
);
17826 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
17827 complain
|decltype_flag
);
17829 if (REF_PARENTHESIZED_P (t
))
17830 r
= force_paren_expr (r
);
17837 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17838 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17839 RETURN (build_nop (type
, op0
));
17842 case IMPLICIT_CONV_EXPR
:
17844 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17845 tree expr
= RECUR (TREE_OPERAND (t
, 0));
17846 if (dependent_type_p (type
) || type_dependent_expression_p (expr
))
17848 retval
= copy_node (t
);
17849 TREE_TYPE (retval
) = type
;
17850 TREE_OPERAND (retval
, 0) = expr
;
17853 if (IMPLICIT_CONV_EXPR_NONTYPE_ARG (t
))
17854 /* We'll pass this to convert_nontype_argument again, we don't need
17855 to actually perform any conversion here. */
17857 int flags
= LOOKUP_IMPLICIT
;
17858 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
17859 flags
= LOOKUP_NORMAL
;
17860 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
17866 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17867 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17868 if (op0
== error_mark_node
)
17869 RETURN (error_mark_node
);
17870 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
17874 case REINTERPRET_CAST_EXPR
:
17875 case CONST_CAST_EXPR
:
17876 case DYNAMIC_CAST_EXPR
:
17877 case STATIC_CAST_EXPR
:
17880 tree op
, r
= NULL_TREE
;
17882 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17883 if (integral_constant_expression_p
17884 && !cast_valid_in_integral_constant_expression_p (type
))
17886 if (complain
& tf_error
)
17887 error ("a cast to a type other than an integral or "
17888 "enumeration type cannot appear in a constant-expression");
17889 RETURN (error_mark_node
);
17892 op
= RECUR (TREE_OPERAND (t
, 0));
17894 warning_sentinel
s(warn_useless_cast
);
17895 warning_sentinel
s2(warn_ignored_qualifiers
);
17896 switch (TREE_CODE (t
))
17899 r
= build_functional_cast (type
, op
, complain
);
17901 case REINTERPRET_CAST_EXPR
:
17902 r
= build_reinterpret_cast (type
, op
, complain
);
17904 case CONST_CAST_EXPR
:
17905 r
= build_const_cast (type
, op
, complain
);
17907 case DYNAMIC_CAST_EXPR
:
17908 r
= build_dynamic_cast (type
, op
, complain
);
17910 case STATIC_CAST_EXPR
:
17911 r
= build_static_cast (type
, op
, complain
);
17914 gcc_unreachable ();
17920 case POSTDECREMENT_EXPR
:
17921 case POSTINCREMENT_EXPR
:
17922 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
17923 args
, complain
, in_decl
);
17924 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
17925 complain
|decltype_flag
));
17927 case PREDECREMENT_EXPR
:
17928 case PREINCREMENT_EXPR
:
17932 case TRUTH_NOT_EXPR
:
17933 case UNARY_PLUS_EXPR
: /* Unary + */
17934 case REALPART_EXPR
:
17935 case IMAGPART_EXPR
:
17936 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
17937 RECUR (TREE_OPERAND (t
, 0)),
17938 complain
|decltype_flag
));
17940 case FIX_TRUNC_EXPR
:
17941 gcc_unreachable ();
17944 op1
= TREE_OPERAND (t
, 0);
17945 if (TREE_CODE (op1
) == LABEL_DECL
)
17946 RETURN (finish_label_address_expr (DECL_NAME (op1
),
17947 EXPR_LOCATION (op1
)));
17948 if (TREE_CODE (op1
) == SCOPE_REF
)
17949 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
17950 /*done=*/true, /*address_p=*/true);
17952 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
17954 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
17955 complain
|decltype_flag
));
17960 case TRUNC_DIV_EXPR
:
17961 case CEIL_DIV_EXPR
:
17962 case FLOOR_DIV_EXPR
:
17963 case ROUND_DIV_EXPR
:
17964 case EXACT_DIV_EXPR
:
17968 case TRUNC_MOD_EXPR
:
17969 case FLOOR_MOD_EXPR
:
17970 case TRUTH_ANDIF_EXPR
:
17971 case TRUTH_ORIF_EXPR
:
17972 case TRUTH_AND_EXPR
:
17973 case TRUTH_OR_EXPR
:
17989 warning_sentinel
s1(warn_type_limits
);
17990 warning_sentinel
s2(warn_div_by_zero
);
17991 warning_sentinel
s3(warn_logical_op
);
17992 warning_sentinel
s4(warn_tautological_compare
);
17993 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17994 tree op1
= RECUR (TREE_OPERAND (t
, 1));
17995 tree r
= build_x_binary_op
17996 (input_location
, TREE_CODE (t
),
17998 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
18000 : TREE_CODE (TREE_OPERAND (t
, 0))),
18002 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
18004 : TREE_CODE (TREE_OPERAND (t
, 1))),
18006 complain
|decltype_flag
);
18007 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
18008 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
18013 case POINTER_PLUS_EXPR
:
18015 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18016 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18017 RETURN (fold_build_pointer_plus (op0
, op1
));
18021 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
18022 /*address_p=*/false));
18024 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
18025 args
, complain
, in_decl
);
18026 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
18027 RECUR (TREE_OPERAND (t
, 1)),
18028 complain
|decltype_flag
));
18031 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
18032 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
18033 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
18040 op1
= TREE_OPERAND (t
, 0);
18041 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
18042 op1
= TREE_TYPE (op1
);
18043 bool std_alignof
= (TREE_CODE (t
) == ALIGNOF_EXPR
18044 && ALIGNOF_EXPR_STD_P (t
));
18047 /* When there are no ARGS, we are trying to evaluate a
18048 non-dependent expression from the parser. Trying to do
18049 the substitutions may not work. */
18051 op1
= TREE_TYPE (op1
);
18055 ++cp_unevaluated_operand
;
18056 ++c_inhibit_evaluation_warnings
;
18058 op1
= tsubst (op1
, args
, complain
, in_decl
);
18060 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
18061 /*function_p=*/false,
18062 /*integral_constant_expression_p=*/
18064 --cp_unevaluated_operand
;
18065 --c_inhibit_evaluation_warnings
;
18068 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
), std_alignof
,
18069 complain
& tf_error
);
18071 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
18072 complain
& tf_error
);
18073 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
18075 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
18077 if (!processing_template_decl
&& TYPE_P (op1
))
18079 r
= build_min (SIZEOF_EXPR
, size_type_node
,
18080 build1 (NOP_EXPR
, op1
, error_mark_node
));
18081 SIZEOF_EXPR_TYPE_P (r
) = 1;
18084 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
18085 TREE_SIDE_EFFECTS (r
) = 0;
18086 TREE_READONLY (r
) = 1;
18088 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
18093 case AT_ENCODE_EXPR
:
18095 op1
= TREE_OPERAND (t
, 0);
18096 ++cp_unevaluated_operand
;
18097 ++c_inhibit_evaluation_warnings
;
18098 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
18099 /*function_p=*/false,
18100 /*integral_constant_expression_p=*/false);
18101 --cp_unevaluated_operand
;
18102 --c_inhibit_evaluation_warnings
;
18103 RETURN (objc_build_encode_expr (op1
));
18106 case NOEXCEPT_EXPR
:
18107 op1
= TREE_OPERAND (t
, 0);
18108 ++cp_unevaluated_operand
;
18109 ++c_inhibit_evaluation_warnings
;
18110 ++cp_noexcept_operand
;
18111 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
18112 /*function_p=*/false,
18113 /*integral_constant_expression_p=*/false);
18114 --cp_unevaluated_operand
;
18115 --c_inhibit_evaluation_warnings
;
18116 --cp_noexcept_operand
;
18117 RETURN (finish_noexcept_expr (op1
, complain
));
18121 warning_sentinel
s(warn_div_by_zero
);
18122 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
18123 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
18124 tree r
= build_x_modify_expr
18125 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
18126 complain
|decltype_flag
);
18127 /* TREE_NO_WARNING must be set if either the expression was
18128 parenthesized or it uses an operator such as >>= rather
18129 than plain assignment. In the former case, it was already
18130 set and must be copied. In the latter case,
18131 build_x_modify_expr sets it and it must not be reset
18133 if (TREE_NO_WARNING (t
))
18134 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
18140 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
18141 args
, complain
, in_decl
);
18142 /* Remember that there was a reference to this entity. */
18144 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
18145 RETURN (error_mark_node
);
18146 RETURN (build_x_arrow (input_location
, op1
, complain
));
18150 tree placement
= RECUR (TREE_OPERAND (t
, 0));
18151 tree init
= RECUR (TREE_OPERAND (t
, 3));
18152 vec
<tree
, va_gc
> *placement_vec
;
18153 vec
<tree
, va_gc
> *init_vec
;
18156 if (placement
== NULL_TREE
)
18157 placement_vec
= NULL
;
18160 placement_vec
= make_tree_vector ();
18161 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
18162 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
18165 /* If there was an initializer in the original tree, but it
18166 instantiated to an empty list, then we should pass a
18167 non-NULL empty vector to tell build_new that it was an
18168 empty initializer() rather than no initializer. This can
18169 only happen when the initializer is a pack expansion whose
18170 parameter packs are of length zero. */
18171 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
18175 init_vec
= make_tree_vector ();
18176 if (init
== void_node
)
18177 gcc_assert (init_vec
!= NULL
);
18180 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
18181 vec_safe_push (init_vec
, TREE_VALUE (init
));
18185 /* Avoid passing an enclosing decl to valid_array_size_p. */
18186 in_decl
= NULL_TREE
;
18188 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
18189 tree op2
= RECUR (TREE_OPERAND (t
, 2));
18190 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
18191 NEW_EXPR_USE_GLOBAL (t
),
18194 if (placement_vec
!= NULL
)
18195 release_tree_vector (placement_vec
);
18196 if (init_vec
!= NULL
)
18197 release_tree_vector (init_vec
);
18204 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18205 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18206 RETURN (delete_sanity (op0
, op1
,
18207 DELETE_EXPR_USE_VEC (t
),
18208 DELETE_EXPR_USE_GLOBAL (t
),
18212 case COMPOUND_EXPR
:
18214 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
18215 complain
& ~tf_decltype
, in_decl
,
18216 /*function_p=*/false,
18217 integral_constant_expression_p
);
18218 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
18220 RECUR (TREE_OPERAND (t
, 1)),
18221 complain
|decltype_flag
));
18227 vec
<tree
, va_gc
> *call_args
;
18228 unsigned int nargs
, i
;
18233 function
= CALL_EXPR_FN (t
);
18234 /* Internal function with no arguments. */
18235 if (function
== NULL_TREE
&& call_expr_nargs (t
) == 0)
18238 /* When we parsed the expression, we determined whether or
18239 not Koenig lookup should be performed. */
18240 koenig_p
= KOENIG_LOOKUP_P (t
);
18241 if (function
== NULL_TREE
)
18244 qualified_p
= false;
18246 else if (TREE_CODE (function
) == SCOPE_REF
)
18248 qualified_p
= true;
18249 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
18251 /*address_p=*/false);
18253 else if (koenig_p
&& identifier_p (function
))
18255 /* Do nothing; calling tsubst_copy_and_build on an identifier
18256 would incorrectly perform unqualified lookup again.
18258 Note that we can also have an IDENTIFIER_NODE if the earlier
18259 unqualified lookup found a member function; in that case
18260 koenig_p will be false and we do want to do the lookup
18261 again to find the instantiated member function.
18263 FIXME but doing that causes c++/15272, so we need to stop
18264 using IDENTIFIER_NODE in that situation. */
18265 qualified_p
= false;
18269 if (TREE_CODE (function
) == COMPONENT_REF
)
18271 tree op
= TREE_OPERAND (function
, 1);
18273 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
18274 || (BASELINK_P (op
)
18275 && BASELINK_QUALIFIED_P (op
)));
18278 qualified_p
= false;
18280 if (TREE_CODE (function
) == ADDR_EXPR
18281 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
18282 /* Avoid error about taking the address of a constructor. */
18283 function
= TREE_OPERAND (function
, 0);
18285 function
= tsubst_copy_and_build (function
, args
, complain
,
18288 integral_constant_expression_p
);
18290 if (BASELINK_P (function
))
18291 qualified_p
= true;
18294 nargs
= call_expr_nargs (t
);
18295 call_args
= make_tree_vector ();
18296 for (i
= 0; i
< nargs
; ++i
)
18298 tree arg
= CALL_EXPR_ARG (t
, i
);
18300 if (!PACK_EXPANSION_P (arg
))
18301 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
18304 /* Expand the pack expansion and push each entry onto
18306 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
18307 if (TREE_CODE (arg
) == TREE_VEC
)
18309 unsigned int len
, j
;
18311 len
= TREE_VEC_LENGTH (arg
);
18312 for (j
= 0; j
< len
; ++j
)
18314 tree value
= TREE_VEC_ELT (arg
, j
);
18315 if (value
!= NULL_TREE
)
18316 value
= convert_from_reference (value
);
18317 vec_safe_push (call_args
, value
);
18322 /* A partial substitution. Add one entry. */
18323 vec_safe_push (call_args
, arg
);
18328 /* We do not perform argument-dependent lookup if normal
18329 lookup finds a non-function, in accordance with the
18330 expected resolution of DR 218. */
18332 && ((is_overloaded_fn (function
)
18333 /* If lookup found a member function, the Koenig lookup is
18334 not appropriate, even if an unqualified-name was used
18335 to denote the function. */
18336 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
18337 || identifier_p (function
))
18338 /* Only do this when substitution turns a dependent call
18339 into a non-dependent call. */
18340 && type_dependent_expression_p_push (t
)
18341 && !any_type_dependent_arguments_p (call_args
))
18342 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
18344 if (function
!= NULL_TREE
18345 && identifier_p (function
)
18346 && !any_type_dependent_arguments_p (call_args
))
18348 if (koenig_p
&& (complain
& tf_warning_or_error
))
18350 /* For backwards compatibility and good diagnostics, try
18351 the unqualified lookup again if we aren't in SFINAE
18353 tree unq
= (tsubst_copy_and_build
18354 (function
, args
, complain
, in_decl
, true,
18355 integral_constant_expression_p
));
18356 if (unq
== error_mark_node
)
18358 release_tree_vector (call_args
);
18359 RETURN (error_mark_node
);
18362 if (unq
!= function
)
18364 /* In a lambda fn, we have to be careful to not
18365 introduce new this captures. Legacy code can't
18366 be using lambdas anyway, so it's ok to be
18368 bool in_lambda
= (current_class_type
18369 && LAMBDA_TYPE_P (current_class_type
));
18370 char const *const msg
18371 = G_("%qD was not declared in this scope, "
18372 "and no declarations were found by "
18373 "argument-dependent lookup at the point "
18374 "of instantiation");
18378 error_at (cp_expr_loc_or_loc (t
, input_location
),
18381 diag
= permerror (cp_expr_loc_or_loc (t
, input_location
),
18387 if (INDIRECT_REF_P (fn
))
18388 fn
= TREE_OPERAND (fn
, 0);
18389 if (is_overloaded_fn (fn
))
18390 fn
= get_first_fn (fn
);
18393 /* Can't say anything more. */;
18394 else if (DECL_CLASS_SCOPE_P (fn
))
18396 location_t loc
= cp_expr_loc_or_loc (t
,
18399 "declarations in dependent base %qT are "
18400 "not found by unqualified lookup",
18401 DECL_CLASS_CONTEXT (fn
));
18402 if (current_class_ptr
)
18404 "use %<this->%D%> instead", function
);
18407 "use %<%T::%D%> instead",
18408 current_class_name
, function
);
18411 inform (DECL_SOURCE_LOCATION (fn
),
18412 "%qD declared here, later in the "
18413 "translation unit", fn
);
18416 release_tree_vector (call_args
);
18417 RETURN (error_mark_node
);
18424 if (identifier_p (function
))
18426 if (complain
& tf_error
)
18427 unqualified_name_lookup_error (function
);
18428 release_tree_vector (call_args
);
18429 RETURN (error_mark_node
);
18433 /* Remember that there was a reference to this entity. */
18434 if (function
!= NULL_TREE
18435 && DECL_P (function
)
18436 && !mark_used (function
, complain
) && !(complain
& tf_error
))
18438 release_tree_vector (call_args
);
18439 RETURN (error_mark_node
);
18442 /* Put back tf_decltype for the actual call. */
18443 complain
|= decltype_flag
;
18445 if (function
== NULL_TREE
)
18446 switch (CALL_EXPR_IFN (t
))
18449 gcc_assert (nargs
== 1);
18450 if (vec_safe_length (call_args
) != 1)
18452 error_at (cp_expr_loc_or_loc (t
, input_location
),
18453 "wrong number of arguments to "
18454 "%<__builtin_launder%>");
18455 ret
= error_mark_node
;
18458 ret
= finish_builtin_launder (cp_expr_loc_or_loc (t
,
18460 (*call_args
)[0], complain
);
18464 /* Unsupported internal function with arguments. */
18465 gcc_unreachable ();
18467 else if (TREE_CODE (function
) == OFFSET_REF
18468 || TREE_CODE (function
) == DOTSTAR_EXPR
18469 || TREE_CODE (function
) == MEMBER_REF
)
18470 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
18472 else if (TREE_CODE (function
) == COMPONENT_REF
)
18474 tree instance
= TREE_OPERAND (function
, 0);
18475 tree fn
= TREE_OPERAND (function
, 1);
18477 if (processing_template_decl
18478 && (type_dependent_expression_p (instance
)
18479 || (!BASELINK_P (fn
)
18480 && TREE_CODE (fn
) != FIELD_DECL
)
18481 || type_dependent_expression_p (fn
)
18482 || any_type_dependent_arguments_p (call_args
)))
18483 ret
= build_min_nt_call_vec (function
, call_args
);
18484 else if (!BASELINK_P (fn
))
18485 ret
= finish_call_expr (function
, &call_args
,
18486 /*disallow_virtual=*/false,
18487 /*koenig_p=*/false,
18490 ret
= (build_new_method_call
18492 &call_args
, NULL_TREE
,
18493 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
18498 ret
= finish_call_expr (function
, &call_args
,
18499 /*disallow_virtual=*/qualified_p
,
18503 release_tree_vector (call_args
);
18505 if (ret
!= error_mark_node
)
18507 bool op
= CALL_EXPR_OPERATOR_SYNTAX (t
);
18508 bool ord
= CALL_EXPR_ORDERED_ARGS (t
);
18509 bool rev
= CALL_EXPR_REVERSE_ARGS (t
);
18510 bool thk
= CALL_FROM_THUNK_P (t
);
18511 if (op
|| ord
|| rev
|| thk
)
18513 function
= extract_call_expr (ret
);
18514 CALL_EXPR_OPERATOR_SYNTAX (function
) = op
;
18515 CALL_EXPR_ORDERED_ARGS (function
) = ord
;
18516 CALL_EXPR_REVERSE_ARGS (function
) = rev
;
18519 if (TREE_CODE (function
) == CALL_EXPR
)
18520 CALL_FROM_THUNK_P (function
) = true;
18522 AGGR_INIT_FROM_THUNK_P (function
) = true;
18523 /* The thunk location is not interesting. */
18524 SET_EXPR_LOCATION (function
, UNKNOWN_LOCATION
);
18534 tree cond
= RECUR (TREE_OPERAND (t
, 0));
18535 cond
= mark_rvalue_use (cond
);
18536 tree folded_cond
= fold_non_dependent_expr (cond
, complain
);
18539 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
18541 if (integer_zerop (folded_cond
))
18543 ++c_inhibit_evaluation_warnings
;
18544 exp1
= RECUR (TREE_OPERAND (t
, 1));
18545 --c_inhibit_evaluation_warnings
;
18546 exp2
= RECUR (TREE_OPERAND (t
, 2));
18550 exp1
= RECUR (TREE_OPERAND (t
, 1));
18551 ++c_inhibit_evaluation_warnings
;
18552 exp2
= RECUR (TREE_OPERAND (t
, 2));
18553 --c_inhibit_evaluation_warnings
;
18555 cond
= folded_cond
;
18559 exp1
= RECUR (TREE_OPERAND (t
, 1));
18560 exp2
= RECUR (TREE_OPERAND (t
, 2));
18563 warning_sentinel
s(warn_duplicated_branches
);
18564 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
18565 cond
, exp1
, exp2
, complain
));
18568 case PSEUDO_DTOR_EXPR
:
18570 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18571 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18572 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
18573 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
18579 tree purpose
, value
, chain
;
18581 if (t
== void_list_node
)
18584 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
18585 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
18587 /* We have pack expansions, so expand those and
18588 create a new list out of it. */
18589 tree purposevec
= NULL_TREE
;
18590 tree valuevec
= NULL_TREE
;
18594 /* Expand the argument expressions. */
18595 if (TREE_PURPOSE (t
))
18596 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
18597 complain
, in_decl
);
18598 if (TREE_VALUE (t
))
18599 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
18600 complain
, in_decl
);
18602 /* Build the rest of the list. */
18603 chain
= TREE_CHAIN (t
);
18604 if (chain
&& chain
!= void_type_node
)
18605 chain
= RECUR (chain
);
18607 /* Determine the number of arguments. */
18608 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
18610 len
= TREE_VEC_LENGTH (purposevec
);
18611 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
18613 else if (TREE_CODE (valuevec
) == TREE_VEC
)
18614 len
= TREE_VEC_LENGTH (valuevec
);
18617 /* Since we only performed a partial substitution into
18618 the argument pack, we only RETURN (a single list
18620 if (purposevec
== TREE_PURPOSE (t
)
18621 && valuevec
== TREE_VALUE (t
)
18622 && chain
== TREE_CHAIN (t
))
18625 RETURN (tree_cons (purposevec
, valuevec
, chain
));
18628 /* Convert the argument vectors into a TREE_LIST */
18632 /* Grab the Ith values. */
18634 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
18637 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
18640 /* Build the list (backwards). */
18641 chain
= tree_cons (purpose
, value
, chain
);
18647 purpose
= TREE_PURPOSE (t
);
18649 purpose
= RECUR (purpose
);
18650 value
= TREE_VALUE (t
);
18652 value
= RECUR (value
);
18653 chain
= TREE_CHAIN (t
);
18654 if (chain
&& chain
!= void_type_node
)
18655 chain
= RECUR (chain
);
18656 if (purpose
== TREE_PURPOSE (t
)
18657 && value
== TREE_VALUE (t
)
18658 && chain
== TREE_CHAIN (t
))
18660 RETURN (tree_cons (purpose
, value
, chain
));
18663 case COMPONENT_REF
:
18670 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
18671 args
, complain
, in_decl
);
18672 /* Remember that there was a reference to this entity. */
18673 if (DECL_P (object
)
18674 && !mark_used (object
, complain
) && !(complain
& tf_error
))
18675 RETURN (error_mark_node
);
18676 object_type
= TREE_TYPE (object
);
18678 member
= TREE_OPERAND (t
, 1);
18679 if (BASELINK_P (member
))
18680 member
= tsubst_baselink (member
,
18681 non_reference (TREE_TYPE (object
)),
18682 args
, complain
, in_decl
);
18684 member
= tsubst_copy (member
, args
, complain
, in_decl
);
18685 if (member
== error_mark_node
)
18686 RETURN (error_mark_node
);
18688 if (TREE_CODE (member
) == FIELD_DECL
)
18690 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
18691 if (TREE_CODE (r
) == COMPONENT_REF
)
18692 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
18695 else if (type_dependent_expression_p (object
))
18696 /* We can't do much here. */;
18697 else if (!CLASS_TYPE_P (object_type
))
18699 if (scalarish_type_p (object_type
))
18701 tree s
= NULL_TREE
;
18702 tree dtor
= member
;
18704 if (TREE_CODE (dtor
) == SCOPE_REF
)
18706 s
= TREE_OPERAND (dtor
, 0);
18707 dtor
= TREE_OPERAND (dtor
, 1);
18709 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
18711 dtor
= TREE_OPERAND (dtor
, 0);
18713 RETURN (finish_pseudo_destructor_expr
18714 (object
, s
, dtor
, input_location
));
18718 else if (TREE_CODE (member
) == SCOPE_REF
18719 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
18721 /* Lookup the template functions now that we know what the
18723 tree scope
= TREE_OPERAND (member
, 0);
18724 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
18725 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
18726 member
= lookup_qualified_name (scope
, tmpl
,
18727 /*is_type_p=*/false,
18728 /*complain=*/false);
18729 if (BASELINK_P (member
))
18731 BASELINK_FUNCTIONS (member
)
18732 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
18734 member
= (adjust_result_of_qualified_name_lookup
18735 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
18740 qualified_name_lookup_error (scope
, tmpl
, member
,
18742 RETURN (error_mark_node
);
18745 else if (TREE_CODE (member
) == SCOPE_REF
18746 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
18747 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
18749 if (complain
& tf_error
)
18751 if (TYPE_P (TREE_OPERAND (member
, 0)))
18752 error ("%qT is not a class or namespace",
18753 TREE_OPERAND (member
, 0));
18755 error ("%qD is not a class or namespace",
18756 TREE_OPERAND (member
, 0));
18758 RETURN (error_mark_node
);
18761 r
= finish_class_member_access_expr (object
, member
,
18762 /*template_p=*/false,
18764 if (TREE_CODE (r
) == COMPONENT_REF
)
18765 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
18770 RETURN (build_throw
18771 (RECUR (TREE_OPERAND (t
, 0))));
18775 vec
<constructor_elt
, va_gc
> *n
;
18776 constructor_elt
*ce
;
18777 unsigned HOST_WIDE_INT idx
;
18778 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18779 bool process_index_p
;
18781 bool need_copy_p
= false;
18784 if (type
== error_mark_node
)
18785 RETURN (error_mark_node
);
18787 /* We do not want to process the index of aggregate
18788 initializers as they are identifier nodes which will be
18789 looked up by digest_init. */
18790 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
18792 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
18793 newlen
= vec_safe_length (n
);
18794 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
18796 if (ce
->index
&& process_index_p
18797 /* An identifier index is looked up in the type
18798 being initialized, not the current scope. */
18799 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
18800 ce
->index
= RECUR (ce
->index
);
18802 if (PACK_EXPANSION_P (ce
->value
))
18804 /* Substitute into the pack expansion. */
18805 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
18808 if (ce
->value
== error_mark_node
18809 || PACK_EXPANSION_P (ce
->value
))
18811 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
18812 /* Just move the argument into place. */
18813 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
18816 /* Update the length of the final CONSTRUCTOR
18817 arguments vector, and note that we will need to
18819 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
18820 need_copy_p
= true;
18824 ce
->value
= RECUR (ce
->value
);
18829 vec
<constructor_elt
, va_gc
> *old_n
= n
;
18831 vec_alloc (n
, newlen
);
18832 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
18834 if (TREE_CODE (ce
->value
) == TREE_VEC
)
18836 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
18837 for (i
= 0; i
< len
; ++i
)
18838 CONSTRUCTOR_APPEND_ELT (n
, 0,
18839 TREE_VEC_ELT (ce
->value
, i
));
18842 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
18846 r
= build_constructor (init_list_type_node
, n
);
18847 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
18849 if (TREE_HAS_CONSTRUCTOR (t
))
18851 fcl_t cl
= fcl_functional
;
18852 if (CONSTRUCTOR_C99_COMPOUND_LITERAL (t
))
18854 RETURN (finish_compound_literal (type
, r
, complain
, cl
));
18857 TREE_TYPE (r
) = type
;
18863 tree operand_0
= TREE_OPERAND (t
, 0);
18864 if (TYPE_P (operand_0
))
18866 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
18867 RETURN (get_typeid (operand_0
, complain
));
18871 operand_0
= RECUR (operand_0
);
18872 RETURN (build_typeid (operand_0
, complain
));
18883 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
18884 /* ??? We're doing a subset of finish_id_expression here. */
18886 && !processing_template_decl
18887 && !cp_unevaluated_operand
18888 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
18889 && CP_DECL_THREAD_LOCAL_P (r
))
18891 if (tree wrap
= get_tls_wrapper_fn (r
))
18892 /* Replace an evaluated use of the thread_local variable with
18893 a call to its wrapper. */
18894 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
18896 else if (outer_automatic_var_p (r
))
18897 r
= process_outer_var_ref (r
, complain
);
18899 if (!TYPE_REF_P (TREE_TYPE (t
)))
18900 /* If the original type was a reference, we'll be wrapped in
18901 the appropriate INDIRECT_REF. */
18902 r
= convert_from_reference (r
);
18908 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18909 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18910 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
18913 case OFFSETOF_EXPR
:
18916 = tsubst_copy_and_build (TREE_OPERAND (t
, 1), args
, complain
,
18917 in_decl
, /*function_p=*/false,
18918 /*integral_constant_expression_p=*/false);
18919 RETURN (finish_offsetof (object_ptr
,
18920 RECUR (TREE_OPERAND (t
, 0)),
18921 EXPR_LOCATION (t
)));
18924 case ADDRESSOF_EXPR
:
18925 RETURN (cp_build_addressof (EXPR_LOCATION (t
),
18926 RECUR (TREE_OPERAND (t
, 0)), complain
));
18930 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
18931 complain
, in_decl
);
18933 tree type2
= TRAIT_EXPR_TYPE2 (t
);
18934 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
18935 type2
= RECUR (type2
);
18937 type2
= tsubst (type2
, args
, complain
, in_decl
);
18939 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
18944 tree old_stmt_expr
= cur_stmt_expr
;
18945 tree stmt_expr
= begin_stmt_expr ();
18947 cur_stmt_expr
= stmt_expr
;
18948 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
18949 integral_constant_expression_p
);
18950 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
18951 cur_stmt_expr
= old_stmt_expr
;
18953 /* If the resulting list of expression statement is empty,
18954 fold it further into void_node. */
18955 if (empty_expr_stmt_p (stmt_expr
))
18956 stmt_expr
= void_node
;
18958 RETURN (stmt_expr
);
18963 tree r
= tsubst_lambda_expr (t
, args
, complain
, in_decl
);
18965 RETURN (build_lambda_object (r
));
18969 /* We can get here for a constant initializer of non-dependent type.
18970 FIXME stop folding in cp_parser_initializer_clause. */
18972 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
18977 case TRANSACTION_EXPR
:
18978 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
18979 integral_constant_expression_p
));
18982 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
18984 case VEC_PERM_EXPR
:
18986 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18987 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18988 tree op2
= RECUR (TREE_OPERAND (t
, 2));
18989 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
18993 case REQUIRES_EXPR
:
18994 RETURN (tsubst_requires_expr (t
, args
, complain
, in_decl
));
18996 case NON_LVALUE_EXPR
:
18997 case VIEW_CONVERT_EXPR
:
18998 /* We should only see these for location wrapper nodes, or within
18999 instantiate_non_dependent_expr (when args is NULL_TREE). */
19000 gcc_assert (location_wrapper_p (t
) || args
== NULL_TREE
);
19001 if (location_wrapper_p (t
))
19002 RETURN (maybe_wrap_with_location (RECUR (TREE_OPERAND (t
, 0)),
19003 EXPR_LOCATION (t
)));
19007 /* Handle Objective-C++ constructs, if appropriate. */
19010 = objcp_tsubst_copy_and_build (t
, args
, complain
,
19011 in_decl
, /*function_p=*/false);
19015 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
19021 input_location
= loc
;
19025 /* Verify that the instantiated ARGS are valid. For type arguments,
19026 make sure that the type's linkage is ok. For non-type arguments,
19027 make sure they are constants if they are integral or enumerations.
19028 Emit an error under control of COMPLAIN, and return TRUE on error. */
19031 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
19033 if (dependent_template_arg_p (t
))
19035 if (ARGUMENT_PACK_P (t
))
19037 tree vec
= ARGUMENT_PACK_ARGS (t
);
19038 int len
= TREE_VEC_LENGTH (vec
);
19039 bool result
= false;
19042 for (i
= 0; i
< len
; ++i
)
19043 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
19047 else if (TYPE_P (t
))
19049 /* [basic.link]: A name with no linkage (notably, the name
19050 of a class or enumeration declared in a local scope)
19051 shall not be used to declare an entity with linkage.
19052 This implies that names with no linkage cannot be used as
19055 DR 757 relaxes this restriction for C++0x. */
19056 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
19057 : no_linkage_check (t
, /*relaxed_p=*/false));
19061 /* DR 488 makes use of a type with no linkage cause
19062 type deduction to fail. */
19063 if (complain
& tf_error
)
19065 if (TYPE_UNNAMED_P (nt
))
19066 error ("%qT is/uses unnamed type", t
);
19068 error ("template argument for %qD uses local type %qT",
19073 /* In order to avoid all sorts of complications, we do not
19074 allow variably-modified types as template arguments. */
19075 else if (variably_modified_type_p (t
, NULL_TREE
))
19077 if (complain
& tf_error
)
19078 error ("%qT is a variably modified type", t
);
19082 /* Class template and alias template arguments should be OK. */
19083 else if (DECL_TYPE_TEMPLATE_P (t
))
19085 /* A non-type argument of integral or enumerated type must be a
19087 else if (TREE_TYPE (t
)
19088 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
19089 && !REFERENCE_REF_P (t
)
19090 && !TREE_CONSTANT (t
))
19092 if (complain
& tf_error
)
19093 error ("integral expression %qE is not constant", t
);
19100 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
19102 int ix
, len
= DECL_NTPARMS (tmpl
);
19103 bool result
= false;
19105 for (ix
= 0; ix
!= len
; ix
++)
19107 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
19110 if (result
&& (complain
& tf_error
))
19111 error (" trying to instantiate %qD", tmpl
);
19115 /* We're out of SFINAE context now, so generate diagnostics for the access
19116 errors we saw earlier when instantiating D from TMPL and ARGS. */
19119 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
19121 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19122 tree type
= TREE_TYPE (pattern
);
19123 location_t loc
= input_location
;
19125 push_access_scope (d
);
19126 push_deferring_access_checks (dk_no_deferred
);
19127 input_location
= DECL_SOURCE_LOCATION (pattern
);
19128 tsubst (type
, args
, tf_warning_or_error
, d
);
19129 input_location
= loc
;
19130 pop_deferring_access_checks ();
19131 pop_access_scope (d
);
19134 /* Instantiate the indicated variable, function, or alias template TMPL with
19135 the template arguments in TARG_PTR. */
19138 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
19140 tree targ_ptr
= orig_args
;
19144 bool access_ok
= true;
19146 if (tmpl
== error_mark_node
)
19147 return error_mark_node
;
19149 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
19151 /* If this function is a clone, handle it specially. */
19152 if (DECL_CLONED_FUNCTION_P (tmpl
))
19157 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
19158 DECL_CLONED_FUNCTION. */
19159 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
19160 targ_ptr
, complain
);
19161 if (spec
== error_mark_node
)
19162 return error_mark_node
;
19164 /* Look for the clone. */
19165 FOR_EACH_CLONE (clone
, spec
)
19166 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
19168 /* We should always have found the clone by now. */
19169 gcc_unreachable ();
19173 if (targ_ptr
== error_mark_node
)
19174 return error_mark_node
;
19176 /* Check to see if we already have this specialization. */
19177 gen_tmpl
= most_general_template (tmpl
);
19178 if (TMPL_ARGS_DEPTH (targ_ptr
)
19179 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
)))
19180 /* targ_ptr only has the innermost template args, so add the outer ones
19181 from tmpl, which could be either a partial instantiation or gen_tmpl (in
19182 the case of a non-dependent call within a template definition). */
19183 targ_ptr
= (add_outermost_template_args
19184 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (tmpl
)),
19187 /* It would be nice to avoid hashing here and then again in tsubst_decl,
19188 but it doesn't seem to be on the hot path. */
19189 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
19191 gcc_assert (tmpl
== gen_tmpl
19192 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
19194 || fndecl
== NULL_TREE
);
19196 if (spec
!= NULL_TREE
)
19198 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
19200 if (complain
& tf_error
)
19201 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
19202 return error_mark_node
;
19207 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
19209 return error_mark_node
;
19211 /* We are building a FUNCTION_DECL, during which the access of its
19212 parameters and return types have to be checked. However this
19213 FUNCTION_DECL which is the desired context for access checking
19214 is not built yet. We solve this chicken-and-egg problem by
19215 deferring all checks until we have the FUNCTION_DECL. */
19216 push_deferring_access_checks (dk_deferred
);
19218 /* Instantiation of the function happens in the context of the function
19219 template, not the context of the overload resolution we're doing. */
19220 push_to_top_level ();
19221 /* If there are dependent arguments, e.g. because we're doing partial
19222 ordering, make sure processing_template_decl stays set. */
19223 if (uses_template_parms (targ_ptr
))
19224 ++processing_template_decl
;
19225 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
19227 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
19228 complain
, gen_tmpl
, true);
19229 push_nested_class (ctx
);
19232 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
19234 fndecl
= NULL_TREE
;
19235 if (VAR_P (pattern
))
19237 /* We need to determine if we're using a partial or explicit
19238 specialization now, because the type of the variable could be
19240 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
19241 tree elt
= most_specialized_partial_spec (tid
, complain
);
19242 if (elt
== error_mark_node
)
19243 pattern
= error_mark_node
;
19246 tree partial_tmpl
= TREE_VALUE (elt
);
19247 tree partial_args
= TREE_PURPOSE (elt
);
19248 tree partial_pat
= DECL_TEMPLATE_RESULT (partial_tmpl
);
19249 fndecl
= tsubst (partial_pat
, partial_args
, complain
, gen_tmpl
);
19253 /* Substitute template parameters to obtain the specialization. */
19254 if (fndecl
== NULL_TREE
)
19255 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
19256 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
19257 pop_nested_class ();
19258 pop_from_top_level ();
19260 if (fndecl
== error_mark_node
)
19262 pop_deferring_access_checks ();
19263 return error_mark_node
;
19266 /* The DECL_TI_TEMPLATE should always be the immediate parent
19267 template, not the most general template. */
19268 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
19269 DECL_TI_ARGS (fndecl
) = targ_ptr
;
19271 /* Now we know the specialization, compute access previously
19272 deferred. Do no access control for inheriting constructors,
19273 as we already checked access for the inherited constructor. */
19274 if (!(flag_new_inheriting_ctors
19275 && DECL_INHERITED_CTOR (fndecl
)))
19277 push_access_scope (fndecl
);
19278 if (!perform_deferred_access_checks (complain
))
19280 pop_access_scope (fndecl
);
19282 pop_deferring_access_checks ();
19284 /* If we've just instantiated the main entry point for a function,
19285 instantiate all the alternate entry points as well. We do this
19286 by cloning the instantiation of the main entry point, not by
19287 instantiating the template clones. */
19288 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
19289 clone_function_decl (fndecl
, /*update_methods=*/false);
19293 if (!(complain
& tf_error
))
19295 /* Remember to reinstantiate when we're out of SFINAE so the user
19296 can see the errors. */
19297 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
19299 return error_mark_node
;
19304 /* Wrapper for instantiate_template_1. */
19307 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
19310 timevar_push (TV_TEMPLATE_INST
);
19311 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
19312 timevar_pop (TV_TEMPLATE_INST
);
19316 /* Instantiate the alias template TMPL with ARGS. Also push a template
19317 instantiation level, which instantiate_template doesn't do because
19318 functions and variables have sufficient context established by the
19322 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
19324 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
19325 return error_mark_node
;
19326 if (!push_tinst_level (tmpl
, args
))
19327 return error_mark_node
;
19330 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
19331 args
, tmpl
, complain
,
19332 /*require_all_args=*/true,
19333 /*use_default_args=*/true);
19335 tree r
= instantiate_template (tmpl
, args
, complain
);
19336 pop_tinst_level ();
19341 /* PARM is a template parameter pack for FN. Returns true iff
19342 PARM is used in a deducible way in the argument list of FN. */
19345 pack_deducible_p (tree parm
, tree fn
)
19347 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
19348 for (; t
; t
= TREE_CHAIN (t
))
19350 tree type
= TREE_VALUE (t
);
19352 if (!PACK_EXPANSION_P (type
))
19354 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
19355 packs
; packs
= TREE_CHAIN (packs
))
19356 if (template_args_equal (TREE_VALUE (packs
), parm
))
19358 /* The template parameter pack is used in a function parameter
19359 pack. If this is the end of the parameter list, the
19360 template parameter pack is deducible. */
19361 if (TREE_CHAIN (t
) == void_list_node
)
19364 /* Otherwise, not. Well, it could be deduced from
19365 a non-pack parameter, but doing so would end up with
19366 a deduction mismatch, so don't bother. */
19370 /* The template parameter pack isn't used in any function parameter
19371 packs, but it might be used deeper, e.g. tuple<Args...>. */
19375 /* Subroutine of fn_type_unification: check non-dependent parms for
19379 check_non_deducible_conversions (tree parms
, const tree
*args
, unsigned nargs
,
19380 tree fn
, unification_kind_t strict
, int flags
,
19381 struct conversion
**convs
, bool explain_p
)
19383 /* Non-constructor methods need to leave a conversion for 'this', which
19384 isn't included in nargs here. */
19385 unsigned offset
= (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
19386 && !DECL_CONSTRUCTOR_P (fn
));
19388 for (unsigned ia
= 0;
19389 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
19391 tree parm
= TREE_VALUE (parms
);
19393 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
19394 && (!TREE_CHAIN (parms
)
19395 || TREE_CHAIN (parms
) == void_list_node
))
19396 /* For a function parameter pack that occurs at the end of the
19397 parameter-declaration-list, the type A of each remaining
19398 argument of the call is compared with the type P of the
19399 declarator-id of the function parameter pack. */
19402 parms
= TREE_CHAIN (parms
);
19404 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
19405 /* For a function parameter pack that does not occur at the
19406 end of the parameter-declaration-list, the type of the
19407 parameter pack is a non-deduced context. */
19410 if (!uses_template_parms (parm
))
19412 tree arg
= args
[ia
];
19413 conversion
**conv_p
= convs
? &convs
[ia
+offset
] : NULL
;
19414 int lflags
= conv_flags (ia
, nargs
, fn
, arg
, flags
);
19416 if (check_non_deducible_conversion (parm
, arg
, strict
, lflags
,
19417 conv_p
, explain_p
))
19427 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
19428 NARGS elements of the arguments that are being used when calling
19429 it. TARGS is a vector into which the deduced template arguments
19432 Returns either a FUNCTION_DECL for the matching specialization of FN or
19433 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
19434 true, diagnostics will be printed to explain why it failed.
19436 If FN is a conversion operator, or we are trying to produce a specific
19437 specialization, RETURN_TYPE is the return type desired.
19439 The EXPLICIT_TARGS are explicit template arguments provided via a
19442 The parameter STRICT is one of:
19445 We are deducing arguments for a function call, as in
19446 [temp.deduct.call]. If RETURN_TYPE is non-null, we are
19447 deducing arguments for a call to the result of a conversion
19448 function template, as in [over.call.object].
19451 We are deducing arguments for a conversion function, as in
19452 [temp.deduct.conv].
19455 We are deducing arguments when doing an explicit instantiation
19456 as in [temp.explicit], when determining an explicit specialization
19457 as in [temp.expl.spec], or when taking the address of a function
19458 template, as in [temp.deduct.funcaddr]. */
19461 fn_type_unification (tree fn
,
19462 tree explicit_targs
,
19465 unsigned int nargs
,
19467 unification_kind_t strict
,
19469 struct conversion
**convs
,
19475 tree decl
= NULL_TREE
;
19476 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
19478 static int deduction_depth
;
19481 if (flag_new_inheriting_ctors
)
19482 fn
= strip_inheriting_ctors (fn
);
19484 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
19485 tree r
= error_mark_node
;
19487 tree full_targs
= targs
;
19488 if (TMPL_ARGS_DEPTH (targs
)
19489 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (fn
)))
19490 full_targs
= (add_outermost_template_args
19491 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (fn
)),
19495 complain
|= tf_decltype
;
19497 /* In C++0x, it's possible to have a function template whose type depends
19498 on itself recursively. This is most obvious with decltype, but can also
19499 occur with enumeration scope (c++/48969). So we need to catch infinite
19500 recursion and reject the substitution at deduction time; this function
19501 will return error_mark_node for any repeated substitution.
19503 This also catches excessive recursion such as when f<N> depends on
19504 f<N-1> across all integers, and returns error_mark_node for all the
19505 substitutions back up to the initial one.
19507 This is, of course, not reentrant. */
19508 if (excessive_deduction_depth
)
19509 return error_mark_node
;
19512 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
19514 fntype
= TREE_TYPE (fn
);
19515 if (explicit_targs
)
19519 The specified template arguments must match the template
19520 parameters in kind (i.e., type, nontype, template), and there
19521 must not be more arguments than there are parameters;
19522 otherwise type deduction fails.
19524 Nontype arguments must match the types of the corresponding
19525 nontype template parameters, or must be convertible to the
19526 types of the corresponding nontype parameters as specified in
19527 _temp.arg.nontype_, otherwise type deduction fails.
19529 All references in the function type of the function template
19530 to the corresponding template parameters are replaced by the
19531 specified template argument values. If a substitution in a
19532 template parameter or in the function type of the function
19533 template results in an invalid type, type deduction fails. */
19534 int i
, len
= TREE_VEC_LENGTH (tparms
);
19535 location_t loc
= input_location
;
19536 bool incomplete
= false;
19538 if (explicit_targs
== error_mark_node
)
19541 if (TMPL_ARGS_DEPTH (explicit_targs
)
19542 < TMPL_ARGS_DEPTH (full_targs
))
19543 explicit_targs
= add_outermost_template_args (full_targs
,
19546 /* Adjust any explicit template arguments before entering the
19547 substitution context. */
19549 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
19551 /*require_all_args=*/false,
19552 /*use_default_args=*/false));
19553 if (explicit_targs
== error_mark_node
)
19556 /* Substitute the explicit args into the function type. This is
19557 necessary so that, for instance, explicitly declared function
19558 arguments can match null pointed constants. If we were given
19559 an incomplete set of explicit args, we must not do semantic
19560 processing during substitution as we could create partial
19562 for (i
= 0; i
< len
; i
++)
19564 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
19565 bool parameter_pack
= false;
19566 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
19568 /* Dig out the actual parm. */
19569 if (TREE_CODE (parm
) == TYPE_DECL
19570 || TREE_CODE (parm
) == TEMPLATE_DECL
)
19572 parm
= TREE_TYPE (parm
);
19573 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
19575 else if (TREE_CODE (parm
) == PARM_DECL
)
19577 parm
= DECL_INITIAL (parm
);
19578 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
19581 if (!parameter_pack
&& targ
== NULL_TREE
)
19582 /* No explicit argument for this template parameter. */
19585 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
19587 /* Mark the argument pack as "incomplete". We could
19588 still deduce more arguments during unification.
19589 We remove this mark in type_unification_real. */
19592 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
19593 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
19594 = ARGUMENT_PACK_ARGS (targ
);
19597 /* We have some incomplete argument packs. */
19602 if (!push_tinst_level (fn
, explicit_targs
))
19604 excessive_deduction_depth
= true;
19607 processing_template_decl
+= incomplete
;
19608 input_location
= DECL_SOURCE_LOCATION (fn
);
19609 /* Ignore any access checks; we'll see them again in
19610 instantiate_template and they might have the wrong
19611 access path at this point. */
19612 push_deferring_access_checks (dk_deferred
);
19613 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
19614 complain
| tf_partial
| tf_fndecl_type
, NULL_TREE
);
19615 pop_deferring_access_checks ();
19616 input_location
= loc
;
19617 processing_template_decl
-= incomplete
;
19618 pop_tinst_level ();
19620 if (fntype
== error_mark_node
)
19623 /* Place the explicitly specified arguments in TARGS. */
19624 explicit_targs
= INNERMOST_TEMPLATE_ARGS (explicit_targs
);
19625 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
19626 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
19629 /* Never do unification on the 'this' parameter. */
19630 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
19632 if (return_type
&& strict
== DEDUCE_CALL
)
19634 /* We're deducing for a call to the result of a template conversion
19635 function. The parms we really want are in return_type. */
19636 if (INDIRECT_TYPE_P (return_type
))
19637 return_type
= TREE_TYPE (return_type
);
19638 parms
= TYPE_ARG_TYPES (return_type
);
19640 else if (return_type
)
19644 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
19645 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
19646 new_args
[0] = return_type
;
19647 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
19652 /* We allow incomplete unification without an error message here
19653 because the standard doesn't seem to explicitly prohibit it. Our
19654 callers must be ready to deal with unification failures in any
19657 /* If we aren't explaining yet, push tinst context so we can see where
19658 any errors (e.g. from class instantiations triggered by instantiation
19659 of default template arguments) come from. If we are explaining, this
19660 context is redundant. */
19661 if (!explain_p
&& !push_tinst_level (fn
, targs
))
19663 excessive_deduction_depth
= true;
19667 /* type_unification_real will pass back any access checks from default
19668 template argument substitution. */
19669 vec
<deferred_access_check
, va_gc
> *checks
;
19672 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
19673 full_targs
, parms
, args
, nargs
, /*subr=*/0,
19674 strict
, &checks
, explain_p
);
19676 pop_tinst_level ();
19680 /* Now that we have bindings for all of the template arguments,
19681 ensure that the arguments deduced for the template template
19682 parameters have compatible template parameter lists. We cannot
19683 check this property before we have deduced all template
19684 arguments, because the template parameter types of a template
19685 template parameter might depend on prior template parameters
19686 deduced after the template template parameter. The following
19687 ill-formed example illustrates this issue:
19689 template<typename T, template<T> class C> void f(C<5>, T);
19691 template<int N> struct X {};
19694 f(X<5>(), 5l); // error: template argument deduction fails
19697 The template parameter list of 'C' depends on the template type
19698 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
19699 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
19700 time that we deduce 'C'. */
19701 if (!template_template_parm_bindings_ok_p
19702 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
19704 unify_inconsistent_template_template_parameters (explain_p
);
19708 /* DR 1391: All parameters have args, now check non-dependent parms for
19710 if (check_non_deducible_conversions (parms
, args
, nargs
, fn
, strict
, flags
,
19714 /* All is well so far. Now, check:
19718 When all template arguments have been deduced, all uses of
19719 template parameters in nondeduced contexts are replaced with
19720 the corresponding deduced argument values. If the
19721 substitution results in an invalid type, as described above,
19722 type deduction fails. */
19723 if (!push_tinst_level (fn
, targs
))
19725 excessive_deduction_depth
= true;
19729 /* Also collect access checks from the instantiation. */
19730 reopen_deferring_access_checks (checks
);
19732 decl
= instantiate_template (fn
, targs
, complain
);
19734 checks
= get_deferred_access_checks ();
19735 pop_deferring_access_checks ();
19737 pop_tinst_level ();
19739 if (decl
== error_mark_node
)
19742 /* Now perform any access checks encountered during substitution. */
19743 push_access_scope (decl
);
19744 ok
= perform_access_checks (checks
, complain
);
19745 pop_access_scope (decl
);
19749 /* If we're looking for an exact match, check that what we got
19750 is indeed an exact match. It might not be if some template
19751 parameters are used in non-deduced contexts. But don't check
19752 for an exact match if we have dependent template arguments;
19753 in that case we're doing partial ordering, and we already know
19754 that we have two candidates that will provide the actual type. */
19755 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
19757 tree substed
= TREE_TYPE (decl
);
19761 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
19763 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
19764 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
19765 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
19767 unify_type_mismatch (explain_p
, args
[i
],
19768 TREE_VALUE (sarg
));
19773 /* After doing deduction with the inherited constructor, actually return an
19774 instantiation of the inheriting constructor. */
19776 decl
= instantiate_template (orig_fn
, targs
, complain
);
19782 if (excessive_deduction_depth
)
19784 if (deduction_depth
== 0)
19785 /* Reset once we're all the way out. */
19786 excessive_deduction_depth
= false;
19792 /* Adjust types before performing type deduction, as described in
19793 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
19794 sections are symmetric. PARM is the type of a function parameter
19795 or the return type of the conversion function. ARG is the type of
19796 the argument passed to the call, or the type of the value
19797 initialized with the result of the conversion function.
19798 ARG_EXPR is the original argument expression, which may be null. */
19801 maybe_adjust_types_for_deduction (unification_kind_t strict
,
19814 /* Swap PARM and ARG throughout the remainder of this
19815 function; the handling is precisely symmetric since PARM
19816 will initialize ARG rather than vice versa. */
19817 std::swap (parm
, arg
);
19821 /* Core issue #873: Do the DR606 thing (see below) for these cases,
19822 too, but here handle it by stripping the reference from PARM
19823 rather than by adding it to ARG. */
19824 if (TYPE_REF_P (*parm
)
19825 && TYPE_REF_IS_RVALUE (*parm
)
19826 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
19827 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
19828 && TYPE_REF_P (*arg
)
19829 && !TYPE_REF_IS_RVALUE (*arg
))
19830 *parm
= TREE_TYPE (*parm
);
19831 /* Nothing else to do in this case. */
19835 gcc_unreachable ();
19838 if (!TYPE_REF_P (*parm
))
19840 /* [temp.deduct.call]
19842 If P is not a reference type:
19844 --If A is an array type, the pointer type produced by the
19845 array-to-pointer standard conversion (_conv.array_) is
19846 used in place of A for type deduction; otherwise,
19848 --If A is a function type, the pointer type produced by
19849 the function-to-pointer standard conversion
19850 (_conv.func_) is used in place of A for type deduction;
19853 --If A is a cv-qualified type, the top level
19854 cv-qualifiers of A's type are ignored for type
19856 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
19857 *arg
= build_pointer_type (TREE_TYPE (*arg
));
19858 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
19859 *arg
= build_pointer_type (*arg
);
19861 *arg
= TYPE_MAIN_VARIANT (*arg
);
19864 /* [14.8.2.1/3 temp.deduct.call], "A forwarding reference is an rvalue
19865 reference to a cv-unqualified template parameter that does not represent a
19866 template parameter of a class template (during class template argument
19867 deduction (13.3.1.8)). If P is a forwarding reference and the argument is
19868 an lvalue, the type "lvalue reference to A" is used in place of A for type
19870 if (TYPE_REF_P (*parm
)
19871 && TYPE_REF_IS_RVALUE (*parm
)
19872 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
19873 && !TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (*parm
))
19874 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
19875 && (arg_expr
? lvalue_p (arg_expr
)
19876 /* try_one_overload doesn't provide an arg_expr, but
19877 functions are always lvalues. */
19878 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
19879 *arg
= build_reference_type (*arg
);
19881 /* [temp.deduct.call]
19883 If P is a cv-qualified type, the top level cv-qualifiers
19884 of P's type are ignored for type deduction. If P is a
19885 reference type, the type referred to by P is used for
19887 *parm
= TYPE_MAIN_VARIANT (*parm
);
19888 if (TYPE_REF_P (*parm
))
19890 *parm
= TREE_TYPE (*parm
);
19891 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
19894 /* DR 322. For conversion deduction, remove a reference type on parm
19895 too (which has been swapped into ARG). */
19896 if (strict
== DEDUCE_CONV
&& TYPE_REF_P (*arg
))
19897 *arg
= TREE_TYPE (*arg
);
19902 /* Subroutine of fn_type_unification. PARM is a function parameter of a
19903 template which doesn't contain any deducible template parameters; check if
19904 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
19905 unify_one_argument. */
19908 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
19909 int flags
, struct conversion
**conv_p
,
19915 type
= TREE_TYPE (arg
);
19919 if (same_type_p (parm
, type
))
19920 return unify_success (explain_p
);
19922 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
19923 if (strict
== DEDUCE_CONV
)
19925 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
, complain
))
19926 return unify_success (explain_p
);
19928 else if (strict
!= DEDUCE_EXACT
)
19931 tree conv_arg
= TYPE_P (arg
) ? NULL_TREE
: arg
;
19933 /* Avoid recalculating this in add_function_candidate. */
19935 = good_conversion (parm
, type
, conv_arg
, flags
, complain
));
19937 ok
= can_convert_arg (parm
, type
, conv_arg
, flags
, complain
);
19939 return unify_success (explain_p
);
19942 if (strict
== DEDUCE_EXACT
)
19943 return unify_type_mismatch (explain_p
, parm
, arg
);
19945 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
19948 static bool uses_deducible_template_parms (tree type
);
19950 /* Returns true iff the expression EXPR is one from which a template
19951 argument can be deduced. In other words, if it's an undecorated
19952 use of a template non-type parameter. */
19955 deducible_expression (tree expr
)
19957 /* Strip implicit conversions. */
19958 while (CONVERT_EXPR_P (expr
))
19959 expr
= TREE_OPERAND (expr
, 0);
19960 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
19963 /* Returns true iff the array domain DOMAIN uses a template parameter in a
19964 deducible way; that is, if it has a max value of <PARM> - 1. */
19967 deducible_array_bound (tree domain
)
19969 if (domain
== NULL_TREE
)
19972 tree max
= TYPE_MAX_VALUE (domain
);
19973 if (TREE_CODE (max
) != MINUS_EXPR
)
19976 return deducible_expression (TREE_OPERAND (max
, 0));
19979 /* Returns true iff the template arguments ARGS use a template parameter
19980 in a deducible way. */
19983 deducible_template_args (tree args
)
19985 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
19988 tree elt
= TREE_VEC_ELT (args
, i
);
19989 if (ARGUMENT_PACK_P (elt
))
19990 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
19993 if (PACK_EXPANSION_P (elt
))
19994 elt
= PACK_EXPANSION_PATTERN (elt
);
19995 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
19997 else if (TYPE_P (elt
))
19998 deducible
= uses_deducible_template_parms (elt
);
20000 deducible
= deducible_expression (elt
);
20008 /* Returns true iff TYPE contains any deducible references to template
20009 parameters, as per 14.8.2.5. */
20012 uses_deducible_template_parms (tree type
)
20014 if (PACK_EXPANSION_P (type
))
20015 type
= PACK_EXPANSION_PATTERN (type
);
20022 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20023 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20029 if (INDIRECT_TYPE_P (type
))
20030 return uses_deducible_template_parms (TREE_TYPE (type
));
20032 /* T[integer-constant ]
20034 if (TREE_CODE (type
) == ARRAY_TYPE
)
20035 return (uses_deducible_template_parms (TREE_TYPE (type
))
20036 || deducible_array_bound (TYPE_DOMAIN (type
)));
20048 if (TYPE_PTRMEM_P (type
))
20049 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
20050 || (uses_deducible_template_parms
20051 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
20053 /* template-name <T> (where template-name refers to a class template)
20054 template-name <i> (where template-name refers to a class template) */
20055 if (CLASS_TYPE_P (type
)
20056 && CLASSTYPE_TEMPLATE_INFO (type
)
20057 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
20058 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
20059 (CLASSTYPE_TI_ARGS (type
)));
20064 if (TREE_CODE (type
) == FUNCTION_TYPE
20065 || TREE_CODE (type
) == METHOD_TYPE
)
20067 if (uses_deducible_template_parms (TREE_TYPE (type
)))
20069 tree parm
= TYPE_ARG_TYPES (type
);
20070 if (TREE_CODE (type
) == METHOD_TYPE
)
20071 parm
= TREE_CHAIN (parm
);
20072 for (; parm
; parm
= TREE_CHAIN (parm
))
20073 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
20080 /* Subroutine of type_unification_real and unify_pack_expansion to
20081 handle unification of a single P/A pair. Parameters are as
20082 for those functions. */
20085 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
20086 int subr
, unification_kind_t strict
,
20089 tree arg_expr
= NULL_TREE
;
20092 if (arg
== error_mark_node
|| parm
== error_mark_node
)
20093 return unify_invalid (explain_p
);
20094 if (arg
== unknown_type_node
)
20095 /* We can't deduce anything from this, but we might get all the
20096 template args from other function args. */
20097 return unify_success (explain_p
);
20099 /* Implicit conversions (Clause 4) will be performed on a function
20100 argument to convert it to the type of the corresponding function
20101 parameter if the parameter type contains no template-parameters that
20102 participate in template argument deduction. */
20103 if (strict
!= DEDUCE_EXACT
20104 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
20105 /* For function parameters with no deducible template parameters,
20106 just return. We'll check non-dependent conversions later. */
20107 return unify_success (explain_p
);
20112 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
20113 | UNIFY_ALLOW_MORE_CV_QUAL
20114 | UNIFY_ALLOW_DERIVED
);
20118 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
20122 arg_strict
= UNIFY_ALLOW_NONE
;
20126 gcc_unreachable ();
20129 /* We only do these transformations if this is the top-level
20130 parameter_type_list in a call or declaration matching; in other
20131 situations (nested function declarators, template argument lists) we
20132 won't be comparing a type to an expression, and we don't do any type
20138 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
20139 if (type_unknown_p (arg
))
20141 /* [temp.deduct.type] A template-argument can be
20142 deduced from a pointer to function or pointer
20143 to member function argument if the set of
20144 overloaded functions does not contain function
20145 templates and at most one of a set of
20146 overloaded functions provides a unique
20148 resolve_overloaded_unification (tparms
, targs
, parm
,
20150 arg_strict
, explain_p
);
20151 /* If a unique match was not found, this is a
20152 non-deduced context, so we still succeed. */
20153 return unify_success (explain_p
);
20157 arg
= unlowered_expr_type (arg
);
20158 if (arg
== error_mark_node
)
20159 return unify_invalid (explain_p
);
20163 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
20166 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
20167 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
20168 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
20170 /* For deduction from an init-list we need the actual list. */
20171 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
20173 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
20176 /* for_each_template_parm callback that always returns 0. */
20179 zero_r (tree
, void *)
20184 /* for_each_template_parm any_fn callback to handle deduction of a template
20185 type argument from the type of an array bound. */
20188 array_deduction_r (tree t
, void *data
)
20190 tree_pair_p d
= (tree_pair_p
)data
;
20191 tree
&tparms
= d
->purpose
;
20192 tree
&targs
= d
->value
;
20194 if (TREE_CODE (t
) == ARRAY_TYPE
)
20195 if (tree dom
= TYPE_DOMAIN (t
))
20196 if (tree max
= TYPE_MAX_VALUE (dom
))
20198 if (TREE_CODE (max
) == MINUS_EXPR
)
20199 max
= TREE_OPERAND (max
, 0);
20200 if (TREE_CODE (max
) == TEMPLATE_PARM_INDEX
)
20201 unify (tparms
, targs
, TREE_TYPE (max
), size_type_node
,
20202 UNIFY_ALLOW_NONE
, /*explain*/false);
20205 /* Keep walking. */
20209 /* Try to deduce any not-yet-deduced template type arguments from the type of
20210 an array bound. This is handled separately from unify because 14.8.2.5 says
20211 "The type of a type parameter is only deduced from an array bound if it is
20212 not otherwise deduced." */
20215 try_array_deduction (tree tparms
, tree targs
, tree parm
)
20217 tree_pair_s data
= { tparms
, targs
};
20218 hash_set
<tree
> visited
;
20219 for_each_template_parm (parm
, zero_r
, &data
, &visited
,
20220 /*nondeduced*/false, array_deduction_r
);
20223 /* Most parms like fn_type_unification.
20225 If SUBR is 1, we're being called recursively (to unify the
20226 arguments of a function or method parameter of a function
20229 CHECKS is a pointer to a vector of access checks encountered while
20230 substituting default template arguments. */
20233 type_unification_real (tree tparms
,
20237 unsigned int xnargs
,
20239 unification_kind_t strict
,
20240 vec
<deferred_access_check
, va_gc
> **checks
,
20245 int ntparms
= TREE_VEC_LENGTH (tparms
);
20246 int saw_undeduced
= 0;
20249 unsigned int nargs
;
20252 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
20253 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
20254 gcc_assert (ntparms
> 0);
20256 tree targs
= INNERMOST_TEMPLATE_ARGS (full_targs
);
20258 /* Reset the number of non-defaulted template arguments contained
20260 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
20268 while (parms
&& parms
!= void_list_node
20271 parm
= TREE_VALUE (parms
);
20273 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
20274 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
20275 /* For a function parameter pack that occurs at the end of the
20276 parameter-declaration-list, the type A of each remaining
20277 argument of the call is compared with the type P of the
20278 declarator-id of the function parameter pack. */
20281 parms
= TREE_CHAIN (parms
);
20283 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
20284 /* For a function parameter pack that does not occur at the
20285 end of the parameter-declaration-list, the type of the
20286 parameter pack is a non-deduced context. */
20292 if (unify_one_argument (tparms
, full_targs
, parm
, arg
, subr
, strict
,
20298 && parms
!= void_list_node
20299 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
20301 /* Unify the remaining arguments with the pack expansion type. */
20303 tree parmvec
= make_tree_vec (1);
20305 /* Allocate a TREE_VEC and copy in all of the arguments */
20306 argvec
= make_tree_vec (nargs
- ia
);
20307 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
20308 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
20310 /* Copy the parameter into parmvec. */
20311 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
20312 if (unify_pack_expansion (tparms
, full_targs
, parmvec
, argvec
, strict
,
20313 /*subr=*/subr
, explain_p
))
20316 /* Advance to the end of the list of parameters. */
20317 parms
= TREE_CHAIN (parms
);
20320 /* Fail if we've reached the end of the parm list, and more args
20321 are present, and the parm list isn't variadic. */
20322 if (ia
< nargs
&& parms
== void_list_node
)
20323 return unify_too_many_arguments (explain_p
, nargs
, ia
);
20324 /* Fail if parms are left and they don't have default values and
20325 they aren't all deduced as empty packs (c++/57397). This is
20326 consistent with sufficient_parms_p. */
20327 if (parms
&& parms
!= void_list_node
20328 && TREE_PURPOSE (parms
) == NULL_TREE
)
20330 unsigned int count
= nargs
;
20335 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
20338 p
= TREE_CHAIN (p
);
20340 while (p
&& p
!= void_list_node
);
20341 if (count
!= nargs
)
20342 return unify_too_few_arguments (explain_p
, ia
, count
,
20348 tsubst_flags_t complain
= (explain_p
20349 ? tf_warning_or_error
20351 bool tried_array_deduction
= (cxx_dialect
< cxx17
);
20353 for (i
= 0; i
< ntparms
; i
++)
20355 tree targ
= TREE_VEC_ELT (targs
, i
);
20356 tree tparm
= TREE_VEC_ELT (tparms
, i
);
20358 /* Clear the "incomplete" flags on all argument packs now so that
20359 substituting them into later default arguments works. */
20360 if (targ
&& ARGUMENT_PACK_P (targ
))
20362 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
20363 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
20366 if (targ
|| tparm
== error_mark_node
)
20368 tparm
= TREE_VALUE (tparm
);
20370 if (TREE_CODE (tparm
) == TYPE_DECL
20371 && !tried_array_deduction
)
20373 try_array_deduction (tparms
, targs
, xparms
);
20374 tried_array_deduction
= true;
20375 if (TREE_VEC_ELT (targs
, i
))
20379 /* If this is an undeduced nontype parameter that depends on
20380 a type parameter, try another pass; its type may have been
20381 deduced from a later argument than the one from which
20382 this parameter can be deduced. */
20383 if (TREE_CODE (tparm
) == PARM_DECL
20384 && uses_template_parms (TREE_TYPE (tparm
))
20385 && saw_undeduced
< 2)
20391 /* Core issue #226 (C++0x) [temp.deduct]:
20393 If a template argument has not been deduced, its
20394 default template argument, if any, is used.
20396 When we are in C++98 mode, TREE_PURPOSE will either
20397 be NULL_TREE or ERROR_MARK_NODE, so we do not need
20398 to explicitly check cxx_dialect here. */
20399 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
20400 /* OK, there is a default argument. Wait until after the
20401 conversion check to do substitution. */
20404 /* If the type parameter is a parameter pack, then it will
20405 be deduced to an empty parameter pack. */
20406 if (template_parameter_pack_p (tparm
))
20410 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
20412 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
20413 TREE_CONSTANT (arg
) = 1;
20416 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
20418 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
20420 TREE_VEC_ELT (targs
, i
) = arg
;
20424 return unify_parameter_deduction_failure (explain_p
, tparm
);
20427 /* Now substitute into the default template arguments. */
20428 for (i
= 0; i
< ntparms
; i
++)
20430 tree targ
= TREE_VEC_ELT (targs
, i
);
20431 tree tparm
= TREE_VEC_ELT (tparms
, i
);
20433 if (targ
|| tparm
== error_mark_node
)
20435 tree parm
= TREE_VALUE (tparm
);
20436 tree arg
= TREE_PURPOSE (tparm
);
20437 reopen_deferring_access_checks (*checks
);
20438 location_t save_loc
= input_location
;
20440 input_location
= DECL_SOURCE_LOCATION (parm
);
20442 if (saw_undeduced
== 1
20443 && TREE_CODE (parm
) == PARM_DECL
20444 && uses_template_parms (TREE_TYPE (parm
)))
20446 /* The type of this non-type parameter depends on undeduced
20447 parameters. Don't try to use its default argument yet,
20448 since we might deduce an argument for it on the next pass,
20449 but do check whether the arguments we already have cause
20450 substitution failure, so that that happens before we try
20451 later default arguments (78489). */
20452 ++processing_template_decl
;
20453 tree type
= tsubst (TREE_TYPE (parm
), full_targs
, complain
,
20455 --processing_template_decl
;
20456 if (type
== error_mark_node
)
20457 arg
= error_mark_node
;
20463 tree substed
= NULL_TREE
;
20464 if (saw_undeduced
== 1 && processing_template_decl
== 0)
20466 /* First instatiate in template context, in case we still
20467 depend on undeduced template parameters. */
20468 ++processing_template_decl
;
20469 substed
= tsubst_template_arg (arg
, full_targs
, complain
,
20471 --processing_template_decl
;
20472 if (substed
!= error_mark_node
20473 && !uses_template_parms (substed
))
20474 /* We replaced all the tparms, substitute again out of
20475 template context. */
20476 substed
= NULL_TREE
;
20479 substed
= tsubst_template_arg (arg
, full_targs
, complain
,
20482 if (!uses_template_parms (substed
))
20483 arg
= convert_template_argument (parm
, substed
, full_targs
,
20484 complain
, i
, NULL_TREE
);
20485 else if (saw_undeduced
== 1)
20488 arg
= error_mark_node
;
20491 input_location
= save_loc
;
20492 *checks
= get_deferred_access_checks ();
20493 pop_deferring_access_checks ();
20495 if (arg
== error_mark_node
)
20499 TREE_VEC_ELT (targs
, i
) = arg
;
20500 /* The position of the first default template argument,
20501 is also the number of non-defaulted arguments in TARGS.
20503 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
20504 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
20508 if (saw_undeduced
++ == 1)
20512 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
20513 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
20515 return unify_success (explain_p
);
20518 /* Subroutine of type_unification_real. Args are like the variables
20519 at the call site. ARG is an overloaded function (or template-id);
20520 we try deducing template args from each of the overloads, and if
20521 only one succeeds, we go with that. Modifies TARGS and returns
20522 true on success. */
20525 resolve_overloaded_unification (tree tparms
,
20529 unification_kind_t strict
,
20533 tree tempargs
= copy_node (targs
);
20535 tree goodfn
= NULL_TREE
;
20538 if (TREE_CODE (arg
) == ADDR_EXPR
)
20540 arg
= TREE_OPERAND (arg
, 0);
20546 if (TREE_CODE (arg
) == COMPONENT_REF
)
20547 /* Handle `&x' where `x' is some static or non-static member
20549 arg
= TREE_OPERAND (arg
, 1);
20551 if (TREE_CODE (arg
) == OFFSET_REF
)
20552 arg
= TREE_OPERAND (arg
, 1);
20554 /* Strip baselink information. */
20555 if (BASELINK_P (arg
))
20556 arg
= BASELINK_FUNCTIONS (arg
);
20558 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
20560 /* If we got some explicit template args, we need to plug them into
20561 the affected templates before we try to unify, in case the
20562 explicit args will completely resolve the templates in question. */
20565 tree expl_subargs
= TREE_OPERAND (arg
, 1);
20566 arg
= TREE_OPERAND (arg
, 0);
20568 for (lkp_iterator
iter (arg
); iter
; ++iter
)
20571 tree subargs
, elem
;
20573 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
20576 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
20577 expl_subargs
, NULL_TREE
, tf_none
,
20578 /*require_all_args=*/true,
20579 /*use_default_args=*/true);
20580 if (subargs
!= error_mark_node
20581 && !any_dependent_template_arguments_p (subargs
))
20583 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
20584 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
20585 elem
, strict
, sub_strict
, addr_p
, explain_p
)
20586 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
20595 /* If no templates (or more than one) are fully resolved by the
20596 explicit arguments, this template-id is a non-deduced context; it
20597 could still be OK if we deduce all template arguments for the
20598 enclosing call through other arguments. */
20602 else if (TREE_CODE (arg
) != OVERLOAD
20603 && TREE_CODE (arg
) != FUNCTION_DECL
)
20604 /* If ARG is, for example, "(0, &f)" then its type will be unknown
20605 -- but the deduction does not succeed because the expression is
20606 not just the function on its own. */
20609 for (lkp_iterator
iter (arg
); iter
; ++iter
)
20612 if (try_one_overload (tparms
, targs
, tempargs
, parm
, TREE_TYPE (fn
),
20613 strict
, sub_strict
, addr_p
, explain_p
)
20614 && (!goodfn
|| !decls_match (goodfn
, fn
)))
20621 /* [temp.deduct.type] A template-argument can be deduced from a pointer
20622 to function or pointer to member function argument if the set of
20623 overloaded functions does not contain function templates and at most
20624 one of a set of overloaded functions provides a unique match.
20626 So if we found multiple possibilities, we return success but don't
20627 deduce anything. */
20631 int i
= TREE_VEC_LENGTH (targs
);
20633 if (TREE_VEC_ELT (tempargs
, i
))
20635 tree old
= TREE_VEC_ELT (targs
, i
);
20636 tree new_
= TREE_VEC_ELT (tempargs
, i
);
20637 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
20638 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
20639 /* Don't forget explicit template arguments in a pack. */
20640 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
20641 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
20642 TREE_VEC_ELT (targs
, i
) = new_
;
20651 /* Core DR 115: In contexts where deduction is done and fails, or in
20652 contexts where deduction is not done, if a template argument list is
20653 specified and it, along with any default template arguments, identifies
20654 a single function template specialization, then the template-id is an
20655 lvalue for the function template specialization. */
20658 resolve_nondeduced_context (tree orig_expr
, tsubst_flags_t complain
)
20660 tree expr
, offset
, baselink
;
20663 if (!type_unknown_p (orig_expr
))
20668 offset
= NULL_TREE
;
20669 baselink
= NULL_TREE
;
20671 if (TREE_CODE (expr
) == ADDR_EXPR
)
20673 expr
= TREE_OPERAND (expr
, 0);
20676 if (TREE_CODE (expr
) == OFFSET_REF
)
20679 expr
= TREE_OPERAND (expr
, 1);
20681 if (BASELINK_P (expr
))
20684 expr
= BASELINK_FUNCTIONS (expr
);
20687 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
20690 tree goodfn
= NULL_TREE
;
20692 /* If we got some explicit template args, we need to plug them into
20693 the affected templates before we try to unify, in case the
20694 explicit args will completely resolve the templates in question. */
20696 tree expl_subargs
= TREE_OPERAND (expr
, 1);
20697 tree arg
= TREE_OPERAND (expr
, 0);
20698 tree badfn
= NULL_TREE
;
20699 tree badargs
= NULL_TREE
;
20701 for (lkp_iterator
iter (arg
); iter
; ++iter
)
20704 tree subargs
, elem
;
20706 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
20709 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
20710 expl_subargs
, NULL_TREE
, tf_none
,
20711 /*require_all_args=*/true,
20712 /*use_default_args=*/true);
20713 if (subargs
!= error_mark_node
20714 && !any_dependent_template_arguments_p (subargs
))
20716 elem
= instantiate_template (fn
, subargs
, tf_none
);
20717 if (elem
== error_mark_node
)
20722 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
20731 mark_used (goodfn
);
20734 expr
= build_baselink (BASELINK_BINFO (baselink
),
20735 BASELINK_ACCESS_BINFO (baselink
),
20736 expr
, BASELINK_OPTYPE (baselink
));
20740 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
20741 expr
= build_offset_ref (base
, expr
, addr
, complain
);
20744 expr
= cp_build_addr_expr (expr
, complain
);
20747 else if (good
== 0 && badargs
&& (complain
& tf_error
))
20748 /* There were no good options and at least one bad one, so let the
20749 user know what the problem is. */
20750 instantiate_template (badfn
, badargs
, complain
);
20755 /* Subroutine of resolve_overloaded_unification; does deduction for a single
20756 overload. Fills TARGS with any deduced arguments, or error_mark_node if
20757 different overloads deduce different arguments for a given parm.
20758 ADDR_P is true if the expression for which deduction is being
20759 performed was of the form "& fn" rather than simply "fn".
20761 Returns 1 on success. */
20764 try_one_overload (tree tparms
,
20769 unification_kind_t strict
,
20778 if (arg
== error_mark_node
)
20781 /* [temp.deduct.type] A template-argument can be deduced from a pointer
20782 to function or pointer to member function argument if the set of
20783 overloaded functions does not contain function templates and at most
20784 one of a set of overloaded functions provides a unique match.
20786 So if this is a template, just return success. */
20788 if (uses_template_parms (arg
))
20791 if (TREE_CODE (arg
) == METHOD_TYPE
)
20792 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
20794 arg
= build_pointer_type (arg
);
20796 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
20798 /* We don't copy orig_targs for this because if we have already deduced
20799 some template args from previous args, unify would complain when we
20800 try to deduce a template parameter for the same argument, even though
20801 there isn't really a conflict. */
20802 nargs
= TREE_VEC_LENGTH (targs
);
20803 tempargs
= make_tree_vec (nargs
);
20805 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
20808 /* First make sure we didn't deduce anything that conflicts with
20809 explicitly specified args. */
20810 for (i
= nargs
; i
--; )
20812 tree elt
= TREE_VEC_ELT (tempargs
, i
);
20813 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
20817 else if (uses_template_parms (elt
))
20818 /* Since we're unifying against ourselves, we will fill in
20819 template args used in the function parm list with our own
20820 template parms. Discard them. */
20821 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
20822 else if (oldelt
&& ARGUMENT_PACK_P (oldelt
))
20824 /* Check that the argument at each index of the deduced argument pack
20825 is equivalent to the corresponding explicitly specified argument.
20826 We may have deduced more arguments than were explicitly specified,
20829 /* We used to assert ARGUMENT_PACK_INCOMPLETE_P (oldelt) here, but
20830 that's wrong if we deduce the same argument pack from multiple
20831 function arguments: it's only incomplete the first time. */
20833 tree explicit_pack
= ARGUMENT_PACK_ARGS (oldelt
);
20834 tree deduced_pack
= ARGUMENT_PACK_ARGS (elt
);
20836 if (TREE_VEC_LENGTH (deduced_pack
)
20837 < TREE_VEC_LENGTH (explicit_pack
))
20840 for (int j
= 0; j
< TREE_VEC_LENGTH (explicit_pack
); j
++)
20841 if (!template_args_equal (TREE_VEC_ELT (explicit_pack
, j
),
20842 TREE_VEC_ELT (deduced_pack
, j
)))
20845 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
20849 for (i
= nargs
; i
--; )
20851 tree elt
= TREE_VEC_ELT (tempargs
, i
);
20854 TREE_VEC_ELT (targs
, i
) = elt
;
20860 /* PARM is a template class (perhaps with unbound template
20861 parameters). ARG is a fully instantiated type. If ARG can be
20862 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
20863 TARGS are as for unify. */
20866 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
20869 tree copy_of_targs
;
20871 if (!CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
20873 else if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20874 /* Matches anything. */;
20875 else if (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
20876 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
)))
20879 /* We need to make a new template argument vector for the call to
20880 unify. If we used TARGS, we'd clutter it up with the result of
20881 the attempted unification, even if this class didn't work out.
20882 We also don't want to commit ourselves to all the unifications
20883 we've already done, since unification is supposed to be done on
20884 an argument-by-argument basis. In other words, consider the
20885 following pathological case:
20887 template <int I, int J, int K>
20890 template <int I, int J>
20891 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
20893 template <int I, int J, int K>
20894 void f(S<I, J, K>, S<I, I, I>);
20903 Now, by the time we consider the unification involving `s2', we
20904 already know that we must have `f<0, 0, 0>'. But, even though
20905 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
20906 because there are two ways to unify base classes of S<0, 1, 2>
20907 with S<I, I, I>. If we kept the already deduced knowledge, we
20908 would reject the possibility I=1. */
20909 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
20911 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20913 if (unify_bound_ttp_args (tparms
, copy_of_targs
, parm
, arg
, explain_p
))
20918 /* If unification failed, we're done. */
20919 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
20920 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
20926 /* Given a template type PARM and a class type ARG, find the unique
20927 base type in ARG that is an instance of PARM. We do not examine
20928 ARG itself; only its base-classes. If there is not exactly one
20929 appropriate base class, return NULL_TREE. PARM may be the type of
20930 a partial specialization, as well as a plain template type. Used
20933 static enum template_base_result
20934 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
20935 bool explain_p
, tree
*result
)
20937 tree rval
= NULL_TREE
;
20940 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
20942 binfo
= TYPE_BINFO (complete_type (arg
));
20945 /* The type could not be completed. */
20946 *result
= NULL_TREE
;
20947 return tbr_incomplete_type
;
20950 /* Walk in inheritance graph order. The search order is not
20951 important, and this avoids multiple walks of virtual bases. */
20952 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
20954 tree r
= try_class_unification (tparms
, targs
, parm
,
20955 BINFO_TYPE (binfo
), explain_p
);
20959 /* If there is more than one satisfactory baseclass, then:
20963 If they yield more than one possible deduced A, the type
20967 if (rval
&& !same_type_p (r
, rval
))
20969 *result
= NULL_TREE
;
20970 return tbr_ambiguous_baseclass
;
20978 return tbr_success
;
20981 /* Returns the level of DECL, which declares a template parameter. */
20984 template_decl_level (tree decl
)
20986 switch (TREE_CODE (decl
))
20989 case TEMPLATE_DECL
:
20990 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
20993 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
20996 gcc_unreachable ();
21001 /* Decide whether ARG can be unified with PARM, considering only the
21002 cv-qualifiers of each type, given STRICT as documented for unify.
21003 Returns nonzero iff the unification is OK on that basis. */
21006 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
21008 int arg_quals
= cp_type_quals (arg
);
21009 int parm_quals
= cp_type_quals (parm
);
21011 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
21012 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
21014 /* Although a CVR qualifier is ignored when being applied to a
21015 substituted template parameter ([8.3.2]/1 for example), that
21016 does not allow us to unify "const T" with "int&" because both
21017 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
21018 It is ok when we're allowing additional CV qualifiers
21019 at the outer level [14.8.2.1]/3,1st bullet. */
21020 if ((TYPE_REF_P (arg
)
21021 || TREE_CODE (arg
) == FUNCTION_TYPE
21022 || TREE_CODE (arg
) == METHOD_TYPE
)
21023 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
21026 if ((!INDIRECT_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
21027 && (parm_quals
& TYPE_QUAL_RESTRICT
))
21031 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
21032 && (arg_quals
& parm_quals
) != parm_quals
)
21035 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
21036 && (parm_quals
& arg_quals
) != arg_quals
)
21042 /* Determines the LEVEL and INDEX for the template parameter PARM. */
21044 template_parm_level_and_index (tree parm
, int* level
, int* index
)
21046 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
21047 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
21048 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21050 *index
= TEMPLATE_TYPE_IDX (parm
);
21051 *level
= TEMPLATE_TYPE_LEVEL (parm
);
21055 *index
= TEMPLATE_PARM_IDX (parm
);
21056 *level
= TEMPLATE_PARM_LEVEL (parm
);
21060 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
21062 if (unify (TP, TA, P, A, S, EP)) \
21066 /* Unifies the remaining arguments in PACKED_ARGS with the pack
21067 expansion at the end of PACKED_PARMS. Returns 0 if the type
21068 deduction succeeds, 1 otherwise. STRICT is the same as in
21069 fn_type_unification. CALL_ARGS_P is true iff PACKED_ARGS is actually a
21070 function call argument list. We'll need to adjust the arguments to make them
21071 types. SUBR tells us if this is from a recursive call to
21072 type_unification_real, or for comparing two template argument
21076 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
21077 tree packed_args
, unification_kind_t strict
,
21078 bool subr
, bool explain_p
)
21081 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
21082 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
21083 tree pack
, packs
= NULL_TREE
;
21084 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
21086 /* Add in any args remembered from an earlier partial instantiation. */
21087 targs
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (parm
), targs
);
21088 int levels
= TMPL_ARGS_DEPTH (targs
);
21090 packed_args
= expand_template_argument_pack (packed_args
);
21092 int len
= TREE_VEC_LENGTH (packed_args
);
21094 /* Determine the parameter packs we will be deducing from the
21095 pattern, and record their current deductions. */
21096 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
21097 pack
; pack
= TREE_CHAIN (pack
))
21099 tree parm_pack
= TREE_VALUE (pack
);
21102 /* Only template parameter packs can be deduced, not e.g. function
21103 parameter packs or __bases or __integer_pack. */
21104 if (!TEMPLATE_PARM_P (parm_pack
))
21107 /* Determine the index and level of this parameter pack. */
21108 template_parm_level_and_index (parm_pack
, &level
, &idx
);
21109 if (level
< levels
)
21112 /* Keep track of the parameter packs and their corresponding
21114 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
21115 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
21118 /* Loop through all of the arguments that have not yet been
21119 unified and unify each with the pattern. */
21120 for (i
= start
; i
< len
; i
++)
21123 bool any_explicit
= false;
21124 tree arg
= TREE_VEC_ELT (packed_args
, i
);
21126 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
21127 or the element of its argument pack at the current index if
21128 this argument was explicitly specified. */
21129 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
21133 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
21136 if (TREE_VALUE (pack
)
21137 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
21138 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
21140 any_explicit
= true;
21141 arg
= TREE_VEC_ELT (pargs
, i
- start
);
21143 TMPL_ARG (targs
, level
, idx
) = arg
;
21146 /* If we had explicit template arguments, substitute them into the
21147 pattern before deduction. */
21150 /* Some arguments might still be unspecified or dependent. */
21152 ++processing_template_decl
;
21153 dependent
= any_dependent_template_arguments_p (targs
);
21155 --processing_template_decl
;
21156 parm
= tsubst (pattern
, targs
,
21157 explain_p
? tf_warning_or_error
: tf_none
,
21160 --processing_template_decl
;
21161 if (parm
== error_mark_node
)
21167 /* Unify the pattern with the current argument. */
21168 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
21172 /* For each parameter pack, collect the deduced value. */
21173 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
21176 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
21178 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
21179 TMPL_ARG (targs
, level
, idx
);
21183 /* Verify that the results of unification with the parameter packs
21184 produce results consistent with what we've seen before, and make
21185 the deduced argument packs available. */
21186 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
21188 tree old_pack
= TREE_VALUE (pack
);
21189 tree new_args
= TREE_TYPE (pack
);
21190 int i
, len
= TREE_VEC_LENGTH (new_args
);
21192 bool nondeduced_p
= false;
21194 /* By default keep the original deduced argument pack.
21195 If necessary, more specific code is going to update the
21196 resulting deduced argument later down in this function. */
21197 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
21198 TMPL_ARG (targs
, level
, idx
) = old_pack
;
21200 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
21201 actually deduce anything. */
21202 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
21203 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
21204 nondeduced_p
= true;
21208 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
21210 /* If we had fewer function args than explicit template args,
21211 just use the explicits. */
21212 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
21213 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
21214 if (len
< explicit_len
)
21215 new_args
= explicit_args
;
21221 /* Build the deduced *_ARGUMENT_PACK. */
21222 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
21224 result
= make_node (NONTYPE_ARGUMENT_PACK
);
21225 TREE_CONSTANT (result
) = 1;
21228 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
21230 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
21232 /* Note the deduced argument packs for this parameter
21234 TMPL_ARG (targs
, level
, idx
) = result
;
21236 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
21237 && (ARGUMENT_PACK_ARGS (old_pack
)
21238 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
21240 /* We only had the explicitly-provided arguments before, but
21241 now we have a complete set of arguments. */
21242 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
21244 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
21245 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
21246 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
21250 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
21251 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
21253 if (!comp_template_args (old_args
, new_args
,
21254 &bad_old_arg
, &bad_new_arg
))
21255 /* Inconsistent unification of this parameter pack. */
21256 return unify_parameter_pack_inconsistent (explain_p
,
21262 return unify_success (explain_p
);
21265 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
21266 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
21267 parameters and return value are as for unify. */
21270 unify_array_domain (tree tparms
, tree targs
,
21271 tree parm_dom
, tree arg_dom
,
21279 /* Our representation of array types uses "N - 1" as the
21280 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
21281 not an integer constant. We cannot unify arbitrarily
21282 complex expressions, so we eliminate the MINUS_EXPRs
21284 parm_max
= TYPE_MAX_VALUE (parm_dom
);
21285 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
21288 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
21289 parm_max
= TREE_OPERAND (parm_max
, 0);
21291 arg_max
= TYPE_MAX_VALUE (arg_dom
);
21292 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
21295 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
21296 trying to unify the type of a variable with the type
21297 of a template parameter. For example:
21299 template <unsigned int N>
21300 void f (char (&) [N]);
21307 Here, the type of the ARG will be "int [g(i)]", and
21308 may be a SAVE_EXPR, etc. */
21309 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
21310 return unify_vla_arg (explain_p
, arg_dom
);
21311 arg_max
= TREE_OPERAND (arg_max
, 0);
21314 /* If only one of the bounds used a MINUS_EXPR, compensate
21315 by adding one to the other bound. */
21316 if (parm_cst
&& !arg_cst
)
21317 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
21321 else if (arg_cst
&& !parm_cst
)
21322 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
21327 return unify (tparms
, targs
, parm_max
, arg_max
,
21328 UNIFY_ALLOW_INTEGER
, explain_p
);
21331 /* Returns whether T, a P or A in unify, is a type, template or expression. */
21333 enum pa_kind_t
{ pa_type
, pa_tmpl
, pa_expr
};
21338 if (PACK_EXPANSION_P (t
))
21339 t
= PACK_EXPANSION_PATTERN (t
);
21340 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
21341 || TREE_CODE (t
) == UNBOUND_CLASS_TEMPLATE
21342 || DECL_TYPE_TEMPLATE_P (t
))
21344 else if (TYPE_P (t
))
21350 /* Deduce the value of template parameters. TPARMS is the (innermost)
21351 set of template parameters to a template. TARGS is the bindings
21352 for those template parameters, as determined thus far; TARGS may
21353 include template arguments for outer levels of template parameters
21354 as well. PARM is a parameter to a template function, or a
21355 subcomponent of that parameter; ARG is the corresponding argument.
21356 This function attempts to match PARM with ARG in a manner
21357 consistent with the existing assignments in TARGS. If more values
21358 are deduced, then TARGS is updated.
21360 Returns 0 if the type deduction succeeds, 1 otherwise. The
21361 parameter STRICT is a bitwise or of the following flags:
21364 Require an exact match between PARM and ARG.
21365 UNIFY_ALLOW_MORE_CV_QUAL:
21366 Allow the deduced ARG to be more cv-qualified (by qualification
21367 conversion) than ARG.
21368 UNIFY_ALLOW_LESS_CV_QUAL:
21369 Allow the deduced ARG to be less cv-qualified than ARG.
21370 UNIFY_ALLOW_DERIVED:
21371 Allow the deduced ARG to be a template base class of ARG,
21372 or a pointer to a template base class of the type pointed to by
21374 UNIFY_ALLOW_INTEGER:
21375 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
21376 case for more information.
21377 UNIFY_ALLOW_OUTER_LEVEL:
21378 This is the outermost level of a deduction. Used to determine validity
21379 of qualification conversions. A valid qualification conversion must
21380 have const qualified pointers leading up to the inner type which
21381 requires additional CV quals, except at the outer level, where const
21382 is not required [conv.qual]. It would be normal to set this flag in
21383 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
21384 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
21385 This is the outermost level of a deduction, and PARM can be more CV
21386 qualified at this point.
21387 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
21388 This is the outermost level of a deduction, and PARM can be less CV
21389 qualified at this point. */
21392 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
21398 int strict_in
= strict
;
21399 tsubst_flags_t complain
= (explain_p
21400 ? tf_warning_or_error
21403 /* I don't think this will do the right thing with respect to types.
21404 But the only case I've seen it in so far has been array bounds, where
21405 signedness is the only information lost, and I think that will be
21407 while (CONVERT_EXPR_P (parm
))
21408 parm
= TREE_OPERAND (parm
, 0);
21410 if (arg
== error_mark_node
)
21411 return unify_invalid (explain_p
);
21412 if (arg
== unknown_type_node
21413 || arg
== init_list_type_node
)
21414 /* We can't deduce anything from this, but we might get all the
21415 template args from other function args. */
21416 return unify_success (explain_p
);
21418 if (parm
== any_targ_node
|| arg
== any_targ_node
)
21419 return unify_success (explain_p
);
21421 /* If PARM uses template parameters, then we can't bail out here,
21422 even if ARG == PARM, since we won't record unifications for the
21423 template parameters. We might need them if we're trying to
21424 figure out which of two things is more specialized. */
21425 if (arg
== parm
&& !uses_template_parms (parm
))
21426 return unify_success (explain_p
);
21428 /* Handle init lists early, so the rest of the function can assume
21429 we're dealing with a type. */
21430 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
21434 tree orig_parm
= parm
;
21436 /* Replace T with std::initializer_list<T> for deduction. */
21437 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
21438 && flag_deduce_init_list
)
21439 parm
= listify (parm
);
21441 if (!is_std_init_list (parm
)
21442 && TREE_CODE (parm
) != ARRAY_TYPE
)
21443 /* We can only deduce from an initializer list argument if the
21444 parameter is std::initializer_list or an array; otherwise this
21445 is a non-deduced context. */
21446 return unify_success (explain_p
);
21448 if (TREE_CODE (parm
) == ARRAY_TYPE
)
21449 elttype
= TREE_TYPE (parm
);
21452 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
21453 /* Deduction is defined in terms of a single type, so just punt
21454 on the (bizarre) std::initializer_list<T...>. */
21455 if (PACK_EXPANSION_P (elttype
))
21456 return unify_success (explain_p
);
21459 if (strict
!= DEDUCE_EXACT
21460 && TYPE_P (elttype
)
21461 && !uses_deducible_template_parms (elttype
))
21462 /* If ELTTYPE has no deducible template parms, skip deduction from
21463 the list elements. */;
21465 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
21467 int elt_strict
= strict
;
21469 if (elt
== error_mark_node
)
21470 return unify_invalid (explain_p
);
21472 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
21474 tree type
= TREE_TYPE (elt
);
21475 if (type
== error_mark_node
)
21476 return unify_invalid (explain_p
);
21477 /* It should only be possible to get here for a call. */
21478 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
21479 elt_strict
|= maybe_adjust_types_for_deduction
21480 (DEDUCE_CALL
, &elttype
, &type
, elt
);
21484 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
21488 if (TREE_CODE (parm
) == ARRAY_TYPE
21489 && deducible_array_bound (TYPE_DOMAIN (parm
)))
21491 /* Also deduce from the length of the initializer list. */
21492 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
21493 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
21494 if (idx
== error_mark_node
)
21495 return unify_invalid (explain_p
);
21496 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
21500 /* If the std::initializer_list<T> deduction worked, replace the
21501 deduced A with std::initializer_list<A>. */
21502 if (orig_parm
!= parm
)
21504 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
21505 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
21506 targ
= listify (targ
);
21507 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
21509 return unify_success (explain_p
);
21512 /* If parm and arg aren't the same kind of thing (template, type, or
21513 expression), fail early. */
21514 if (pa_kind (parm
) != pa_kind (arg
))
21515 return unify_invalid (explain_p
);
21517 /* Immediately reject some pairs that won't unify because of
21518 cv-qualification mismatches. */
21519 if (TREE_CODE (arg
) == TREE_CODE (parm
)
21521 /* It is the elements of the array which hold the cv quals of an array
21522 type, and the elements might be template type parms. We'll check
21523 when we recurse. */
21524 && TREE_CODE (arg
) != ARRAY_TYPE
21525 /* We check the cv-qualifiers when unifying with template type
21526 parameters below. We want to allow ARG `const T' to unify with
21527 PARM `T' for example, when computing which of two templates
21528 is more specialized, for example. */
21529 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
21530 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
21531 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
21533 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
21534 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
21535 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
21536 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
21537 strict
&= ~UNIFY_ALLOW_DERIVED
;
21538 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
21539 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
21541 switch (TREE_CODE (parm
))
21543 case TYPENAME_TYPE
:
21545 case UNBOUND_CLASS_TEMPLATE
:
21546 /* In a type which contains a nested-name-specifier, template
21547 argument values cannot be deduced for template parameters used
21548 within the nested-name-specifier. */
21549 return unify_success (explain_p
);
21551 case TEMPLATE_TYPE_PARM
:
21552 case TEMPLATE_TEMPLATE_PARM
:
21553 case BOUND_TEMPLATE_TEMPLATE_PARM
:
21554 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
21555 if (error_operand_p (tparm
))
21556 return unify_invalid (explain_p
);
21558 if (TEMPLATE_TYPE_LEVEL (parm
)
21559 != template_decl_level (tparm
))
21560 /* The PARM is not one we're trying to unify. Just check
21561 to see if it matches ARG. */
21563 if (TREE_CODE (arg
) == TREE_CODE (parm
)
21564 && (is_auto (parm
) ? is_auto (arg
)
21565 : same_type_p (parm
, arg
)))
21566 return unify_success (explain_p
);
21568 return unify_type_mismatch (explain_p
, parm
, arg
);
21570 idx
= TEMPLATE_TYPE_IDX (parm
);
21571 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
21572 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
21573 if (error_operand_p (tparm
))
21574 return unify_invalid (explain_p
);
21576 /* Check for mixed types and values. */
21577 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
21578 && TREE_CODE (tparm
) != TYPE_DECL
)
21579 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
21580 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
21581 gcc_unreachable ();
21583 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21585 if ((strict_in
& UNIFY_ALLOW_DERIVED
)
21586 && CLASS_TYPE_P (arg
))
21588 /* First try to match ARG directly. */
21589 tree t
= try_class_unification (tparms
, targs
, parm
, arg
,
21593 /* Otherwise, look for a suitable base of ARG, as below. */
21594 enum template_base_result r
;
21595 r
= get_template_base (tparms
, targs
, parm
, arg
,
21598 return unify_no_common_base (explain_p
, r
, parm
, arg
);
21602 /* ARG must be constructed from a template class or a template
21603 template parameter. */
21604 else if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
21605 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
21606 return unify_template_deduction_failure (explain_p
, parm
, arg
);
21608 /* Deduce arguments T, i from TT<T> or TT<i>. */
21609 if (unify_bound_ttp_args (tparms
, targs
, parm
, arg
, explain_p
))
21612 arg
= TYPE_TI_TEMPLATE (arg
);
21614 /* Fall through to deduce template name. */
21617 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
21618 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
21620 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
21622 /* Simple cases: Value already set, does match or doesn't. */
21623 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
21624 return unify_success (explain_p
);
21626 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
21630 /* If PARM is `const T' and ARG is only `int', we don't have
21631 a match unless we are allowing additional qualification.
21632 If ARG is `const int' and PARM is just `T' that's OK;
21633 that binds `const int' to `T'. */
21634 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
21636 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
21638 /* Consider the case where ARG is `const volatile int' and
21639 PARM is `const T'. Then, T should be `volatile int'. */
21640 arg
= cp_build_qualified_type_real
21641 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
21642 if (arg
== error_mark_node
)
21643 return unify_invalid (explain_p
);
21645 /* Simple cases: Value already set, does match or doesn't. */
21646 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
21647 return unify_success (explain_p
);
21649 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
21651 /* Make sure that ARG is not a variable-sized array. (Note
21652 that were talking about variable-sized arrays (like
21653 `int[n]'), rather than arrays of unknown size (like
21654 `int[]').) We'll get very confused by such a type since
21655 the bound of the array is not constant, and therefore
21656 not mangleable. Besides, such types are not allowed in
21657 ISO C++, so we can do as we please here. We do allow
21658 them for 'auto' deduction, since that isn't ABI-exposed. */
21659 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
21660 return unify_vla_arg (explain_p
, arg
);
21662 /* Strip typedefs as in convert_template_argument. */
21663 arg
= canonicalize_type_argument (arg
, tf_none
);
21666 /* If ARG is a parameter pack or an expansion, we cannot unify
21667 against it unless PARM is also a parameter pack. */
21668 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
21669 && !template_parameter_pack_p (parm
))
21670 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
21672 /* If the argument deduction results is a METHOD_TYPE,
21673 then there is a problem.
21674 METHOD_TYPE doesn't map to any real C++ type the result of
21675 the deduction can not be of that type. */
21676 if (TREE_CODE (arg
) == METHOD_TYPE
)
21677 return unify_method_type_error (explain_p
, arg
);
21679 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
21680 return unify_success (explain_p
);
21682 case TEMPLATE_PARM_INDEX
:
21683 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
21684 if (error_operand_p (tparm
))
21685 return unify_invalid (explain_p
);
21687 if (TEMPLATE_PARM_LEVEL (parm
)
21688 != template_decl_level (tparm
))
21690 /* The PARM is not one we're trying to unify. Just check
21691 to see if it matches ARG. */
21692 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
21693 && cp_tree_equal (parm
, arg
));
21695 unify_expression_unequal (explain_p
, parm
, arg
);
21699 idx
= TEMPLATE_PARM_IDX (parm
);
21700 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
21704 if ((strict
& UNIFY_ALLOW_INTEGER
)
21705 && TREE_TYPE (targ
) && TREE_TYPE (arg
)
21706 && CP_INTEGRAL_TYPE_P (TREE_TYPE (targ
)))
21707 /* We're deducing from an array bound, the type doesn't matter. */
21708 arg
= fold_convert (TREE_TYPE (targ
), arg
);
21709 int x
= !cp_tree_equal (targ
, arg
);
21711 unify_inconsistency (explain_p
, parm
, targ
, arg
);
21715 /* [temp.deduct.type] If, in the declaration of a function template
21716 with a non-type template-parameter, the non-type
21717 template-parameter is used in an expression in the function
21718 parameter-list and, if the corresponding template-argument is
21719 deduced, the template-argument type shall match the type of the
21720 template-parameter exactly, except that a template-argument
21721 deduced from an array bound may be of any integral type.
21722 The non-type parameter might use already deduced type parameters. */
21723 tparm
= TREE_TYPE (parm
);
21724 if (TEMPLATE_PARM_LEVEL (parm
) > TMPL_ARGS_DEPTH (targs
))
21725 /* We don't have enough levels of args to do any substitution. This
21726 can happen in the context of -fnew-ttp-matching. */;
21729 ++processing_template_decl
;
21730 tparm
= tsubst (tparm
, targs
, tf_none
, NULL_TREE
);
21731 --processing_template_decl
;
21733 if (tree a
= type_uses_auto (tparm
))
21735 tparm
= do_auto_deduction (tparm
, arg
, a
, complain
, adc_unify
);
21736 if (tparm
== error_mark_node
)
21741 if (!TREE_TYPE (arg
))
21742 /* Template-parameter dependent expression. Just accept it for now.
21743 It will later be processed in convert_template_argument. */
21745 else if (same_type_p (non_reference (TREE_TYPE (arg
)),
21746 non_reference (tparm
)))
21748 else if ((strict
& UNIFY_ALLOW_INTEGER
)
21749 && CP_INTEGRAL_TYPE_P (tparm
))
21750 /* Convert the ARG to the type of PARM; the deduced non-type
21751 template argument must exactly match the types of the
21752 corresponding parameter. */
21753 arg
= fold (build_nop (tparm
, arg
));
21754 else if (uses_template_parms (tparm
))
21756 /* We haven't deduced the type of this parameter yet. */
21757 if (cxx_dialect
>= cxx17
21758 /* We deduce from array bounds in try_array_deduction. */
21759 && !(strict
& UNIFY_ALLOW_INTEGER
))
21761 /* Deduce it from the non-type argument. */
21762 tree atype
= TREE_TYPE (arg
);
21763 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
21765 UNIFY_ALLOW_NONE
, explain_p
);
21768 /* Try again later. */
21769 return unify_success (explain_p
);
21772 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
21774 /* If ARG is a parameter pack or an expansion, we cannot unify
21775 against it unless PARM is also a parameter pack. */
21776 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
21777 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
21778 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
21781 bool removed_attr
= false;
21782 arg
= strip_typedefs_expr (arg
, &removed_attr
);
21784 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
21785 return unify_success (explain_p
);
21789 /* A pointer-to-member constant can be unified only with
21790 another constant. */
21791 if (TREE_CODE (arg
) != PTRMEM_CST
)
21792 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
21794 /* Just unify the class member. It would be useless (and possibly
21795 wrong, depending on the strict flags) to unify also
21796 PTRMEM_CST_CLASS, because we want to be sure that both parm and
21797 arg refer to the same variable, even if through different
21798 classes. For instance:
21800 struct A { int x; };
21803 Unification of &A::x and &B::x must succeed. */
21804 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
21805 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
21810 if (!TYPE_PTR_P (arg
))
21811 return unify_type_mismatch (explain_p
, parm
, arg
);
21813 /* [temp.deduct.call]
21815 A can be another pointer or pointer to member type that can
21816 be converted to the deduced A via a qualification
21817 conversion (_conv.qual_).
21819 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
21820 This will allow for additional cv-qualification of the
21821 pointed-to types if appropriate. */
21823 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
21824 /* The derived-to-base conversion only persists through one
21825 level of pointers. */
21826 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
21828 return unify (tparms
, targs
, TREE_TYPE (parm
),
21829 TREE_TYPE (arg
), strict
, explain_p
);
21832 case REFERENCE_TYPE
:
21833 if (!TYPE_REF_P (arg
))
21834 return unify_type_mismatch (explain_p
, parm
, arg
);
21835 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
21836 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
21839 if (TREE_CODE (arg
) != ARRAY_TYPE
)
21840 return unify_type_mismatch (explain_p
, parm
, arg
);
21841 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
21842 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
21843 return unify_type_mismatch (explain_p
, parm
, arg
);
21844 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
21845 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
21846 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
21847 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
21848 TYPE_DOMAIN (arg
), explain_p
);
21849 return unify_success (explain_p
);
21856 case ENUMERAL_TYPE
:
21859 if (TREE_CODE (arg
) != TREE_CODE (parm
))
21860 return unify_type_mismatch (explain_p
, parm
, arg
);
21862 /* We have already checked cv-qualification at the top of the
21864 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
21865 return unify_type_mismatch (explain_p
, parm
, arg
);
21867 /* As far as unification is concerned, this wins. Later checks
21868 will invalidate it if necessary. */
21869 return unify_success (explain_p
);
21871 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
21872 /* Type INTEGER_CST can come from ordinary constant template args. */
21874 while (CONVERT_EXPR_P (arg
))
21875 arg
= TREE_OPERAND (arg
, 0);
21877 if (TREE_CODE (arg
) != INTEGER_CST
)
21878 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
21879 return (tree_int_cst_equal (parm
, arg
)
21880 ? unify_success (explain_p
)
21881 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
21885 int i
, len
, argslen
;
21886 int parm_variadic_p
= 0;
21888 if (TREE_CODE (arg
) != TREE_VEC
)
21889 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
21891 len
= TREE_VEC_LENGTH (parm
);
21892 argslen
= TREE_VEC_LENGTH (arg
);
21894 /* Check for pack expansions in the parameters. */
21895 for (i
= 0; i
< len
; ++i
)
21897 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
21900 /* We can unify against something with a trailing
21902 parm_variadic_p
= 1;
21904 /* [temp.deduct.type]/9: If the template argument list of
21905 P contains a pack expansion that is not the last
21906 template argument, the entire template argument list
21907 is a non-deduced context. */
21908 return unify_success (explain_p
);
21912 /* If we don't have enough arguments to satisfy the parameters
21913 (not counting the pack expression at the end), or we have
21914 too many arguments for a parameter list that doesn't end in
21915 a pack expression, we can't unify. */
21916 if (parm_variadic_p
21917 ? argslen
< len
- parm_variadic_p
21919 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
21921 /* Unify all of the parameters that precede the (optional)
21922 pack expression. */
21923 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
21925 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
21926 TREE_VEC_ELT (parm
, i
),
21927 TREE_VEC_ELT (arg
, i
),
21928 UNIFY_ALLOW_NONE
, explain_p
);
21930 if (parm_variadic_p
)
21931 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
21933 /*subr=*/true, explain_p
);
21934 return unify_success (explain_p
);
21939 if (TREE_CODE (arg
) != TREE_CODE (parm
))
21940 return unify_type_mismatch (explain_p
, parm
, arg
);
21942 if (TYPE_PTRMEMFUNC_P (parm
))
21944 if (!TYPE_PTRMEMFUNC_P (arg
))
21945 return unify_type_mismatch (explain_p
, parm
, arg
);
21947 return unify (tparms
, targs
,
21948 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
21949 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
21950 strict
, explain_p
);
21952 else if (TYPE_PTRMEMFUNC_P (arg
))
21953 return unify_type_mismatch (explain_p
, parm
, arg
);
21955 if (CLASSTYPE_TEMPLATE_INFO (parm
))
21957 tree t
= NULL_TREE
;
21959 if (strict_in
& UNIFY_ALLOW_DERIVED
)
21961 /* First, we try to unify the PARM and ARG directly. */
21962 t
= try_class_unification (tparms
, targs
,
21963 parm
, arg
, explain_p
);
21967 /* Fallback to the special case allowed in
21968 [temp.deduct.call]:
21970 If P is a class, and P has the form
21971 template-id, then A can be a derived class of
21972 the deduced A. Likewise, if P is a pointer to
21973 a class of the form template-id, A can be a
21974 pointer to a derived class pointed to by the
21976 enum template_base_result r
;
21977 r
= get_template_base (tparms
, targs
, parm
, arg
,
21982 /* Don't give the derived diagnostic if we're
21983 already dealing with the same template. */
21985 = (CLASSTYPE_TEMPLATE_INFO (arg
)
21986 && (CLASSTYPE_TI_TEMPLATE (parm
)
21987 == CLASSTYPE_TI_TEMPLATE (arg
)));
21988 return unify_no_common_base (explain_p
&& !same_template
,
21993 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
21994 && (CLASSTYPE_TI_TEMPLATE (parm
)
21995 == CLASSTYPE_TI_TEMPLATE (arg
)))
21996 /* Perhaps PARM is something like S<U> and ARG is S<int>.
21997 Then, we should unify `int' and `U'. */
22000 /* There's no chance of unification succeeding. */
22001 return unify_type_mismatch (explain_p
, parm
, arg
);
22003 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
22004 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
22006 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
22007 return unify_type_mismatch (explain_p
, parm
, arg
);
22008 return unify_success (explain_p
);
22011 case FUNCTION_TYPE
:
22013 unsigned int nargs
;
22018 if (TREE_CODE (arg
) != TREE_CODE (parm
))
22019 return unify_type_mismatch (explain_p
, parm
, arg
);
22021 /* CV qualifications for methods can never be deduced, they must
22022 match exactly. We need to check them explicitly here,
22023 because type_unification_real treats them as any other
22024 cv-qualified parameter. */
22025 if (TREE_CODE (parm
) == METHOD_TYPE
22026 && (!check_cv_quals_for_unify
22028 class_of_this_parm (arg
),
22029 class_of_this_parm (parm
))))
22030 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22031 if (TREE_CODE (arg
) == FUNCTION_TYPE
22032 && type_memfn_quals (parm
) != type_memfn_quals (arg
))
22033 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22034 if (type_memfn_rqual (parm
) != type_memfn_rqual (arg
))
22035 return unify_type_mismatch (explain_p
, parm
, arg
);
22037 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
22038 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
22040 nargs
= list_length (TYPE_ARG_TYPES (arg
));
22041 args
= XALLOCAVEC (tree
, nargs
);
22042 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
22043 a
!= NULL_TREE
&& a
!= void_list_node
;
22044 a
= TREE_CHAIN (a
), ++i
)
22045 args
[i
] = TREE_VALUE (a
);
22048 if (type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
22049 args
, nargs
, 1, DEDUCE_EXACT
,
22053 if (flag_noexcept_type
)
22055 tree pspec
= TYPE_RAISES_EXCEPTIONS (parm
);
22056 tree aspec
= canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (arg
));
22057 if (pspec
== NULL_TREE
) pspec
= noexcept_false_spec
;
22058 if (aspec
== NULL_TREE
) aspec
= noexcept_false_spec
;
22059 if (TREE_PURPOSE (pspec
) && TREE_PURPOSE (aspec
)
22060 && uses_template_parms (TREE_PURPOSE (pspec
)))
22061 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_PURPOSE (pspec
),
22062 TREE_PURPOSE (aspec
),
22063 UNIFY_ALLOW_NONE
, explain_p
);
22064 else if (nothrow_spec_p (pspec
) && !nothrow_spec_p (aspec
))
22065 return unify_type_mismatch (explain_p
, parm
, arg
);
22072 /* Unify a pointer to member with a pointer to member function, which
22073 deduces the type of the member as a function type. */
22074 if (TYPE_PTRMEMFUNC_P (arg
))
22076 /* Check top-level cv qualifiers */
22077 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
22078 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
22080 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
22081 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
22082 UNIFY_ALLOW_NONE
, explain_p
);
22084 /* Determine the type of the function we are unifying against. */
22085 tree fntype
= static_fn_type (arg
);
22087 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
22090 if (TREE_CODE (arg
) != OFFSET_TYPE
)
22091 return unify_type_mismatch (explain_p
, parm
, arg
);
22092 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
22093 TYPE_OFFSET_BASETYPE (arg
),
22094 UNIFY_ALLOW_NONE
, explain_p
);
22095 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
22096 strict
, explain_p
);
22099 if (DECL_TEMPLATE_PARM_P (parm
))
22100 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
22101 if (arg
!= scalar_constant_value (parm
))
22102 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22103 return unify_success (explain_p
);
22106 case TEMPLATE_DECL
:
22107 /* Matched cases are handled by the ARG == PARM test above. */
22108 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
22111 /* We might get a variable as a non-type template argument in parm if the
22112 corresponding parameter is type-dependent. Make any necessary
22113 adjustments based on whether arg is a reference. */
22114 if (CONSTANT_CLASS_P (arg
))
22115 parm
= fold_non_dependent_expr (parm
, complain
);
22116 else if (REFERENCE_REF_P (arg
))
22118 tree sub
= TREE_OPERAND (arg
, 0);
22120 if (TREE_CODE (sub
) == ADDR_EXPR
)
22121 arg
= TREE_OPERAND (sub
, 0);
22123 /* Now use the normal expression code to check whether they match. */
22126 case TYPE_ARGUMENT_PACK
:
22127 case NONTYPE_ARGUMENT_PACK
:
22128 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
22129 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
22132 case DECLTYPE_TYPE
:
22133 case UNDERLYING_TYPE
:
22134 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
22135 or UNDERLYING_TYPE nodes. */
22136 return unify_success (explain_p
);
22139 /* Unification fails if we hit an error node. */
22140 return unify_invalid (explain_p
);
22143 if (REFERENCE_REF_P (parm
))
22145 bool pexp
= PACK_EXPANSION_P (arg
);
22147 arg
= PACK_EXPANSION_PATTERN (arg
);
22148 if (REFERENCE_REF_P (arg
))
22149 arg
= TREE_OPERAND (arg
, 0);
22151 arg
= make_pack_expansion (arg
, complain
);
22152 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
22153 strict
, explain_p
);
22158 /* An unresolved overload is a nondeduced context. */
22159 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
22160 return unify_success (explain_p
);
22161 gcc_assert (EXPR_P (parm
) || TREE_CODE (parm
) == TRAIT_EXPR
);
22163 /* We must be looking at an expression. This can happen with
22167 void foo(S<I>, S<I + 2>);
22169 This is a "nondeduced context":
22173 The nondeduced contexts are:
22175 --A type that is a template-id in which one or more of
22176 the template-arguments is an expression that references
22177 a template-parameter.
22179 In these cases, we assume deduction succeeded, but don't
22180 actually infer any unifications. */
22182 if (!uses_template_parms (parm
)
22183 && !template_args_equal (parm
, arg
))
22184 return unify_expression_unequal (explain_p
, parm
, arg
);
22186 return unify_success (explain_p
);
22189 #undef RECUR_AND_CHECK_FAILURE
22191 /* Note that DECL can be defined in this translation unit, if
22195 mark_definable (tree decl
)
22198 DECL_NOT_REALLY_EXTERN (decl
) = 1;
22199 FOR_EACH_CLONE (clone
, decl
)
22200 DECL_NOT_REALLY_EXTERN (clone
) = 1;
22203 /* Called if RESULT is explicitly instantiated, or is a member of an
22204 explicitly instantiated class. */
22207 mark_decl_instantiated (tree result
, int extern_p
)
22209 SET_DECL_EXPLICIT_INSTANTIATION (result
);
22211 /* If this entity has already been written out, it's too late to
22212 make any modifications. */
22213 if (TREE_ASM_WRITTEN (result
))
22216 /* For anonymous namespace we don't need to do anything. */
22217 if (decl_anon_ns_mem_p (result
))
22219 gcc_assert (!TREE_PUBLIC (result
));
22223 if (TREE_CODE (result
) != FUNCTION_DECL
)
22224 /* The TREE_PUBLIC flag for function declarations will have been
22225 set correctly by tsubst. */
22226 TREE_PUBLIC (result
) = 1;
22228 /* This might have been set by an earlier implicit instantiation. */
22229 DECL_COMDAT (result
) = 0;
22232 DECL_NOT_REALLY_EXTERN (result
) = 0;
22235 mark_definable (result
);
22236 mark_needed (result
);
22237 /* Always make artificials weak. */
22238 if (DECL_ARTIFICIAL (result
) && flag_weak
)
22239 comdat_linkage (result
);
22240 /* For WIN32 we also want to put explicit instantiations in
22241 linkonce sections. */
22242 else if (TREE_PUBLIC (result
))
22243 maybe_make_one_only (result
);
22244 if (TREE_CODE (result
) == FUNCTION_DECL
22245 && DECL_TEMPLATE_INSTANTIATED (result
))
22246 /* If the function has already been instantiated, clear DECL_EXTERNAL,
22247 since start_preparsed_function wouldn't have if we had an earlier
22248 extern explicit instantiation. */
22249 DECL_EXTERNAL (result
) = 0;
22252 /* If EXTERN_P, then this function will not be emitted -- unless
22253 followed by an explicit instantiation, at which point its linkage
22254 will be adjusted. If !EXTERN_P, then this function will be
22255 emitted here. In neither circumstance do we want
22256 import_export_decl to adjust the linkage. */
22257 DECL_INTERFACE_KNOWN (result
) = 1;
22260 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
22261 important template arguments. If any are missing, we check whether
22262 they're important by using error_mark_node for substituting into any
22263 args that were used for partial ordering (the ones between ARGS and END)
22264 and seeing if it bubbles up. */
22267 check_undeduced_parms (tree targs
, tree args
, tree end
)
22269 bool found
= false;
22271 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
22272 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
22275 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
22279 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
22280 if (substed
== error_mark_node
)
22286 /* Given two function templates PAT1 and PAT2, return:
22288 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
22289 -1 if PAT2 is more specialized than PAT1.
22290 0 if neither is more specialized.
22292 LEN indicates the number of parameters we should consider
22293 (defaulted parameters should not be considered).
22295 The 1998 std underspecified function template partial ordering, and
22296 DR214 addresses the issue. We take pairs of arguments, one from
22297 each of the templates, and deduce them against each other. One of
22298 the templates will be more specialized if all the *other*
22299 template's arguments deduce against its arguments and at least one
22300 of its arguments *does* *not* deduce against the other template's
22301 corresponding argument. Deduction is done as for class templates.
22302 The arguments used in deduction have reference and top level cv
22303 qualifiers removed. Iff both arguments were originally reference
22304 types *and* deduction succeeds in both directions, an lvalue reference
22305 wins against an rvalue reference and otherwise the template
22306 with the more cv-qualified argument wins for that pairing (if
22307 neither is more cv-qualified, they both are equal). Unlike regular
22308 deduction, after all the arguments have been deduced in this way,
22309 we do *not* verify the deduced template argument values can be
22310 substituted into non-deduced contexts.
22312 The logic can be a bit confusing here, because we look at deduce1 and
22313 targs1 to see if pat2 is at least as specialized, and vice versa; if we
22314 can find template arguments for pat1 to make arg1 look like arg2, that
22315 means that arg2 is at least as specialized as arg1. */
22318 more_specialized_fn (tree pat1
, tree pat2
, int len
)
22320 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
22321 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
22322 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
22323 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
22324 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
22325 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
22326 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
22327 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
22328 tree origs1
, origs2
;
22329 bool lose1
= false;
22330 bool lose2
= false;
22332 /* Remove the this parameter from non-static member functions. If
22333 one is a non-static member function and the other is not a static
22334 member function, remove the first parameter from that function
22335 also. This situation occurs for operator functions where we
22336 locate both a member function (with this pointer) and non-member
22337 operator (with explicit first operand). */
22338 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
22340 len
--; /* LEN is the number of significant arguments for DECL1 */
22341 args1
= TREE_CHAIN (args1
);
22342 if (!DECL_STATIC_FUNCTION_P (decl2
))
22343 args2
= TREE_CHAIN (args2
);
22345 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
22347 args2
= TREE_CHAIN (args2
);
22348 if (!DECL_STATIC_FUNCTION_P (decl1
))
22351 args1
= TREE_CHAIN (args1
);
22355 /* If only one is a conversion operator, they are unordered. */
22356 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
22359 /* Consider the return type for a conversion function */
22360 if (DECL_CONV_FN_P (decl1
))
22362 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
22363 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
22367 processing_template_decl
++;
22373 /* Stop when an ellipsis is seen. */
22374 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
22376 tree arg1
= TREE_VALUE (args1
);
22377 tree arg2
= TREE_VALUE (args2
);
22378 int deduce1
, deduce2
;
22384 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
22385 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
22387 /* When both arguments are pack expansions, we need only
22388 unify the patterns themselves. */
22389 arg1
= PACK_EXPANSION_PATTERN (arg1
);
22390 arg2
= PACK_EXPANSION_PATTERN (arg2
);
22392 /* This is the last comparison we need to do. */
22396 /* DR 1847: If a particular P contains no template-parameters that
22397 participate in template argument deduction, that P is not used to
22398 determine the ordering. */
22399 if (!uses_deducible_template_parms (arg1
)
22400 && !uses_deducible_template_parms (arg2
))
22403 if (TYPE_REF_P (arg1
))
22405 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
22406 arg1
= TREE_TYPE (arg1
);
22407 quals1
= cp_type_quals (arg1
);
22410 if (TYPE_REF_P (arg2
))
22412 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
22413 arg2
= TREE_TYPE (arg2
);
22414 quals2
= cp_type_quals (arg2
);
22417 arg1
= TYPE_MAIN_VARIANT (arg1
);
22418 arg2
= TYPE_MAIN_VARIANT (arg2
);
22420 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
22422 int i
, len2
= remaining_arguments (args2
);
22423 tree parmvec
= make_tree_vec (1);
22424 tree argvec
= make_tree_vec (len2
);
22427 /* Setup the parameter vector, which contains only ARG1. */
22428 TREE_VEC_ELT (parmvec
, 0) = arg1
;
22430 /* Setup the argument vector, which contains the remaining
22432 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
22433 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
22435 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
22436 argvec
, DEDUCE_EXACT
,
22437 /*subr=*/true, /*explain_p=*/false)
22440 /* We cannot deduce in the other direction, because ARG1 is
22441 a pack expansion but ARG2 is not. */
22444 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
22446 int i
, len1
= remaining_arguments (args1
);
22447 tree parmvec
= make_tree_vec (1);
22448 tree argvec
= make_tree_vec (len1
);
22451 /* Setup the parameter vector, which contains only ARG1. */
22452 TREE_VEC_ELT (parmvec
, 0) = arg2
;
22454 /* Setup the argument vector, which contains the remaining
22456 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
22457 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
22459 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
22460 argvec
, DEDUCE_EXACT
,
22461 /*subr=*/true, /*explain_p=*/false)
22464 /* We cannot deduce in the other direction, because ARG2 is
22465 a pack expansion but ARG1 is not.*/
22471 /* The normal case, where neither argument is a pack
22473 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
22474 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
22476 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
22477 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
22481 /* If we couldn't deduce arguments for tparms1 to make arg1 match
22482 arg2, then arg2 is not as specialized as arg1. */
22488 /* "If, for a given type, deduction succeeds in both directions
22489 (i.e., the types are identical after the transformations above)
22490 and both P and A were reference types (before being replaced with
22491 the type referred to above):
22492 - if the type from the argument template was an lvalue reference and
22493 the type from the parameter template was not, the argument type is
22494 considered to be more specialized than the other; otherwise,
22495 - if the type from the argument template is more cv-qualified
22496 than the type from the parameter template (as described above),
22497 the argument type is considered to be more specialized than the other;
22499 - neither type is more specialized than the other." */
22501 if (deduce1
&& deduce2
)
22503 if (ref1
&& ref2
&& ref1
!= ref2
)
22510 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
22512 if ((quals1
& quals2
) == quals2
)
22514 if ((quals1
& quals2
) == quals1
)
22519 if (lose1
&& lose2
)
22520 /* We've failed to deduce something in either direction.
22521 These must be unordered. */
22526 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
22527 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
22528 /* We have already processed all of the arguments in our
22529 handing of the pack expansion type. */
22532 args1
= TREE_CHAIN (args1
);
22533 args2
= TREE_CHAIN (args2
);
22536 /* "In most cases, all template parameters must have values in order for
22537 deduction to succeed, but for partial ordering purposes a template
22538 parameter may remain without a value provided it is not used in the
22539 types being used for partial ordering."
22541 Thus, if we are missing any of the targs1 we need to substitute into
22542 origs1, then pat2 is not as specialized as pat1. This can happen when
22543 there is a nondeduced context. */
22544 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
22546 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
22549 processing_template_decl
--;
22551 /* If both deductions succeed, the partial ordering selects the more
22552 constrained template. */
22553 if (!lose1
&& !lose2
)
22555 tree c1
= get_constraints (DECL_TEMPLATE_RESULT (pat1
));
22556 tree c2
= get_constraints (DECL_TEMPLATE_RESULT (pat2
));
22557 lose1
= !subsumes_constraints (c1
, c2
);
22558 lose2
= !subsumes_constraints (c2
, c1
);
22561 /* All things being equal, if the next argument is a pack expansion
22562 for one function but not for the other, prefer the
22563 non-variadic function. FIXME this is bogus; see c++/41958. */
22565 && args1
&& TREE_VALUE (args1
)
22566 && args2
&& TREE_VALUE (args2
))
22568 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
22569 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
22572 if (lose1
== lose2
)
22580 /* Determine which of two partial specializations of TMPL is more
22583 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
22584 to the first partial specialization. The TREE_PURPOSE is the
22585 innermost set of template parameters for the partial
22586 specialization. PAT2 is similar, but for the second template.
22588 Return 1 if the first partial specialization is more specialized;
22589 -1 if the second is more specialized; 0 if neither is more
22592 See [temp.class.order] for information about determining which of
22593 two templates is more specialized. */
22596 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
22600 bool any_deductions
= false;
22602 tree tmpl1
= TREE_VALUE (pat1
);
22603 tree tmpl2
= TREE_VALUE (pat2
);
22604 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
22605 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
22607 /* Just like what happens for functions, if we are ordering between
22608 different template specializations, we may encounter dependent
22609 types in the arguments, and we need our dependency check functions
22610 to behave correctly. */
22611 ++processing_template_decl
;
22612 targs
= get_partial_spec_bindings (tmpl
, tmpl1
, specargs2
);
22616 any_deductions
= true;
22619 targs
= get_partial_spec_bindings (tmpl
, tmpl2
, specargs1
);
22623 any_deductions
= true;
22625 --processing_template_decl
;
22627 /* If both deductions succeed, the partial ordering selects the more
22628 constrained template. */
22629 if (!winner
&& any_deductions
)
22630 return more_constrained (tmpl1
, tmpl2
);
22632 /* In the case of a tie where at least one of the templates
22633 has a parameter pack at the end, the template with the most
22634 non-packed parameters wins. */
22637 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
22638 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
22640 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
22641 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
22642 int len1
= TREE_VEC_LENGTH (args1
);
22643 int len2
= TREE_VEC_LENGTH (args2
);
22645 /* We don't count the pack expansion at the end. */
22646 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
22648 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
22653 else if (len1
< len2
)
22660 /* Return the template arguments that will produce the function signature
22661 DECL from the function template FN, with the explicit template
22662 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
22663 also match. Return NULL_TREE if no satisfactory arguments could be
22667 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
22669 int ntparms
= DECL_NTPARMS (fn
);
22670 tree targs
= make_tree_vec (ntparms
);
22671 tree decl_type
= TREE_TYPE (decl
);
22672 tree decl_arg_types
;
22674 unsigned int nargs
, ix
;
22677 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
22679 /* Never do unification on the 'this' parameter. */
22680 decl_arg_types
= skip_artificial_parms_for (decl
,
22681 TYPE_ARG_TYPES (decl_type
));
22683 nargs
= list_length (decl_arg_types
);
22684 args
= XALLOCAVEC (tree
, nargs
);
22685 for (arg
= decl_arg_types
, ix
= 0;
22686 arg
!= NULL_TREE
&& arg
!= void_list_node
;
22687 arg
= TREE_CHAIN (arg
), ++ix
)
22688 args
[ix
] = TREE_VALUE (arg
);
22690 if (fn_type_unification (fn
, explicit_args
, targs
,
22692 (check_rettype
|| DECL_CONV_FN_P (fn
)
22693 ? TREE_TYPE (decl_type
) : NULL_TREE
),
22694 DEDUCE_EXACT
, LOOKUP_NORMAL
, NULL
,
22695 /*explain_p=*/false,
22697 == error_mark_node
)
22703 /* Return the innermost template arguments that, when applied to a partial
22704 specialization SPEC_TMPL of TMPL, yield the ARGS.
22706 For example, suppose we have:
22708 template <class T, class U> struct S {};
22709 template <class T> struct S<T*, int> {};
22711 Then, suppose we want to get `S<double*, int>'. SPEC_TMPL will be the
22712 partial specialization and the ARGS will be {double*, int}. The resulting
22713 vector will be {double}, indicating that `T' is bound to `double'. */
22716 get_partial_spec_bindings (tree tmpl
, tree spec_tmpl
, tree args
)
22718 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
22720 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (spec_tmpl
)));
22721 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
22723 tree innermost_deduced_args
;
22725 innermost_deduced_args
= make_tree_vec (ntparms
);
22726 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
22728 deduced_args
= copy_node (args
);
22729 SET_TMPL_ARGS_LEVEL (deduced_args
,
22730 TMPL_ARGS_DEPTH (deduced_args
),
22731 innermost_deduced_args
);
22734 deduced_args
= innermost_deduced_args
;
22736 bool tried_array_deduction
= (cxx_dialect
< cxx17
);
22738 if (unify (tparms
, deduced_args
,
22739 INNERMOST_TEMPLATE_ARGS (spec_args
),
22740 INNERMOST_TEMPLATE_ARGS (args
),
22741 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
22744 for (i
= 0; i
< ntparms
; ++i
)
22745 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
22747 if (!tried_array_deduction
)
22749 try_array_deduction (tparms
, innermost_deduced_args
,
22750 INNERMOST_TEMPLATE_ARGS (spec_args
));
22751 tried_array_deduction
= true;
22752 if (TREE_VEC_ELT (innermost_deduced_args
, i
))
22758 if (!push_tinst_level (spec_tmpl
, deduced_args
))
22760 excessive_deduction_depth
= true;
22764 /* Verify that nondeduced template arguments agree with the type
22765 obtained from argument deduction.
22769 struct A { typedef int X; };
22770 template <class T, class U> struct C {};
22771 template <class T> struct C<T, typename T::X> {};
22773 Then with the instantiation `C<A, int>', we can deduce that
22774 `T' is `A' but unify () does not check whether `typename T::X'
22776 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
22778 if (spec_args
!= error_mark_node
)
22779 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
22780 INNERMOST_TEMPLATE_ARGS (spec_args
),
22781 tmpl
, tf_none
, false, false);
22783 pop_tinst_level ();
22785 if (spec_args
== error_mark_node
22786 /* We only need to check the innermost arguments; the other
22787 arguments will always agree. */
22788 || !comp_template_args_porder (INNERMOST_TEMPLATE_ARGS (spec_args
),
22789 INNERMOST_TEMPLATE_ARGS (args
)))
22792 /* Now that we have bindings for all of the template arguments,
22793 ensure that the arguments deduced for the template template
22794 parameters have compatible template parameter lists. See the use
22795 of template_template_parm_bindings_ok_p in fn_type_unification
22796 for more information. */
22797 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
22800 return deduced_args
;
22803 // Compare two function templates T1 and T2 by deducing bindings
22804 // from one against the other. If both deductions succeed, compare
22805 // constraints to see which is more constrained.
22807 more_specialized_inst (tree t1
, tree t2
)
22812 if (get_bindings (t1
, DECL_TEMPLATE_RESULT (t2
), NULL_TREE
, true))
22818 if (get_bindings (t2
, DECL_TEMPLATE_RESULT (t1
), NULL_TREE
, true))
22824 // If both deductions succeed, then one may be more constrained.
22825 if (count
== 2 && fate
== 0)
22826 fate
= more_constrained (t1
, t2
);
22831 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
22832 Return the TREE_LIST node with the most specialized template, if
22833 any. If there is no most specialized template, the error_mark_node
22836 Note that this function does not look at, or modify, the
22837 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
22838 returned is one of the elements of INSTANTIATIONS, callers may
22839 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
22840 and retrieve it from the value returned. */
22843 most_specialized_instantiation (tree templates
)
22847 ++processing_template_decl
;
22850 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
22852 gcc_assert (TREE_VALUE (champ
) != TREE_VALUE (fn
));
22853 int fate
= more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
));
22858 /* Equally specialized, move to next function. If there
22859 is no next function, nothing's most specialized. */
22860 fn
= TREE_CHAIN (fn
);
22868 /* Now verify that champ is better than everything earlier in the
22869 instantiation list. */
22870 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
)) {
22871 if (more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
)) != 1)
22878 processing_template_decl
--;
22881 return error_mark_node
;
22886 /* If DECL is a specialization of some template, return the most
22887 general such template. Otherwise, returns NULL_TREE.
22889 For example, given:
22891 template <class T> struct S { template <class U> void f(U); };
22893 if TMPL is `template <class U> void S<int>::f(U)' this will return
22894 the full template. This function will not trace past partial
22895 specializations, however. For example, given in addition:
22897 template <class T> struct S<T*> { template <class U> void f(U); };
22899 if TMPL is `template <class U> void S<int*>::f(U)' this will return
22900 `template <class T> template <class U> S<T*>::f(U)'. */
22903 most_general_template (tree decl
)
22905 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
22907 if (tree tinfo
= get_template_info (decl
))
22908 decl
= TI_TEMPLATE (tinfo
);
22909 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
22910 template friend, or a FIELD_DECL for a capture pack. */
22911 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
22915 /* Look for more and more general templates. */
22916 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
22918 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
22919 (See cp-tree.h for details.) */
22920 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
22923 if (CLASS_TYPE_P (TREE_TYPE (decl
))
22924 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
22925 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
22928 /* Stop if we run into an explicitly specialized class template. */
22929 if (!DECL_NAMESPACE_SCOPE_P (decl
)
22930 && DECL_CONTEXT (decl
)
22931 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
22934 decl
= DECL_TI_TEMPLATE (decl
);
22940 /* Return the most specialized of the template partial specializations
22941 which can produce TARGET, a specialization of some class or variable
22942 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
22943 a TEMPLATE_DECL node corresponding to the partial specialization, while
22944 the TREE_PURPOSE is the set of template arguments that must be
22945 substituted into the template pattern in order to generate TARGET.
22947 If the choice of partial specialization is ambiguous, a diagnostic
22948 is issued, and the error_mark_node is returned. If there are no
22949 partial specializations matching TARGET, then NULL_TREE is
22950 returned, indicating that the primary template should be used. */
22953 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
22955 tree list
= NULL_TREE
;
22960 tree outer_args
= NULL_TREE
;
22963 if (TYPE_P (target
))
22965 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
22966 tmpl
= TI_TEMPLATE (tinfo
);
22967 args
= TI_ARGS (tinfo
);
22969 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
22971 tmpl
= TREE_OPERAND (target
, 0);
22972 args
= TREE_OPERAND (target
, 1);
22974 else if (VAR_P (target
))
22976 tree tinfo
= DECL_TEMPLATE_INFO (target
);
22977 tmpl
= TI_TEMPLATE (tinfo
);
22978 args
= TI_ARGS (tinfo
);
22981 gcc_unreachable ();
22983 tree main_tmpl
= most_general_template (tmpl
);
22985 /* For determining which partial specialization to use, only the
22986 innermost args are interesting. */
22987 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
22989 outer_args
= strip_innermost_template_args (args
, 1);
22990 args
= INNERMOST_TEMPLATE_ARGS (args
);
22993 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
22996 tree spec_tmpl
= TREE_VALUE (t
);
23000 /* Substitute in the template args from the enclosing class. */
23001 ++processing_template_decl
;
23002 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
23003 --processing_template_decl
;
23006 if (spec_tmpl
== error_mark_node
)
23007 return error_mark_node
;
23009 spec_args
= get_partial_spec_bindings (tmpl
, spec_tmpl
, args
);
23013 spec_args
= add_to_template_args (outer_args
, spec_args
);
23015 /* Keep the candidate only if the constraints are satisfied,
23016 or if we're not compiling with concepts. */
23018 || constraints_satisfied_p (spec_tmpl
, spec_args
))
23020 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
23021 TREE_TYPE (list
) = TREE_TYPE (t
);
23029 ambiguous_p
= false;
23032 t
= TREE_CHAIN (t
);
23033 for (; t
; t
= TREE_CHAIN (t
))
23035 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
23042 t
= TREE_CHAIN (t
);
23045 ambiguous_p
= true;
23054 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
23056 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
23059 ambiguous_p
= true;
23067 char *spaces
= NULL
;
23068 if (!(complain
& tf_error
))
23069 return error_mark_node
;
23070 if (TYPE_P (target
))
23071 error ("ambiguous template instantiation for %q#T", target
);
23073 error ("ambiguous template instantiation for %q#D", target
);
23074 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
23075 for (t
= list
; t
; t
= TREE_CHAIN (t
))
23077 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
23078 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
23079 "%s %#qS", spaces
? spaces
: str
, subst
);
23080 spaces
= spaces
? spaces
: get_spaces (str
);
23083 return error_mark_node
;
23089 /* Explicitly instantiate DECL. */
23092 do_decl_instantiation (tree decl
, tree storage
)
23094 tree result
= NULL_TREE
;
23097 if (!decl
|| decl
== error_mark_node
)
23098 /* An error occurred, for which grokdeclarator has already issued
23099 an appropriate message. */
23101 else if (! DECL_LANG_SPECIFIC (decl
))
23103 error ("explicit instantiation of non-template %q#D", decl
);
23107 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
23108 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
23110 if (VAR_P (decl
) && !var_templ
)
23112 /* There is an asymmetry here in the way VAR_DECLs and
23113 FUNCTION_DECLs are handled by grokdeclarator. In the case of
23114 the latter, the DECL we get back will be marked as a
23115 template instantiation, and the appropriate
23116 DECL_TEMPLATE_INFO will be set up. This does not happen for
23117 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
23118 should handle VAR_DECLs as it currently handles
23120 if (!DECL_CLASS_SCOPE_P (decl
))
23122 error ("%qD is not a static data member of a class template", decl
);
23125 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
23126 if (!result
|| !VAR_P (result
))
23128 error ("no matching template for %qD found", decl
);
23131 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
23133 error ("type %qT for explicit instantiation %qD does not match "
23134 "declared type %qT", TREE_TYPE (result
), decl
,
23139 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
23141 error ("explicit instantiation of %q#D", decl
);
23147 /* Check for various error cases. Note that if the explicit
23148 instantiation is valid the RESULT will currently be marked as an
23149 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
23150 until we get here. */
23152 if (DECL_TEMPLATE_SPECIALIZATION (result
))
23154 /* DR 259 [temp.spec].
23156 Both an explicit instantiation and a declaration of an explicit
23157 specialization shall not appear in a program unless the explicit
23158 instantiation follows a declaration of the explicit specialization.
23160 For a given set of template parameters, if an explicit
23161 instantiation of a template appears after a declaration of an
23162 explicit specialization for that template, the explicit
23163 instantiation has no effect. */
23166 else if (DECL_EXPLICIT_INSTANTIATION (result
))
23170 No program shall explicitly instantiate any template more
23173 We check DECL_NOT_REALLY_EXTERN so as not to complain when
23174 the first instantiation was `extern' and the second is not,
23175 and EXTERN_P for the opposite case. */
23176 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
23177 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
23178 /* If an "extern" explicit instantiation follows an ordinary
23179 explicit instantiation, the template is instantiated. */
23183 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
23185 error ("no matching template for %qD found", result
);
23188 else if (!DECL_TEMPLATE_INFO (result
))
23190 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
23194 if (storage
== NULL_TREE
)
23196 else if (storage
== ridpointers
[(int) RID_EXTERN
])
23198 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
23199 pedwarn (input_location
, OPT_Wpedantic
,
23200 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
23205 error ("storage class %qD applied to template instantiation", storage
);
23207 check_explicit_instantiation_namespace (result
);
23208 mark_decl_instantiated (result
, extern_p
);
23210 instantiate_decl (result
, /*defer_ok=*/true,
23211 /*expl_inst_class_mem_p=*/false);
23215 mark_class_instantiated (tree t
, int extern_p
)
23217 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
23218 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
23219 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
23220 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
23223 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
23224 rest_of_type_compilation (t
, 1);
23228 /* Called from do_type_instantiation through binding_table_foreach to
23229 do recursive instantiation for the type bound in ENTRY. */
23231 bt_instantiate_type_proc (binding_entry entry
, void *data
)
23233 tree storage
= *(tree
*) data
;
23235 if (MAYBE_CLASS_TYPE_P (entry
->type
)
23236 && CLASSTYPE_TEMPLATE_INFO (entry
->type
)
23237 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
23238 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
23241 /* Perform an explicit instantiation of template class T. STORAGE, if
23242 non-null, is the RID for extern, inline or static. COMPLAIN is
23243 nonzero if this is called from the parser, zero if called recursively,
23244 since the standard is unclear (as detailed below). */
23247 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
23252 int previous_instantiation_extern_p
= 0;
23254 if (TREE_CODE (t
) == TYPE_DECL
)
23257 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
23260 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
23262 error ("explicit instantiation of non-class template %qD", tmpl
);
23264 error ("explicit instantiation of non-template type %qT", t
);
23270 if (!COMPLETE_TYPE_P (t
))
23272 if (complain
& tf_error
)
23273 error ("explicit instantiation of %q#T before definition of template",
23278 if (storage
!= NULL_TREE
)
23280 if (!in_system_header_at (input_location
))
23282 if (storage
== ridpointers
[(int) RID_EXTERN
])
23284 if (cxx_dialect
== cxx98
)
23285 pedwarn (input_location
, OPT_Wpedantic
,
23286 "ISO C++ 1998 forbids the use of %<extern%> on "
23287 "explicit instantiations");
23290 pedwarn (input_location
, OPT_Wpedantic
,
23291 "ISO C++ forbids the use of %qE"
23292 " on explicit instantiations", storage
);
23295 if (storage
== ridpointers
[(int) RID_INLINE
])
23297 else if (storage
== ridpointers
[(int) RID_EXTERN
])
23299 else if (storage
== ridpointers
[(int) RID_STATIC
])
23303 error ("storage class %qD applied to template instantiation",
23309 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
23311 /* DR 259 [temp.spec].
23313 Both an explicit instantiation and a declaration of an explicit
23314 specialization shall not appear in a program unless the explicit
23315 instantiation follows a declaration of the explicit specialization.
23317 For a given set of template parameters, if an explicit
23318 instantiation of a template appears after a declaration of an
23319 explicit specialization for that template, the explicit
23320 instantiation has no effect. */
23323 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
23327 No program shall explicitly instantiate any template more
23330 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
23331 instantiation was `extern'. If EXTERN_P then the second is.
23332 These cases are OK. */
23333 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
23335 if (!previous_instantiation_extern_p
&& !extern_p
23336 && (complain
& tf_error
))
23337 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
23339 /* If we've already instantiated the template, just return now. */
23340 if (!CLASSTYPE_INTERFACE_ONLY (t
))
23344 check_explicit_instantiation_namespace (TYPE_NAME (t
));
23345 mark_class_instantiated (t
, extern_p
);
23350 /* In contrast to implicit instantiation, where only the
23351 declarations, and not the definitions, of members are
23352 instantiated, we have here:
23356 The explicit instantiation of a class template specialization
23357 implies the instantiation of all of its members not
23358 previously explicitly specialized in the translation unit
23359 containing the explicit instantiation.
23361 Of course, we can't instantiate member template classes, since we
23362 don't have any arguments for them. Note that the standard is
23363 unclear on whether the instantiation of the members are
23364 *explicit* instantiations or not. However, the most natural
23365 interpretation is that it should be an explicit
23367 for (tree fld
= TYPE_FIELDS (t
); fld
; fld
= DECL_CHAIN (fld
))
23369 || (TREE_CODE (fld
) == FUNCTION_DECL
23371 && user_provided_p (fld
)))
23372 && DECL_TEMPLATE_INSTANTIATION (fld
))
23374 mark_decl_instantiated (fld
, extern_p
);
23376 instantiate_decl (fld
, /*defer_ok=*/true,
23377 /*expl_inst_class_mem_p=*/true);
23380 if (CLASSTYPE_NESTED_UTDS (t
))
23381 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
23382 bt_instantiate_type_proc
, &storage
);
23385 /* Given a function DECL, which is a specialization of TMPL, modify
23386 DECL to be a re-instantiation of TMPL with the same template
23387 arguments. TMPL should be the template into which tsubst'ing
23388 should occur for DECL, not the most general template.
23390 One reason for doing this is a scenario like this:
23393 void f(const T&, int i);
23395 void g() { f(3, 7); }
23398 void f(const T& t, const int i) { }
23400 Note that when the template is first instantiated, with
23401 instantiate_template, the resulting DECL will have no name for the
23402 first parameter, and the wrong type for the second. So, when we go
23403 to instantiate the DECL, we regenerate it. */
23406 regenerate_decl_from_template (tree decl
, tree tmpl
, tree args
)
23408 /* The arguments used to instantiate DECL, from the most general
23412 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
23414 /* Make sure that we can see identifiers, and compute access
23416 push_access_scope (decl
);
23418 if (TREE_CODE (decl
) == FUNCTION_DECL
)
23426 args_depth
= TMPL_ARGS_DEPTH (args
);
23427 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
23428 if (args_depth
> parms_depth
)
23429 args
= get_innermost_template_args (args
, parms_depth
);
23431 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
23432 args
, tf_error
, NULL_TREE
,
23433 /*defer_ok*/false);
23434 if (specs
&& specs
!= error_mark_node
)
23435 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
23438 /* Merge parameter declarations. */
23439 decl_parm
= skip_artificial_parms_for (decl
,
23440 DECL_ARGUMENTS (decl
));
23442 = skip_artificial_parms_for (code_pattern
,
23443 DECL_ARGUMENTS (code_pattern
));
23444 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
23449 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
23450 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
23451 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
23453 parm_type
= type_decays_to (parm_type
);
23454 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
23455 TREE_TYPE (decl_parm
) = parm_type
;
23456 attributes
= DECL_ATTRIBUTES (pattern_parm
);
23457 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
23459 DECL_ATTRIBUTES (decl_parm
) = attributes
;
23460 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
23462 decl_parm
= DECL_CHAIN (decl_parm
);
23463 pattern_parm
= DECL_CHAIN (pattern_parm
);
23465 /* Merge any parameters that match with the function parameter
23467 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
23470 tree expanded_types
;
23471 /* Expand the TYPE_PACK_EXPANSION that provides the types for
23472 the parameters in this function parameter pack. */
23473 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
23474 args
, tf_error
, NULL_TREE
);
23475 len
= TREE_VEC_LENGTH (expanded_types
);
23476 for (i
= 0; i
< len
; i
++)
23481 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
23482 /* Rename the parameter to include the index. */
23483 DECL_NAME (decl_parm
) =
23484 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
23485 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
23486 parm_type
= type_decays_to (parm_type
);
23487 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
23488 TREE_TYPE (decl_parm
) = parm_type
;
23489 attributes
= DECL_ATTRIBUTES (pattern_parm
);
23490 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
23492 DECL_ATTRIBUTES (decl_parm
) = attributes
;
23493 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
23495 decl_parm
= DECL_CHAIN (decl_parm
);
23498 /* Merge additional specifiers from the CODE_PATTERN. */
23499 if (DECL_DECLARED_INLINE_P (code_pattern
)
23500 && !DECL_DECLARED_INLINE_P (decl
))
23501 DECL_DECLARED_INLINE_P (decl
) = 1;
23503 else if (VAR_P (decl
))
23505 start_lambda_scope (decl
);
23506 DECL_INITIAL (decl
) =
23507 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
23508 tf_error
, DECL_TI_TEMPLATE (decl
),
23509 /*integral_constant_expression_p=*/false);
23510 finish_lambda_scope ();
23511 if (VAR_HAD_UNKNOWN_BOUND (decl
))
23512 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
23513 tf_error
, DECL_TI_TEMPLATE (decl
));
23516 gcc_unreachable ();
23518 pop_access_scope (decl
);
23521 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
23522 substituted to get DECL. */
23525 template_for_substitution (tree decl
)
23527 tree tmpl
= DECL_TI_TEMPLATE (decl
);
23529 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
23530 for the instantiation. This is not always the most general
23531 template. Consider, for example:
23534 struct S { template <class U> void f();
23535 template <> void f<int>(); };
23537 and an instantiation of S<double>::f<int>. We want TD to be the
23538 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
23539 while (/* An instantiation cannot have a definition, so we need a
23540 more general template. */
23541 DECL_TEMPLATE_INSTANTIATION (tmpl
)
23542 /* We must also deal with friend templates. Given:
23544 template <class T> struct S {
23545 template <class U> friend void f() {};
23548 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
23549 so far as the language is concerned, but that's still
23550 where we get the pattern for the instantiation from. On
23551 other hand, if the definition comes outside the class, say:
23553 template <class T> struct S {
23554 template <class U> friend void f();
23556 template <class U> friend void f() {}
23558 we don't need to look any further. That's what the check for
23559 DECL_INITIAL is for. */
23560 || (TREE_CODE (decl
) == FUNCTION_DECL
23561 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
23562 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
23564 /* The present template, TD, should not be a definition. If it
23565 were a definition, we should be using it! Note that we
23566 cannot restructure the loop to just keep going until we find
23567 a template with a definition, since that might go too far if
23568 a specialization was declared, but not defined. */
23570 /* Fetch the more general template. */
23571 tmpl
= DECL_TI_TEMPLATE (tmpl
);
23577 /* Returns true if we need to instantiate this template instance even if we
23578 know we aren't going to emit it. */
23581 always_instantiate_p (tree decl
)
23583 /* We always instantiate inline functions so that we can inline them. An
23584 explicit instantiation declaration prohibits implicit instantiation of
23585 non-inline functions. With high levels of optimization, we would
23586 normally inline non-inline functions -- but we're not allowed to do
23587 that for "extern template" functions. Therefore, we check
23588 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
23589 return ((TREE_CODE (decl
) == FUNCTION_DECL
23590 && (DECL_DECLARED_INLINE_P (decl
)
23591 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
23592 /* And we need to instantiate static data members so that
23593 their initializers are available in integral constant
23596 && decl_maybe_constant_var_p (decl
)));
23599 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
23600 instantiate it now, modifying TREE_TYPE (fn). Returns false on
23601 error, true otherwise. */
23604 maybe_instantiate_noexcept (tree fn
, tsubst_flags_t complain
)
23606 tree fntype
, spec
, noex
, clone
;
23608 /* Don't instantiate a noexcept-specification from template context. */
23609 if (processing_template_decl
23610 && (!flag_noexcept_type
|| type_dependent_expression_p (fn
)))
23613 if (DECL_CLONED_FUNCTION_P (fn
))
23614 fn
= DECL_CLONED_FUNCTION (fn
);
23615 fntype
= TREE_TYPE (fn
);
23616 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
23618 if (!spec
|| !TREE_PURPOSE (spec
))
23621 noex
= TREE_PURPOSE (spec
);
23623 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
23625 static hash_set
<tree
>* fns
= new hash_set
<tree
>;
23626 bool added
= false;
23627 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
23628 spec
= get_defaulted_eh_spec (fn
, complain
);
23629 else if (!(added
= !fns
->add (fn
)))
23631 /* If hash_set::add returns true, the element was already there. */
23632 location_t loc
= cp_expr_loc_or_loc (DEFERRED_NOEXCEPT_PATTERN (noex
),
23633 DECL_SOURCE_LOCATION (fn
));
23635 "exception specification of %qD depends on itself",
23637 spec
= noexcept_false_spec
;
23639 else if (push_tinst_level (fn
))
23641 push_access_scope (fn
);
23642 push_deferring_access_checks (dk_no_deferred
);
23643 input_location
= DECL_SOURCE_LOCATION (fn
);
23644 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
23645 DEFERRED_NOEXCEPT_ARGS (noex
),
23646 tf_warning_or_error
, fn
,
23647 /*function_p=*/false,
23648 /*integral_constant_expression_p=*/true);
23649 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
23650 pop_deferring_access_checks ();
23651 pop_access_scope (fn
);
23652 pop_tinst_level ();
23653 if (spec
== error_mark_node
)
23654 spec
= noexcept_false_spec
;
23657 spec
= noexcept_false_spec
;
23662 if (spec
== error_mark_node
)
23665 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
23668 FOR_EACH_CLONE (clone
, fn
)
23670 if (TREE_TYPE (clone
) == fntype
)
23671 TREE_TYPE (clone
) = TREE_TYPE (fn
);
23673 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
23679 /* We're starting to process the function INST, an instantiation of PATTERN;
23680 add their parameters to local_specializations. */
23683 register_parameter_specializations (tree pattern
, tree inst
)
23685 tree tmpl_parm
= DECL_ARGUMENTS (pattern
);
23686 tree spec_parm
= DECL_ARGUMENTS (inst
);
23687 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (inst
))
23689 register_local_specialization (spec_parm
, tmpl_parm
);
23690 spec_parm
= skip_artificial_parms_for (inst
, spec_parm
);
23691 tmpl_parm
= skip_artificial_parms_for (pattern
, tmpl_parm
);
23693 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
23695 if (!DECL_PACK_P (tmpl_parm
))
23697 register_local_specialization (spec_parm
, tmpl_parm
);
23698 spec_parm
= DECL_CHAIN (spec_parm
);
23702 /* Register the (value) argument pack as a specialization of
23703 TMPL_PARM, then move on. */
23704 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
23705 register_local_specialization (argpack
, tmpl_parm
);
23708 gcc_assert (!spec_parm
);
23711 /* Produce the definition of D, a _DECL generated from a template. If
23712 DEFER_OK is true, then we don't have to actually do the
23713 instantiation now; we just have to do it sometime. Normally it is
23714 an error if this is an explicit instantiation but D is undefined.
23715 EXPL_INST_CLASS_MEM_P is true iff D is a member of an explicitly
23716 instantiated class template. */
23719 instantiate_decl (tree d
, bool defer_ok
, bool expl_inst_class_mem_p
)
23721 tree tmpl
= DECL_TI_TEMPLATE (d
);
23728 bool pattern_defined
;
23729 location_t saved_loc
= input_location
;
23730 int saved_unevaluated_operand
= cp_unevaluated_operand
;
23731 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
23735 /* This function should only be used to instantiate templates for
23736 functions and static member variables. */
23737 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
23739 /* A concept is never instantiated. */
23740 gcc_assert (!DECL_DECLARED_CONCEPT_P (d
));
23742 /* Variables are never deferred; if instantiation is required, they
23743 are instantiated right away. That allows for better code in the
23744 case that an expression refers to the value of the variable --
23745 if the variable has a constant value the referring expression can
23746 take advantage of that fact. */
23750 /* Don't instantiate cloned functions. Instead, instantiate the
23751 functions they cloned. */
23752 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
23753 d
= DECL_CLONED_FUNCTION (d
);
23755 if (DECL_TEMPLATE_INSTANTIATED (d
)
23756 || (TREE_CODE (d
) == FUNCTION_DECL
23757 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
23758 || DECL_TEMPLATE_SPECIALIZATION (d
))
23759 /* D has already been instantiated or explicitly specialized, so
23760 there's nothing for us to do here.
23762 It might seem reasonable to check whether or not D is an explicit
23763 instantiation, and, if so, stop here. But when an explicit
23764 instantiation is deferred until the end of the compilation,
23765 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
23766 the instantiation. */
23769 /* Check to see whether we know that this template will be
23770 instantiated in some other file, as with "extern template"
23772 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
23774 /* In general, we do not instantiate such templates. */
23775 if (external_p
&& !always_instantiate_p (d
))
23778 gen_tmpl
= most_general_template (tmpl
);
23779 gen_args
= DECL_TI_ARGS (d
);
23781 if (tmpl
!= gen_tmpl
)
23782 /* We should already have the extra args. */
23783 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
23784 == TMPL_ARGS_DEPTH (gen_args
));
23785 /* And what's in the hash table should match D. */
23786 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
23787 || spec
== NULL_TREE
);
23789 /* This needs to happen before any tsubsting. */
23790 if (! push_tinst_level (d
))
23793 timevar_push (TV_TEMPLATE_INST
);
23795 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
23796 for the instantiation. */
23797 td
= template_for_substitution (d
);
23802 /* Look up an explicit specialization, if any. */
23803 tree tid
= lookup_template_variable (gen_tmpl
, gen_args
);
23804 tree elt
= most_specialized_partial_spec (tid
, tf_warning_or_error
);
23805 if (elt
&& elt
!= error_mark_node
)
23807 td
= TREE_VALUE (elt
);
23808 args
= TREE_PURPOSE (elt
);
23812 code_pattern
= DECL_TEMPLATE_RESULT (td
);
23814 /* We should never be trying to instantiate a member of a class
23815 template or partial specialization. */
23816 gcc_assert (d
!= code_pattern
);
23818 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
23819 || DECL_TEMPLATE_SPECIALIZATION (td
))
23820 /* In the case of a friend template whose definition is provided
23821 outside the class, we may have too many arguments. Drop the
23822 ones we don't need. The same is true for specializations. */
23823 args
= get_innermost_template_args
23824 (args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
23826 if (TREE_CODE (d
) == FUNCTION_DECL
)
23828 deleted_p
= DECL_DELETED_FN (code_pattern
);
23829 pattern_defined
= ((DECL_SAVED_TREE (code_pattern
) != NULL_TREE
23830 && DECL_INITIAL (code_pattern
) != error_mark_node
)
23831 || DECL_DEFAULTED_FN (code_pattern
)
23837 if (DECL_CLASS_SCOPE_P (code_pattern
))
23838 pattern_defined
= (! DECL_IN_AGGR_P (code_pattern
)
23839 || DECL_INLINE_VAR_P (code_pattern
));
23841 pattern_defined
= ! DECL_EXTERNAL (code_pattern
);
23844 /* We may be in the middle of deferred access check. Disable it now. */
23845 push_deferring_access_checks (dk_no_deferred
);
23847 /* Unless an explicit instantiation directive has already determined
23848 the linkage of D, remember that a definition is available for
23850 if (pattern_defined
23851 && !DECL_INTERFACE_KNOWN (d
)
23852 && !DECL_NOT_REALLY_EXTERN (d
))
23853 mark_definable (d
);
23855 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
23856 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
23857 input_location
= DECL_SOURCE_LOCATION (d
);
23859 /* If D is a member of an explicitly instantiated class template,
23860 and no definition is available, treat it like an implicit
23862 if (!pattern_defined
&& expl_inst_class_mem_p
23863 && DECL_EXPLICIT_INSTANTIATION (d
))
23865 /* Leave linkage flags alone on instantiations with anonymous
23867 if (TREE_PUBLIC (d
))
23869 DECL_NOT_REALLY_EXTERN (d
) = 0;
23870 DECL_INTERFACE_KNOWN (d
) = 0;
23872 SET_DECL_IMPLICIT_INSTANTIATION (d
);
23875 /* Defer all other templates, unless we have been explicitly
23876 forbidden from doing so. */
23877 if (/* If there is no definition, we cannot instantiate the
23880 /* If it's OK to postpone instantiation, do so. */
23882 /* If this is a static data member that will be defined
23883 elsewhere, we don't want to instantiate the entire data
23884 member, but we do want to instantiate the initializer so that
23885 we can substitute that elsewhere. */
23886 || (external_p
&& VAR_P (d
))
23887 /* Handle here a deleted function too, avoid generating
23888 its body (c++/61080). */
23891 /* The definition of the static data member is now required so
23892 we must substitute the initializer. */
23894 && !DECL_INITIAL (d
)
23895 && DECL_INITIAL (code_pattern
))
23899 bool const_init
= false;
23900 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
23902 ns
= decl_namespace_context (d
);
23903 push_nested_namespace (ns
);
23905 push_nested_class (DECL_CONTEXT (d
));
23906 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
23908 tf_warning_or_error
, NULL_TREE
,
23909 /*integral_constant_expression_p=*/false);
23910 /* If instantiating the initializer involved instantiating this
23911 again, don't call cp_finish_decl twice. */
23912 if (!DECL_INITIAL (d
))
23914 /* Make sure the initializer is still constant, in case of
23915 circular dependency (template/instantiate6.C). */
23917 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
23918 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
23919 /*asmspec_tree=*/NULL_TREE
,
23920 LOOKUP_ONLYCONVERTING
);
23923 pop_nested_class ();
23924 pop_nested_namespace (ns
);
23927 /* We restore the source position here because it's used by
23928 add_pending_template. */
23929 input_location
= saved_loc
;
23931 if (at_eof
&& !pattern_defined
23932 && DECL_EXPLICIT_INSTANTIATION (d
)
23933 && DECL_NOT_REALLY_EXTERN (d
))
23936 The definition of a non-exported function template, a
23937 non-exported member function template, or a non-exported
23938 member function or static data member of a class template
23939 shall be present in every translation unit in which it is
23940 explicitly instantiated. */
23941 permerror (input_location
, "explicit instantiation of %qD "
23942 "but no definition available", d
);
23944 /* If we're in unevaluated context, we just wanted to get the
23945 constant value; this isn't an odr use, so don't queue
23946 a full instantiation. */
23947 if (cp_unevaluated_operand
!= 0)
23949 /* ??? Historically, we have instantiated inline functions, even
23950 when marked as "extern template". */
23951 if (!(external_p
&& VAR_P (d
)))
23952 add_pending_template (d
);
23955 /* Tell the repository that D is available in this translation unit
23956 -- and see if it is supposed to be instantiated here. */
23957 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
23959 /* In a PCH file, despite the fact that the repository hasn't
23960 requested instantiation in the PCH it is still possible that
23961 an instantiation will be required in a file that includes the
23964 add_pending_template (d
);
23965 /* Instantiate inline functions so that the inliner can do its
23966 job, even though we'll not be emitting a copy of this
23968 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
23972 bool push_to_top
, nested
;
23974 fn_context
= decl_function_context (d
);
23975 if (LAMBDA_FUNCTION_P (d
))
23976 /* tsubst_lambda_expr resolved any references to enclosing functions. */
23977 fn_context
= NULL_TREE
;
23978 nested
= current_function_decl
!= NULL_TREE
;
23979 push_to_top
= !(nested
&& fn_context
== current_function_decl
);
23981 vec
<tree
> omp_privatization_save
;
23983 save_omp_privatization_clauses (omp_privatization_save
);
23986 push_to_top_level ();
23989 gcc_assert (!processing_template_decl
);
23990 push_function_context ();
23991 cp_unevaluated_operand
= 0;
23992 c_inhibit_evaluation_warnings
= 0;
23995 /* Mark D as instantiated so that recursive calls to
23996 instantiate_decl do not try to instantiate it again. */
23997 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
23999 /* Regenerate the declaration in case the template has been modified
24000 by a subsequent redeclaration. */
24001 regenerate_decl_from_template (d
, td
, args
);
24003 /* We already set the file and line above. Reset them now in case
24004 they changed as a result of calling regenerate_decl_from_template. */
24005 input_location
= DECL_SOURCE_LOCATION (d
);
24010 bool const_init
= false;
24012 /* Clear out DECL_RTL; whatever was there before may not be right
24013 since we've reset the type of the declaration. */
24014 SET_DECL_RTL (d
, NULL
);
24015 DECL_IN_AGGR_P (d
) = 0;
24017 /* The initializer is placed in DECL_INITIAL by
24018 regenerate_decl_from_template so we don't need to
24019 push/pop_access_scope again here. Pull it out so that
24020 cp_finish_decl can process it. */
24021 init
= DECL_INITIAL (d
);
24022 DECL_INITIAL (d
) = NULL_TREE
;
24023 DECL_INITIALIZED_P (d
) = 0;
24025 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
24026 initializer. That function will defer actual emission until
24027 we have a chance to determine linkage. */
24028 DECL_EXTERNAL (d
) = 0;
24030 /* Enter the scope of D so that access-checking works correctly. */
24031 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
24033 push_nested_class (DECL_CONTEXT (d
));
24035 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
24036 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
24039 pop_nested_class ();
24041 if (variable_template_p (gen_tmpl
))
24042 note_variable_template_instantiation (d
);
24044 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
24045 synthesize_method (d
);
24046 else if (TREE_CODE (d
) == FUNCTION_DECL
)
24048 /* Set up the list of local specializations. */
24049 local_specialization_stack
lss (push_to_top
? lss_blank
: lss_copy
);
24050 tree block
= NULL_TREE
;
24052 /* Set up context. */
24053 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
24054 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
24055 block
= push_stmt_list ();
24057 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
24059 /* Some typedefs referenced from within the template code need to be
24060 access checked at template instantiation time, i.e now. These
24061 types were added to the template at parsing time. Let's get those
24062 and perform the access checks then. */
24063 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (td
),
24066 /* Create substitution entries for the parameters. */
24067 register_parameter_specializations (code_pattern
, d
);
24069 /* Substitute into the body of the function. */
24070 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
24071 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
24072 tf_warning_or_error
, tmpl
);
24075 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
24076 tf_warning_or_error
, tmpl
,
24077 /*integral_constant_expression_p=*/false);
24079 /* Set the current input_location to the end of the function
24080 so that finish_function knows where we are. */
24082 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
24084 /* Remember if we saw an infinite loop in the template. */
24085 current_function_infinite_loop
24086 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
24089 /* Finish the function. */
24090 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
24091 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
24092 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
24095 d
= finish_function (/*inline_p=*/false);
24096 expand_or_defer_fn (d
);
24099 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
24100 cp_check_omp_declare_reduction (d
);
24103 /* We're not deferring instantiation any more. */
24104 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
24107 pop_from_top_level ();
24109 pop_function_context ();
24112 restore_omp_privatization_clauses (omp_privatization_save
);
24115 pop_deferring_access_checks ();
24116 timevar_pop (TV_TEMPLATE_INST
);
24117 pop_tinst_level ();
24118 input_location
= saved_loc
;
24119 cp_unevaluated_operand
= saved_unevaluated_operand
;
24120 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
24125 /* Run through the list of templates that we wish we could
24126 instantiate, and instantiate any we can. RETRIES is the
24127 number of times we retry pending template instantiation. */
24130 instantiate_pending_templates (int retries
)
24133 location_t saved_loc
= input_location
;
24135 /* Instantiating templates may trigger vtable generation. This in turn
24136 may require further template instantiations. We place a limit here
24137 to avoid infinite loop. */
24138 if (pending_templates
&& retries
>= max_tinst_depth
)
24140 tree decl
= pending_templates
->tinst
->maybe_get_node ();
24142 fatal_error (input_location
,
24143 "template instantiation depth exceeds maximum of %d"
24144 " instantiating %q+D, possibly from virtual table generation"
24145 " (use -ftemplate-depth= to increase the maximum)",
24146 max_tinst_depth
, decl
);
24147 if (TREE_CODE (decl
) == FUNCTION_DECL
)
24148 /* Pretend that we defined it. */
24149 DECL_INITIAL (decl
) = error_mark_node
;
24155 struct pending_template
**t
= &pending_templates
;
24156 struct pending_template
*last
= NULL
;
24160 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
24161 bool complete
= false;
24163 if (TYPE_P (instantiation
))
24165 if (!COMPLETE_TYPE_P (instantiation
))
24167 instantiate_class_template (instantiation
);
24168 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
24169 for (tree fld
= TYPE_FIELDS (instantiation
);
24170 fld
; fld
= TREE_CHAIN (fld
))
24172 || (TREE_CODE (fld
) == FUNCTION_DECL
24173 && !DECL_ARTIFICIAL (fld
)))
24174 && DECL_TEMPLATE_INSTANTIATION (fld
))
24175 instantiate_decl (fld
,
24176 /*defer_ok=*/false,
24177 /*expl_inst_class_mem_p=*/false);
24179 if (COMPLETE_TYPE_P (instantiation
))
24183 complete
= COMPLETE_TYPE_P (instantiation
);
24187 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
24188 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
24191 = instantiate_decl (instantiation
,
24192 /*defer_ok=*/false,
24193 /*expl_inst_class_mem_p=*/false);
24194 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
24198 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
24199 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
24204 /* If INSTANTIATION has been instantiated, then we don't
24205 need to consider it again in the future. */
24206 struct pending_template
*drop
= *t
;
24208 set_refcount_ptr (drop
->tinst
);
24209 pending_template_freelist ().free (drop
);
24217 set_refcount_ptr (current_tinst_level
);
24219 last_pending_template
= last
;
24221 while (reconsider
);
24223 input_location
= saved_loc
;
24226 /* Substitute ARGVEC into T, which is a list of initializers for
24227 either base class or a non-static data member. The TREE_PURPOSEs
24228 are DECLs, and the TREE_VALUEs are the initializer values. Used by
24229 instantiate_decl. */
24232 tsubst_initializer_list (tree t
, tree argvec
)
24234 tree inits
= NULL_TREE
;
24235 tree target_ctor
= error_mark_node
;
24237 for (; t
; t
= TREE_CHAIN (t
))
24241 tree expanded_bases
= NULL_TREE
;
24242 tree expanded_arguments
= NULL_TREE
;
24245 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
24250 /* Expand the base class expansion type into separate base
24252 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
24253 tf_warning_or_error
,
24255 if (expanded_bases
== error_mark_node
)
24258 /* We'll be building separate TREE_LISTs of arguments for
24260 len
= TREE_VEC_LENGTH (expanded_bases
);
24261 expanded_arguments
= make_tree_vec (len
);
24262 for (i
= 0; i
< len
; i
++)
24263 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
24265 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
24266 expand each argument in the TREE_VALUE of t. */
24267 expr
= make_node (EXPR_PACK_EXPANSION
);
24268 PACK_EXPANSION_LOCAL_P (expr
) = true;
24269 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
24270 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
24272 if (TREE_VALUE (t
) == void_type_node
)
24273 /* VOID_TYPE_NODE is used to indicate
24274 value-initialization. */
24276 for (i
= 0; i
< len
; i
++)
24277 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
24281 /* Substitute parameter packs into each argument in the
24283 in_base_initializer
= 1;
24284 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
24286 tree expanded_exprs
;
24288 /* Expand the argument. */
24289 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
24291 = tsubst_pack_expansion (expr
, argvec
,
24292 tf_warning_or_error
,
24294 if (expanded_exprs
== error_mark_node
)
24297 /* Prepend each of the expanded expressions to the
24298 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
24299 for (i
= 0; i
< len
; i
++)
24301 TREE_VEC_ELT (expanded_arguments
, i
) =
24302 tree_cons (NULL_TREE
,
24303 TREE_VEC_ELT (expanded_exprs
, i
),
24304 TREE_VEC_ELT (expanded_arguments
, i
));
24307 in_base_initializer
= 0;
24309 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
24310 since we built them backwards. */
24311 for (i
= 0; i
< len
; i
++)
24313 TREE_VEC_ELT (expanded_arguments
, i
) =
24314 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
24319 for (i
= 0; i
< len
; ++i
)
24321 if (expanded_bases
)
24323 decl
= TREE_VEC_ELT (expanded_bases
, i
);
24324 decl
= expand_member_init (decl
);
24325 init
= TREE_VEC_ELT (expanded_arguments
, i
);
24330 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
24331 tf_warning_or_error
, NULL_TREE
);
24333 decl
= expand_member_init (decl
);
24334 if (decl
&& !DECL_P (decl
))
24335 in_base_initializer
= 1;
24337 init
= TREE_VALUE (t
);
24339 if (init
!= void_type_node
)
24340 init
= tsubst_expr (init
, argvec
,
24341 tf_warning_or_error
, NULL_TREE
,
24342 /*integral_constant_expression_p=*/false);
24343 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
24344 /* If we had an initializer but it instantiated to nothing,
24345 value-initialize the object. This will only occur when
24346 the initializer was a pack expansion where the parameter
24347 packs used in that expansion were of length zero. */
24348 init
= void_type_node
;
24349 in_base_initializer
= 0;
24352 if (target_ctor
!= error_mark_node
24353 && init
!= error_mark_node
)
24355 error ("mem-initializer for %qD follows constructor delegation",
24359 /* Look for a target constructor. */
24360 if (init
!= error_mark_node
24361 && decl
&& CLASS_TYPE_P (decl
)
24362 && same_type_p (decl
, current_class_type
))
24364 maybe_warn_cpp0x (CPP0X_DELEGATING_CTORS
);
24367 error ("constructor delegation follows mem-initializer for %qD",
24368 TREE_PURPOSE (inits
));
24371 target_ctor
= init
;
24376 init
= build_tree_list (decl
, init
);
24377 TREE_CHAIN (init
) = inits
;
24385 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
24388 set_current_access_from_decl (tree decl
)
24390 if (TREE_PRIVATE (decl
))
24391 current_access_specifier
= access_private_node
;
24392 else if (TREE_PROTECTED (decl
))
24393 current_access_specifier
= access_protected_node
;
24395 current_access_specifier
= access_public_node
;
24398 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
24399 is the instantiation (which should have been created with
24400 start_enum) and ARGS are the template arguments to use. */
24403 tsubst_enum (tree tag
, tree newtag
, tree args
)
24407 if (SCOPED_ENUM_P (newtag
))
24408 begin_scope (sk_scoped_enum
, newtag
);
24410 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
24415 decl
= TREE_VALUE (e
);
24416 /* Note that in a template enum, the TREE_VALUE is the
24417 CONST_DECL, not the corresponding INTEGER_CST. */
24418 value
= tsubst_expr (DECL_INITIAL (decl
),
24419 args
, tf_warning_or_error
, NULL_TREE
,
24420 /*integral_constant_expression_p=*/true);
24422 /* Give this enumeration constant the correct access. */
24423 set_current_access_from_decl (decl
);
24425 /* Actually build the enumerator itself. Here we're assuming that
24426 enumerators can't have dependent attributes. */
24427 build_enumerator (DECL_NAME (decl
), value
, newtag
,
24428 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
24431 if (SCOPED_ENUM_P (newtag
))
24434 finish_enum_value_list (newtag
);
24435 finish_enum (newtag
);
24437 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
24438 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
24441 /* DECL is a FUNCTION_DECL that is a template specialization. Return
24442 its type -- but without substituting the innermost set of template
24443 arguments. So, innermost set of template parameters will appear in
24447 get_mostly_instantiated_function_type (tree decl
)
24449 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
24450 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
24453 /* Return truthvalue if we're processing a template different from
24454 the last one involved in diagnostics. */
24456 problematic_instantiation_changed (void)
24458 return current_tinst_level
!= last_error_tinst_level
;
24461 /* Remember current template involved in diagnostics. */
24463 record_last_problematic_instantiation (void)
24465 set_refcount_ptr (last_error_tinst_level
, current_tinst_level
);
24468 struct tinst_level
*
24469 current_instantiation (void)
24471 return current_tinst_level
;
24474 /* Return TRUE if current_function_decl is being instantiated, false
24478 instantiating_current_function_p (void)
24480 return (current_instantiation ()
24481 && (current_instantiation ()->maybe_get_node ()
24482 == current_function_decl
));
24485 /* [temp.param] Check that template non-type parm TYPE is of an allowable
24486 type. Return false for ok, true for disallowed. Issue error and
24487 inform messages under control of COMPLAIN. */
24490 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
24492 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
24494 else if (TYPE_PTR_P (type
))
24496 else if (TYPE_REF_P (type
)
24497 && !TYPE_REF_IS_RVALUE (type
))
24499 else if (TYPE_PTRMEM_P (type
))
24501 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
24503 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
24505 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
24507 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
24509 /* A bound template template parm could later be instantiated to have a valid
24510 nontype parm type via an alias template. */
24511 else if (cxx_dialect
>= cxx11
24512 && TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
24515 if (complain
& tf_error
)
24517 if (type
== error_mark_node
)
24518 inform (input_location
, "invalid template non-type parameter");
24520 error ("%q#T is not a valid type for a template non-type parameter",
24526 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
24527 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
24530 dependent_type_p_r (tree type
)
24536 A type is dependent if it is:
24538 -- a template parameter. Template template parameters are types
24539 for us (since TYPE_P holds true for them) so we handle
24541 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
24542 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
24544 /* -- a qualified-id with a nested-name-specifier which contains a
24545 class-name that names a dependent type or whose unqualified-id
24546 names a dependent type. */
24547 if (TREE_CODE (type
) == TYPENAME_TYPE
)
24550 /* An alias template specialization can be dependent even if the
24551 resulting type is not. */
24552 if (dependent_alias_template_spec_p (type
))
24555 /* -- a cv-qualified type where the cv-unqualified type is
24557 No code is necessary for this bullet; the code below handles
24558 cv-qualified types, and we don't want to strip aliases with
24559 TYPE_MAIN_VARIANT because of DR 1558. */
24560 /* -- a compound type constructed from any dependent type. */
24561 if (TYPE_PTRMEM_P (type
))
24562 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
24563 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
24565 else if (INDIRECT_TYPE_P (type
))
24566 return dependent_type_p (TREE_TYPE (type
));
24567 else if (TREE_CODE (type
) == FUNCTION_TYPE
24568 || TREE_CODE (type
) == METHOD_TYPE
)
24572 if (dependent_type_p (TREE_TYPE (type
)))
24574 for (arg_type
= TYPE_ARG_TYPES (type
);
24576 arg_type
= TREE_CHAIN (arg_type
))
24577 if (dependent_type_p (TREE_VALUE (arg_type
)))
24579 if (cxx_dialect
>= cxx17
)
24580 /* A value-dependent noexcept-specifier makes the type dependent. */
24581 if (tree spec
= TYPE_RAISES_EXCEPTIONS (type
))
24582 if (tree noex
= TREE_PURPOSE (spec
))
24583 /* Treat DEFERRED_NOEXCEPT as non-dependent, since it doesn't
24584 affect overload resolution and treating it as dependent breaks
24586 if (TREE_CODE (noex
) != DEFERRED_NOEXCEPT
24587 && value_dependent_expression_p (noex
))
24591 /* -- an array type constructed from any dependent type or whose
24592 size is specified by a constant expression that is
24595 We checked for type- and value-dependence of the bounds in
24596 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
24597 if (TREE_CODE (type
) == ARRAY_TYPE
)
24599 if (TYPE_DOMAIN (type
)
24600 && dependent_type_p (TYPE_DOMAIN (type
)))
24602 return dependent_type_p (TREE_TYPE (type
));
24605 /* -- a template-id in which either the template name is a template
24607 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
24609 /* ... or any of the template arguments is a dependent type or
24610 an expression that is type-dependent or value-dependent. */
24611 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
24612 && (any_dependent_template_arguments_p
24613 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
24616 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
24617 dependent; if the argument of the `typeof' expression is not
24618 type-dependent, then it should already been have resolved. */
24619 if (TREE_CODE (type
) == TYPEOF_TYPE
24620 || TREE_CODE (type
) == DECLTYPE_TYPE
24621 || TREE_CODE (type
) == UNDERLYING_TYPE
)
24624 /* A template argument pack is dependent if any of its packed
24626 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
24628 tree args
= ARGUMENT_PACK_ARGS (type
);
24629 int i
, len
= TREE_VEC_LENGTH (args
);
24630 for (i
= 0; i
< len
; ++i
)
24631 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
24635 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
24636 be template parameters. */
24637 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
24640 if (any_dependent_type_attributes_p (TYPE_ATTRIBUTES (type
)))
24643 /* The standard does not specifically mention types that are local
24644 to template functions or local classes, but they should be
24645 considered dependent too. For example:
24647 template <int I> void f() {
24652 The size of `E' cannot be known until the value of `I' has been
24653 determined. Therefore, `E' must be considered dependent. */
24654 scope
= TYPE_CONTEXT (type
);
24655 if (scope
&& TYPE_P (scope
))
24656 return dependent_type_p (scope
);
24657 /* Don't use type_dependent_expression_p here, as it can lead
24658 to infinite recursion trying to determine whether a lambda
24659 nested in a lambda is dependent (c++/47687). */
24660 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
24661 && DECL_LANG_SPECIFIC (scope
)
24662 && DECL_TEMPLATE_INFO (scope
)
24663 && (any_dependent_template_arguments_p
24664 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
24667 /* Other types are non-dependent. */
24671 /* Returns TRUE if TYPE is dependent, in the sense of
24672 [temp.dep.type]. Note that a NULL type is considered dependent. */
24675 dependent_type_p (tree type
)
24677 /* If there are no template parameters in scope, then there can't be
24678 any dependent types. */
24679 if (!processing_template_decl
)
24681 /* If we are not processing a template, then nobody should be
24682 providing us with a dependent type. */
24684 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
24688 /* If the type is NULL, we have not computed a type for the entity
24689 in question; in that case, the type is dependent. */
24693 /* Erroneous types can be considered non-dependent. */
24694 if (type
== error_mark_node
)
24697 /* Getting here with global_type_node means we improperly called this
24698 function on the TREE_TYPE of an IDENTIFIER_NODE. */
24699 gcc_checking_assert (type
!= global_type_node
);
24701 /* If we have not already computed the appropriate value for TYPE,
24703 if (!TYPE_DEPENDENT_P_VALID (type
))
24705 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
24706 TYPE_DEPENDENT_P_VALID (type
) = 1;
24709 return TYPE_DEPENDENT_P (type
);
24712 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
24713 lookup. In other words, a dependent type that is not the current
24717 dependent_scope_p (tree scope
)
24719 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
24720 && !currently_open_class (scope
));
24723 /* T is a SCOPE_REF. Return whether it represents a non-static member of
24724 an unknown base of 'this' (and is therefore instantiation-dependent). */
24727 unknown_base_ref_p (tree t
)
24729 if (!current_class_ptr
)
24732 tree mem
= TREE_OPERAND (t
, 1);
24733 if (shared_member_p (mem
))
24736 tree cur
= current_nonlambda_class_type ();
24737 if (!any_dependent_bases_p (cur
))
24740 tree ctx
= TREE_OPERAND (t
, 0);
24741 if (DERIVED_FROM_P (ctx
, cur
))
24747 /* T is a SCOPE_REF; return whether we need to consider it
24748 instantiation-dependent so that we can check access at instantiation
24749 time even though we know which member it resolves to. */
24752 instantiation_dependent_scope_ref_p (tree t
)
24754 if (DECL_P (TREE_OPERAND (t
, 1))
24755 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
24756 && !unknown_base_ref_p (t
)
24757 && accessible_in_template_p (TREE_OPERAND (t
, 0),
24758 TREE_OPERAND (t
, 1)))
24764 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
24765 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
24768 /* Note that this predicate is not appropriate for general expressions;
24769 only constant expressions (that satisfy potential_constant_expression)
24770 can be tested for value dependence. */
24773 value_dependent_expression_p (tree expression
)
24775 if (!processing_template_decl
|| expression
== NULL_TREE
)
24778 /* A type-dependent expression is also value-dependent. */
24779 if (type_dependent_expression_p (expression
))
24782 switch (TREE_CODE (expression
))
24785 /* A dependent member function of the current instantiation. */
24786 return dependent_type_p (BINFO_TYPE (BASELINK_BINFO (expression
)));
24788 case FUNCTION_DECL
:
24789 /* A dependent member function of the current instantiation. */
24790 if (DECL_CLASS_SCOPE_P (expression
)
24791 && dependent_type_p (DECL_CONTEXT (expression
)))
24795 case IDENTIFIER_NODE
:
24796 /* A name that has not been looked up -- must be dependent. */
24799 case TEMPLATE_PARM_INDEX
:
24800 /* A non-type template parm. */
24804 /* A non-type template parm. */
24805 if (DECL_TEMPLATE_PARM_P (expression
))
24807 return value_dependent_expression_p (DECL_INITIAL (expression
));
24810 /* A constant with literal type and is initialized
24811 with an expression that is value-dependent. */
24812 if (DECL_DEPENDENT_INIT_P (expression
)
24813 /* FIXME cp_finish_decl doesn't fold reference initializers. */
24814 || TYPE_REF_P (TREE_TYPE (expression
)))
24816 if (DECL_HAS_VALUE_EXPR_P (expression
))
24818 tree value_expr
= DECL_VALUE_EXPR (expression
);
24819 if (value_dependent_expression_p (value_expr
))
24824 case DYNAMIC_CAST_EXPR
:
24825 case STATIC_CAST_EXPR
:
24826 case CONST_CAST_EXPR
:
24827 case REINTERPRET_CAST_EXPR
:
24829 case IMPLICIT_CONV_EXPR
:
24830 /* These expressions are value-dependent if the type to which
24831 the cast occurs is dependent or the expression being casted
24832 is value-dependent. */
24834 tree type
= TREE_TYPE (expression
);
24836 if (dependent_type_p (type
))
24839 /* A functional cast has a list of operands. */
24840 expression
= TREE_OPERAND (expression
, 0);
24843 /* If there are no operands, it must be an expression such
24844 as "int()". This should not happen for aggregate types
24845 because it would form non-constant expressions. */
24846 gcc_assert (cxx_dialect
>= cxx11
24847 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
24852 if (TREE_CODE (expression
) == TREE_LIST
)
24853 return any_value_dependent_elements_p (expression
);
24855 return value_dependent_expression_p (expression
);
24859 if (SIZEOF_EXPR_TYPE_P (expression
))
24860 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
24864 /* A `sizeof' expression is value-dependent if the operand is
24865 type-dependent or is a pack expansion. */
24866 expression
= TREE_OPERAND (expression
, 0);
24867 if (PACK_EXPANSION_P (expression
))
24869 else if (TYPE_P (expression
))
24870 return dependent_type_p (expression
);
24871 return instantiation_dependent_uneval_expression_p (expression
);
24873 case AT_ENCODE_EXPR
:
24874 /* An 'encode' expression is value-dependent if the operand is
24876 expression
= TREE_OPERAND (expression
, 0);
24877 return dependent_type_p (expression
);
24879 case NOEXCEPT_EXPR
:
24880 expression
= TREE_OPERAND (expression
, 0);
24881 return instantiation_dependent_uneval_expression_p (expression
);
24884 /* All instantiation-dependent expressions should also be considered
24885 value-dependent. */
24886 return instantiation_dependent_scope_ref_p (expression
);
24888 case COMPONENT_REF
:
24889 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
24890 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
24892 case NONTYPE_ARGUMENT_PACK
:
24893 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
24894 is value-dependent. */
24896 tree values
= ARGUMENT_PACK_ARGS (expression
);
24897 int i
, len
= TREE_VEC_LENGTH (values
);
24899 for (i
= 0; i
< len
; ++i
)
24900 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
24908 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
24910 if (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
)))
24916 if (TREE_CODE (type2
) != TREE_LIST
)
24917 return dependent_type_p (type2
);
24919 for (; type2
; type2
= TREE_CHAIN (type2
))
24920 if (dependent_type_p (TREE_VALUE (type2
)))
24927 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
24928 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
24931 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
24932 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
24936 tree op
= TREE_OPERAND (expression
, 0);
24937 return (value_dependent_expression_p (op
)
24938 || has_value_dependent_address (op
));
24941 case REQUIRES_EXPR
:
24942 /* Treat all requires-expressions as value-dependent so
24943 we don't try to fold them. */
24947 return dependent_type_p (TREE_OPERAND (expression
, 0));
24951 if (value_dependent_expression_p (CALL_EXPR_FN (expression
)))
24953 tree fn
= get_callee_fndecl (expression
);
24955 nargs
= call_expr_nargs (expression
);
24956 for (i
= 0; i
< nargs
; ++i
)
24958 tree op
= CALL_EXPR_ARG (expression
, i
);
24959 /* In a call to a constexpr member function, look through the
24960 implicit ADDR_EXPR on the object argument so that it doesn't
24961 cause the call to be considered value-dependent. We also
24962 look through it in potential_constant_expression. */
24963 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
24964 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
24965 && TREE_CODE (op
) == ADDR_EXPR
)
24966 op
= TREE_OPERAND (op
, 0);
24967 if (value_dependent_expression_p (op
))
24973 case TEMPLATE_ID_EXPR
:
24974 return variable_concept_p (TREE_OPERAND (expression
, 0));
24980 if (dependent_type_p (TREE_TYPE (expression
)))
24982 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
24983 if (value_dependent_expression_p (val
))
24989 /* Treat a GNU statement expression as dependent to avoid crashing
24990 under instantiate_non_dependent_expr; it can't be constant. */
24994 /* A constant expression is value-dependent if any subexpression is
24995 value-dependent. */
24996 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
24998 case tcc_reference
:
25000 case tcc_comparison
:
25002 case tcc_expression
:
25005 int i
, len
= cp_tree_operand_length (expression
);
25007 for (i
= 0; i
< len
; i
++)
25009 tree t
= TREE_OPERAND (expression
, i
);
25011 /* In some cases, some of the operands may be missing.
25012 (For example, in the case of PREDECREMENT_EXPR, the
25013 amount to increment by may be missing.) That doesn't
25014 make the expression dependent. */
25015 if (t
&& value_dependent_expression_p (t
))
25026 /* The expression is not value-dependent. */
25030 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
25031 [temp.dep.expr]. Note that an expression with no type is
25032 considered dependent. Other parts of the compiler arrange for an
25033 expression with type-dependent subexpressions to have no type, so
25034 this function doesn't have to be fully recursive. */
25037 type_dependent_expression_p (tree expression
)
25039 if (!processing_template_decl
)
25042 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
25045 STRIP_ANY_LOCATION_WRAPPER (expression
);
25047 /* An unresolved name is always dependent. */
25048 if (identifier_p (expression
)
25049 || TREE_CODE (expression
) == USING_DECL
25050 || TREE_CODE (expression
) == WILDCARD_DECL
)
25053 /* A fold expression is type-dependent. */
25054 if (TREE_CODE (expression
) == UNARY_LEFT_FOLD_EXPR
25055 || TREE_CODE (expression
) == UNARY_RIGHT_FOLD_EXPR
25056 || TREE_CODE (expression
) == BINARY_LEFT_FOLD_EXPR
25057 || TREE_CODE (expression
) == BINARY_RIGHT_FOLD_EXPR
)
25060 /* Some expression forms are never type-dependent. */
25061 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
25062 || TREE_CODE (expression
) == SIZEOF_EXPR
25063 || TREE_CODE (expression
) == ALIGNOF_EXPR
25064 || TREE_CODE (expression
) == AT_ENCODE_EXPR
25065 || TREE_CODE (expression
) == NOEXCEPT_EXPR
25066 || TREE_CODE (expression
) == TRAIT_EXPR
25067 || TREE_CODE (expression
) == TYPEID_EXPR
25068 || TREE_CODE (expression
) == DELETE_EXPR
25069 || TREE_CODE (expression
) == VEC_DELETE_EXPR
25070 || TREE_CODE (expression
) == THROW_EXPR
25071 || TREE_CODE (expression
) == REQUIRES_EXPR
)
25074 /* The types of these expressions depends only on the type to which
25075 the cast occurs. */
25076 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
25077 || TREE_CODE (expression
) == STATIC_CAST_EXPR
25078 || TREE_CODE (expression
) == CONST_CAST_EXPR
25079 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
25080 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
25081 || TREE_CODE (expression
) == CAST_EXPR
)
25082 return dependent_type_p (TREE_TYPE (expression
));
25084 /* The types of these expressions depends only on the type created
25085 by the expression. */
25086 if (TREE_CODE (expression
) == NEW_EXPR
25087 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
25089 /* For NEW_EXPR tree nodes created inside a template, either
25090 the object type itself or a TREE_LIST may appear as the
25092 tree type
= TREE_OPERAND (expression
, 1);
25093 if (TREE_CODE (type
) == TREE_LIST
)
25094 /* This is an array type. We need to check array dimensions
25096 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
25097 || value_dependent_expression_p
25098 (TREE_OPERAND (TREE_VALUE (type
), 1));
25100 return dependent_type_p (type
);
25103 if (TREE_CODE (expression
) == SCOPE_REF
)
25105 tree scope
= TREE_OPERAND (expression
, 0);
25106 tree name
= TREE_OPERAND (expression
, 1);
25108 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
25109 contains an identifier associated by name lookup with one or more
25110 declarations declared with a dependent type, or...a
25111 nested-name-specifier or qualified-id that names a member of an
25112 unknown specialization. */
25113 return (type_dependent_expression_p (name
)
25114 || dependent_scope_p (scope
));
25117 if (TREE_CODE (expression
) == TEMPLATE_DECL
25118 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
25119 return uses_outer_template_parms (expression
);
25121 if (TREE_CODE (expression
) == STMT_EXPR
)
25122 expression
= stmt_expr_value_expr (expression
);
25124 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
25129 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
25131 if (type_dependent_expression_p (elt
))
25137 /* A static data member of the current instantiation with incomplete
25138 array type is type-dependent, as the definition and specializations
25139 can have different bounds. */
25140 if (VAR_P (expression
)
25141 && DECL_CLASS_SCOPE_P (expression
)
25142 && dependent_type_p (DECL_CONTEXT (expression
))
25143 && VAR_HAD_UNKNOWN_BOUND (expression
))
25146 /* An array of unknown bound depending on a variadic parameter, eg:
25148 template<typename... Args>
25149 void foo (Args... args)
25151 int arr[] = { args... };
25154 template<int... vals>
25157 int arr[] = { vals... };
25160 If the array has no length and has an initializer, it must be that
25161 we couldn't determine its length in cp_complete_array_type because
25162 it is dependent. */
25163 if (VAR_P (expression
)
25164 && TREE_TYPE (expression
) != NULL_TREE
25165 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
25166 && !TYPE_DOMAIN (TREE_TYPE (expression
))
25167 && DECL_INITIAL (expression
))
25170 /* A function or variable template-id is type-dependent if it has any
25171 dependent template arguments. */
25172 if (VAR_OR_FUNCTION_DECL_P (expression
)
25173 && DECL_LANG_SPECIFIC (expression
)
25174 && DECL_TEMPLATE_INFO (expression
))
25176 /* Consider the innermost template arguments, since those are the ones
25177 that come from the template-id; the template arguments for the
25178 enclosing class do not make it type-dependent unless they are used in
25179 the type of the decl. */
25180 if (PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (expression
))
25181 && (any_dependent_template_arguments_p
25182 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
25186 /* Otherwise, if the function decl isn't from a dependent scope, it can't be
25187 type-dependent. Checking this is important for functions with auto return
25188 type, which looks like a dependent type. */
25189 if (TREE_CODE (expression
) == FUNCTION_DECL
25190 && !(DECL_CLASS_SCOPE_P (expression
)
25191 && dependent_type_p (DECL_CONTEXT (expression
)))
25192 && !(DECL_LANG_SPECIFIC (expression
)
25193 && DECL_FRIEND_P (expression
)
25194 && (!DECL_FRIEND_CONTEXT (expression
)
25195 || dependent_type_p (DECL_FRIEND_CONTEXT (expression
))))
25196 && !DECL_LOCAL_FUNCTION_P (expression
))
25198 gcc_assert (!dependent_type_p (TREE_TYPE (expression
))
25199 || undeduced_auto_decl (expression
));
25203 /* Always dependent, on the number of arguments if nothing else. */
25204 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
25207 if (TREE_TYPE (expression
) == unknown_type_node
)
25209 if (TREE_CODE (expression
) == ADDR_EXPR
)
25210 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
25211 if (TREE_CODE (expression
) == COMPONENT_REF
25212 || TREE_CODE (expression
) == OFFSET_REF
)
25214 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
25216 expression
= TREE_OPERAND (expression
, 1);
25217 if (identifier_p (expression
))
25220 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
25221 if (TREE_CODE (expression
) == SCOPE_REF
)
25224 if (BASELINK_P (expression
))
25226 if (BASELINK_OPTYPE (expression
)
25227 && dependent_type_p (BASELINK_OPTYPE (expression
)))
25229 expression
= BASELINK_FUNCTIONS (expression
);
25232 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
25234 if (any_dependent_template_arguments_p
25235 (TREE_OPERAND (expression
, 1)))
25237 expression
= TREE_OPERAND (expression
, 0);
25238 if (identifier_p (expression
))
25242 gcc_assert (TREE_CODE (expression
) == OVERLOAD
25243 || TREE_CODE (expression
) == FUNCTION_DECL
);
25245 for (lkp_iterator
iter (expression
); iter
; ++iter
)
25246 if (type_dependent_expression_p (*iter
))
25252 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
25254 /* Dependent type attributes might not have made it from the decl to
25256 if (DECL_P (expression
)
25257 && any_dependent_type_attributes_p (DECL_ATTRIBUTES (expression
)))
25260 return (dependent_type_p (TREE_TYPE (expression
)));
25263 /* [temp.dep.expr]/5: A class member access expression (5.2.5) is
25264 type-dependent if the expression refers to a member of the current
25265 instantiation and the type of the referenced member is dependent, or the
25266 class member access expression refers to a member of an unknown
25269 This function returns true if the OBJECT in such a class member access
25270 expression is of an unknown specialization. */
25273 type_dependent_object_expression_p (tree object
)
25275 /* An IDENTIFIER_NODE can sometimes have a TREE_TYPE, but it's still
25277 if (TREE_CODE (object
) == IDENTIFIER_NODE
)
25279 tree scope
= TREE_TYPE (object
);
25280 return (!scope
|| dependent_scope_p (scope
));
25283 /* walk_tree callback function for instantiation_dependent_expression_p,
25284 below. Returns non-zero if a dependent subexpression is found. */
25287 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
25292 /* We don't have to worry about decltype currently because decltype
25293 of an instantiation-dependent expr is a dependent type. This
25294 might change depending on the resolution of DR 1172. */
25295 *walk_subtrees
= false;
25298 enum tree_code code
= TREE_CODE (*tp
);
25301 /* Don't treat an argument list as dependent just because it has no
25305 case NONTYPE_ARGUMENT_PACK
:
25308 case TEMPLATE_PARM_INDEX
:
25311 /* Handle expressions with type operands. */
25315 case AT_ENCODE_EXPR
:
25317 tree op
= TREE_OPERAND (*tp
, 0);
25318 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
25319 op
= TREE_TYPE (op
);
25322 if (dependent_type_p (op
))
25326 *walk_subtrees
= false;
25333 case COMPONENT_REF
:
25334 if (identifier_p (TREE_OPERAND (*tp
, 1)))
25335 /* In a template, finish_class_member_access_expr creates a
25336 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
25337 type-dependent, so that we can check access control at
25338 instantiation time (PR 42277). See also Core issue 1273. */
25343 if (instantiation_dependent_scope_ref_p (*tp
))
25348 /* Treat statement-expressions as dependent. */
25352 /* Treat requires-expressions as dependent. */
25353 case REQUIRES_EXPR
:
25357 /* Treat calls to function concepts as dependent. */
25358 if (function_concept_check_p (*tp
))
25362 case TEMPLATE_ID_EXPR
:
25363 /* And variable concepts. */
25364 if (variable_concept_p (TREE_OPERAND (*tp
, 0)))
25372 if (type_dependent_expression_p (*tp
))
25378 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
25379 sense defined by the ABI:
25381 "An expression is instantiation-dependent if it is type-dependent
25382 or value-dependent, or it has a subexpression that is type-dependent
25383 or value-dependent."
25385 Except don't actually check value-dependence for unevaluated expressions,
25386 because in sizeof(i) we don't care about the value of i. Checking
25387 type-dependence will in turn check value-dependence of array bounds/template
25388 arguments as needed. */
25391 instantiation_dependent_uneval_expression_p (tree expression
)
25395 if (!processing_template_decl
)
25398 if (expression
== error_mark_node
)
25401 result
= cp_walk_tree_without_duplicates (&expression
,
25402 instantiation_dependent_r
, NULL
);
25403 return result
!= NULL_TREE
;
25406 /* As above, but also check value-dependence of the expression as a whole. */
25409 instantiation_dependent_expression_p (tree expression
)
25411 return (instantiation_dependent_uneval_expression_p (expression
)
25412 || value_dependent_expression_p (expression
));
25415 /* Like type_dependent_expression_p, but it also works while not processing
25416 a template definition, i.e. during substitution or mangling. */
25419 type_dependent_expression_p_push (tree expr
)
25422 ++processing_template_decl
;
25423 b
= type_dependent_expression_p (expr
);
25424 --processing_template_decl
;
25428 /* Returns TRUE if ARGS contains a type-dependent expression. */
25431 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
25436 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
25438 if (type_dependent_expression_p (arg
))
25444 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
25445 expressions) contains any type-dependent expressions. */
25448 any_type_dependent_elements_p (const_tree list
)
25450 for (; list
; list
= TREE_CHAIN (list
))
25451 if (type_dependent_expression_p (TREE_VALUE (list
)))
25457 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
25458 expressions) contains any value-dependent expressions. */
25461 any_value_dependent_elements_p (const_tree list
)
25463 for (; list
; list
= TREE_CHAIN (list
))
25464 if (value_dependent_expression_p (TREE_VALUE (list
)))
25470 /* Returns TRUE if the ARG (a template argument) is dependent. */
25473 dependent_template_arg_p (tree arg
)
25475 if (!processing_template_decl
)
25478 /* Assume a template argument that was wrongly written by the user
25479 is dependent. This is consistent with what
25480 any_dependent_template_arguments_p [that calls this function]
25482 if (!arg
|| arg
== error_mark_node
)
25485 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
25486 arg
= argument_pack_select_arg (arg
);
25488 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
25490 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
25492 if (DECL_TEMPLATE_PARM_P (arg
))
25494 /* A member template of a dependent class is not necessarily
25495 type-dependent, but it is a dependent template argument because it
25496 will be a member of an unknown specialization to that template. */
25497 tree scope
= CP_DECL_CONTEXT (arg
);
25498 return TYPE_P (scope
) && dependent_type_p (scope
);
25500 else if (ARGUMENT_PACK_P (arg
))
25502 tree args
= ARGUMENT_PACK_ARGS (arg
);
25503 int i
, len
= TREE_VEC_LENGTH (args
);
25504 for (i
= 0; i
< len
; ++i
)
25506 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
25512 else if (TYPE_P (arg
))
25513 return dependent_type_p (arg
);
25515 return (type_dependent_expression_p (arg
)
25516 || value_dependent_expression_p (arg
));
25519 /* Returns true if ARGS (a collection of template arguments) contains
25520 any types that require structural equality testing. */
25523 any_template_arguments_need_structural_equality_p (tree args
)
25530 if (args
== error_mark_node
)
25533 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
25535 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
25536 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
25538 tree arg
= TREE_VEC_ELT (level
, j
);
25539 tree packed_args
= NULL_TREE
;
25542 if (ARGUMENT_PACK_P (arg
))
25544 /* Look inside the argument pack. */
25545 packed_args
= ARGUMENT_PACK_ARGS (arg
);
25546 len
= TREE_VEC_LENGTH (packed_args
);
25549 for (k
= 0; k
< len
; ++k
)
25552 arg
= TREE_VEC_ELT (packed_args
, k
);
25554 if (error_operand_p (arg
))
25556 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
25558 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
25560 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
25561 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
25570 /* Returns true if ARGS (a collection of template arguments) contains
25571 any dependent arguments. */
25574 any_dependent_template_arguments_p (const_tree args
)
25581 if (args
== error_mark_node
)
25584 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
25586 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
25587 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
25588 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
25595 /* Returns true if ARGS contains any errors. */
25598 any_erroneous_template_args_p (const_tree args
)
25603 if (args
== error_mark_node
)
25606 if (args
&& TREE_CODE (args
) != TREE_VEC
)
25608 if (tree ti
= get_template_info (args
))
25609 args
= TI_ARGS (ti
);
25617 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
25619 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
25620 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
25621 if (error_operand_p (TREE_VEC_ELT (level
, j
)))
25628 /* Returns TRUE if the template TMPL is type-dependent. */
25631 dependent_template_p (tree tmpl
)
25633 if (TREE_CODE (tmpl
) == OVERLOAD
)
25635 for (lkp_iterator
iter (tmpl
); iter
; ++iter
)
25636 if (dependent_template_p (*iter
))
25641 /* Template template parameters are dependent. */
25642 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
25643 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
25645 /* So are names that have not been looked up. */
25646 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
25651 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
25654 dependent_template_id_p (tree tmpl
, tree args
)
25656 return (dependent_template_p (tmpl
)
25657 || any_dependent_template_arguments_p (args
));
25660 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
25664 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
25668 if (!processing_template_decl
)
25671 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
25673 tree decl
= TREE_VEC_ELT (declv
, i
);
25674 tree init
= TREE_VEC_ELT (initv
, i
);
25675 tree cond
= TREE_VEC_ELT (condv
, i
);
25676 tree incr
= TREE_VEC_ELT (incrv
, i
);
25678 if (type_dependent_expression_p (decl
)
25679 || TREE_CODE (decl
) == SCOPE_REF
)
25682 if (init
&& type_dependent_expression_p (init
))
25685 if (type_dependent_expression_p (cond
))
25688 if (COMPARISON_CLASS_P (cond
)
25689 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
25690 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
25693 if (TREE_CODE (incr
) == MODOP_EXPR
)
25695 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
25696 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
25699 else if (type_dependent_expression_p (incr
))
25701 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
25703 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
25705 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
25707 tree t
= TREE_OPERAND (incr
, 1);
25708 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
25709 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
25718 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
25719 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
25720 no such TYPE can be found. Note that this function peers inside
25721 uninstantiated templates and therefore should be used only in
25722 extremely limited situations. ONLY_CURRENT_P restricts this
25723 peering to the currently open classes hierarchy (which is required
25724 when comparing types). */
25727 resolve_typename_type (tree type
, bool only_current_p
)
25736 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
25738 scope
= TYPE_CONTEXT (type
);
25739 /* We shouldn't have built a TYPENAME_TYPE with a non-dependent scope. */
25740 gcc_checking_assert (uses_template_parms (scope
));
25742 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
25743 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
25744 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
25745 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
25746 identifier of the TYPENAME_TYPE anymore.
25747 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
25748 TYPENAME_TYPE instead, we avoid messing up with a possible
25749 typedef variant case. */
25750 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
25752 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
25753 it first before we can figure out what NAME refers to. */
25754 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
25756 if (TYPENAME_IS_RESOLVING_P (scope
))
25757 /* Given a class template A with a dependent base with nested type C,
25758 typedef typename A::C::C C will land us here, as trying to resolve
25759 the initial A::C leads to the local C typedef, which leads back to
25760 A::C::C. So we break the recursion now. */
25763 scope
= resolve_typename_type (scope
, only_current_p
);
25765 /* If we don't know what SCOPE refers to, then we cannot resolve the
25767 if (!CLASS_TYPE_P (scope
))
25769 /* If this is a typedef, we don't want to look inside (c++/11987). */
25770 if (typedef_variant_p (type
))
25772 /* If SCOPE isn't the template itself, it will not have a valid
25773 TYPE_FIELDS list. */
25774 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
25775 /* scope is either the template itself or a compatible instantiation
25776 like X<T>, so look up the name in the original template. */
25777 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
25778 /* If scope has no fields, it can't be a current instantiation. Check this
25779 before currently_open_class to avoid infinite recursion (71515). */
25780 if (!TYPE_FIELDS (scope
))
25782 /* If the SCOPE is not the current instantiation, there's no reason
25783 to look inside it. */
25784 if (only_current_p
&& !currently_open_class (scope
))
25786 /* Enter the SCOPE so that name lookup will be resolved as if we
25787 were in the class definition. In particular, SCOPE will no
25788 longer be considered a dependent type. */
25789 pushed_scope
= push_scope (scope
);
25790 /* Look up the declaration. */
25791 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
25792 tf_warning_or_error
);
25794 result
= NULL_TREE
;
25796 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
25797 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
25798 tree fullname
= TYPENAME_TYPE_FULLNAME (type
);
25801 else if (identifier_p (fullname
)
25802 && TREE_CODE (decl
) == TYPE_DECL
)
25804 result
= TREE_TYPE (decl
);
25805 if (result
== error_mark_node
)
25806 result
= NULL_TREE
;
25808 else if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
25809 && DECL_CLASS_TEMPLATE_P (decl
))
25811 /* Obtain the template and the arguments. */
25812 tree tmpl
= TREE_OPERAND (fullname
, 0);
25813 if (TREE_CODE (tmpl
) == IDENTIFIER_NODE
)
25815 /* We get here with a plain identifier because a previous tentative
25816 parse of the nested-name-specifier as part of a ptr-operator saw
25817 ::template X<A>. The use of ::template is necessary in a
25818 ptr-operator, but wrong in a declarator-id.
25820 [temp.names]: In a qualified-id of a declarator-id, the keyword
25821 template shall not appear at the top level. */
25822 pedwarn (cp_expr_loc_or_loc (fullname
, input_location
), OPT_Wpedantic
,
25823 "keyword %<template%> not allowed in declarator-id");
25826 tree args
= TREE_OPERAND (fullname
, 1);
25827 /* Instantiate the template. */
25828 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
25829 /*entering_scope=*/true,
25830 tf_error
| tf_user
);
25831 if (result
== error_mark_node
)
25832 result
= NULL_TREE
;
25835 /* Leave the SCOPE. */
25837 pop_scope (pushed_scope
);
25839 /* If we failed to resolve it, return the original typename. */
25843 /* If lookup found a typename type, resolve that too. */
25844 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
25846 /* Ill-formed programs can cause infinite recursion here, so we
25847 must catch that. */
25848 TYPENAME_IS_RESOLVING_P (result
) = 1;
25849 result
= resolve_typename_type (result
, only_current_p
);
25850 TYPENAME_IS_RESOLVING_P (result
) = 0;
25853 /* Qualify the resulting type. */
25854 quals
= cp_type_quals (type
);
25856 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
25861 /* EXPR is an expression which is not type-dependent. Return a proxy
25862 for EXPR that can be used to compute the types of larger
25863 expressions containing EXPR. */
25866 build_non_dependent_expr (tree expr
)
25868 tree orig_expr
= expr
;
25871 /* When checking, try to get a constant value for all non-dependent
25872 expressions in order to expose bugs in *_dependent_expression_p
25873 and constexpr. This can affect code generation, see PR70704, so
25874 only do this for -fchecking=2. */
25875 if (flag_checking
> 1
25876 && cxx_dialect
>= cxx11
25877 /* Don't do this during nsdmi parsing as it can lead to
25878 unexpected recursive instantiations. */
25879 && !parsing_nsdmi ()
25880 /* Don't do this during concept expansion either and for
25881 the same reason. */
25882 && !expanding_concept ())
25883 fold_non_dependent_expr (expr
, tf_none
);
25885 STRIP_ANY_LOCATION_WRAPPER (expr
);
25887 /* Preserve OVERLOADs; the functions must be available to resolve
25890 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
25891 inner_expr
= stmt_expr_value_expr (inner_expr
);
25892 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
25893 inner_expr
= TREE_OPERAND (inner_expr
, 0);
25894 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
25895 inner_expr
= TREE_OPERAND (inner_expr
, 1);
25896 if (is_overloaded_fn (inner_expr
)
25897 || TREE_CODE (inner_expr
) == OFFSET_REF
)
25899 /* There is no need to return a proxy for a variable or enumerator. */
25900 if (VAR_P (expr
) || TREE_CODE (expr
) == CONST_DECL
)
25902 /* Preserve string constants; conversions from string constants to
25903 "char *" are allowed, even though normally a "const char *"
25904 cannot be used to initialize a "char *". */
25905 if (TREE_CODE (expr
) == STRING_CST
)
25907 /* Preserve void and arithmetic constants, as an optimization -- there is no
25908 reason to create a new node. */
25909 if (TREE_CODE (expr
) == VOID_CST
25910 || TREE_CODE (expr
) == INTEGER_CST
25911 || TREE_CODE (expr
) == REAL_CST
)
25913 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
25914 There is at least one place where we want to know that a
25915 particular expression is a throw-expression: when checking a ?:
25916 expression, there are special rules if the second or third
25917 argument is a throw-expression. */
25918 if (TREE_CODE (expr
) == THROW_EXPR
)
25921 /* Don't wrap an initializer list, we need to be able to look inside. */
25922 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
25925 /* Don't wrap a dummy object, we need to be able to test for it. */
25926 if (is_dummy_object (expr
))
25929 if (TREE_CODE (expr
) == COND_EXPR
)
25930 return build3 (COND_EXPR
,
25932 TREE_OPERAND (expr
, 0),
25933 (TREE_OPERAND (expr
, 1)
25934 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
25935 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
25936 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
25937 if (TREE_CODE (expr
) == COMPOUND_EXPR
25938 && !COMPOUND_EXPR_OVERLOADED (expr
))
25939 return build2 (COMPOUND_EXPR
,
25941 TREE_OPERAND (expr
, 0),
25942 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
25944 /* If the type is unknown, it can't really be non-dependent */
25945 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
25947 /* Otherwise, build a NON_DEPENDENT_EXPR. */
25948 return build1_loc (EXPR_LOCATION (orig_expr
), NON_DEPENDENT_EXPR
,
25949 TREE_TYPE (expr
), expr
);
25952 /* ARGS is a vector of expressions as arguments to a function call.
25953 Replace the arguments with equivalent non-dependent expressions.
25954 This modifies ARGS in place. */
25957 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
25962 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
25964 tree newarg
= build_non_dependent_expr (arg
);
25966 (*args
)[ix
] = newarg
;
25970 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
25971 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
25972 parms. If set_canonical is true, we set TYPE_CANONICAL on it. */
25975 make_auto_1 (tree name
, bool set_canonical
)
25977 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
25978 TYPE_NAME (au
) = build_decl (input_location
,
25979 TYPE_DECL
, name
, au
);
25980 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
25981 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
25982 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
25983 TYPE_NAME (au
), NULL_TREE
);
25985 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
25986 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
25987 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
25993 make_decltype_auto (void)
25995 return make_auto_1 (decltype_auto_identifier
, true);
26001 return make_auto_1 (auto_identifier
, true);
26004 /* Return a C++17 deduction placeholder for class template TMPL. */
26007 make_template_placeholder (tree tmpl
)
26009 tree t
= make_auto_1 (DECL_NAME (tmpl
), true);
26010 CLASS_PLACEHOLDER_TEMPLATE (t
) = tmpl
;
26014 /* True iff T is a C++17 class template deduction placeholder. */
26017 template_placeholder_p (tree t
)
26019 return is_auto (t
) && CLASS_PLACEHOLDER_TEMPLATE (t
);
26022 /* Make a "constrained auto" type-specifier. This is an
26023 auto type with constraints that must be associated after
26024 deduction. The constraint is formed from the given
26025 CONC and its optional sequence of arguments, which are
26026 non-null if written as partial-concept-id. */
26029 make_constrained_auto (tree con
, tree args
)
26031 tree type
= make_auto_1 (auto_identifier
, false);
26033 /* Build the constraint. */
26034 tree tmpl
= DECL_TI_TEMPLATE (con
);
26035 tree expr
= VAR_P (con
) ? tmpl
: ovl_make (tmpl
);
26036 expr
= build_concept_check (expr
, type
, args
);
26038 tree constr
= normalize_expression (expr
);
26039 PLACEHOLDER_TYPE_CONSTRAINTS (type
) = constr
;
26041 /* Our canonical type depends on the constraint. */
26042 TYPE_CANONICAL (type
) = canonical_type_parameter (type
);
26044 /* Attach the constraint to the type declaration. */
26045 tree decl
= TYPE_NAME (type
);
26049 /* Given type ARG, return std::initializer_list<ARG>. */
26054 tree std_init_list
= get_namespace_binding (std_node
, init_list_identifier
);
26056 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
26058 gcc_rich_location
richloc (input_location
);
26059 maybe_add_include_fixit (&richloc
, "<initializer_list>");
26060 error_at (&richloc
,
26061 "deducing from brace-enclosed initializer list"
26062 " requires %<#include <initializer_list>%>");
26064 return error_mark_node
;
26066 tree argvec
= make_tree_vec (1);
26067 TREE_VEC_ELT (argvec
, 0) = arg
;
26069 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
26070 NULL_TREE
, 0, tf_warning_or_error
);
26073 /* Replace auto in TYPE with std::initializer_list<auto>. */
26076 listify_autos (tree type
, tree auto_node
)
26078 tree init_auto
= listify (auto_node
);
26079 tree argvec
= make_tree_vec (1);
26080 TREE_VEC_ELT (argvec
, 0) = init_auto
;
26081 if (processing_template_decl
)
26082 argvec
= add_to_template_args (current_template_args (), argvec
);
26083 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
26086 /* Hash traits for hashing possibly constrained 'auto'
26087 TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
26089 struct auto_hash
: default_hash_traits
<tree
>
26091 static inline hashval_t
hash (tree
);
26092 static inline bool equal (tree
, tree
);
26095 /* Hash the 'auto' T. */
26098 auto_hash::hash (tree t
)
26100 if (tree c
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
26101 /* Matching constrained-type-specifiers denote the same template
26102 parameter, so hash the constraint. */
26103 return hash_placeholder_constraint (c
);
26105 /* But unconstrained autos are all separate, so just hash the pointer. */
26106 return iterative_hash_object (t
, 0);
26109 /* Compare two 'auto's. */
26112 auto_hash::equal (tree t1
, tree t2
)
26117 tree c1
= PLACEHOLDER_TYPE_CONSTRAINTS (t1
);
26118 tree c2
= PLACEHOLDER_TYPE_CONSTRAINTS (t2
);
26120 /* Two unconstrained autos are distinct. */
26124 return equivalent_placeholder_constraints (c1
, c2
);
26127 /* for_each_template_parm callback for extract_autos: if t is a (possibly
26128 constrained) auto, add it to the vector. */
26131 extract_autos_r (tree t
, void *data
)
26133 hash_table
<auto_hash
> &hash
= *(hash_table
<auto_hash
>*)data
;
26136 /* All the autos were built with index 0; fix that up now. */
26137 tree
*p
= hash
.find_slot (t
, INSERT
);
26140 /* If this is a repeated constrained-type-specifier, use the index we
26142 idx
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (*p
));
26145 /* Otherwise this is new, so use the current count. */
26147 idx
= hash
.elements () - 1;
26149 TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (t
)) = idx
;
26152 /* Always keep walking. */
26156 /* Return a TREE_VEC of the 'auto's used in type under the Concepts TS, which
26157 says they can appear anywhere in the type. */
26160 extract_autos (tree type
)
26162 hash_set
<tree
> visited
;
26163 hash_table
<auto_hash
> hash (2);
26165 for_each_template_parm (type
, extract_autos_r
, &hash
, &visited
, true);
26167 tree tree_vec
= make_tree_vec (hash
.elements());
26168 for (hash_table
<auto_hash
>::iterator iter
= hash
.begin();
26169 iter
!= hash
.end(); ++iter
)
26172 unsigned i
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (elt
));
26173 TREE_VEC_ELT (tree_vec
, i
)
26174 = build_tree_list (NULL_TREE
, TYPE_NAME (elt
));
26180 /* The stem for deduction guide names. */
26181 const char *const dguide_base
= "__dguide_";
26183 /* Return the name for a deduction guide for class template TMPL. */
26186 dguide_name (tree tmpl
)
26188 tree type
= (TYPE_P (tmpl
) ? tmpl
: TREE_TYPE (tmpl
));
26189 tree tname
= TYPE_IDENTIFIER (type
);
26190 char *buf
= (char *) alloca (1 + strlen (dguide_base
)
26191 + IDENTIFIER_LENGTH (tname
));
26192 memcpy (buf
, dguide_base
, strlen (dguide_base
));
26193 memcpy (buf
+ strlen (dguide_base
), IDENTIFIER_POINTER (tname
),
26194 IDENTIFIER_LENGTH (tname
) + 1);
26195 tree dname
= get_identifier (buf
);
26196 TREE_TYPE (dname
) = type
;
26200 /* True if NAME is the name of a deduction guide. */
26203 dguide_name_p (tree name
)
26205 return (TREE_CODE (name
) == IDENTIFIER_NODE
26206 && TREE_TYPE (name
)
26207 && !strncmp (IDENTIFIER_POINTER (name
), dguide_base
,
26208 strlen (dguide_base
)));
26211 /* True if FN is a deduction guide. */
26214 deduction_guide_p (const_tree fn
)
26217 if (tree name
= DECL_NAME (fn
))
26218 return dguide_name_p (name
);
26222 /* True if FN is the copy deduction guide, i.e. A(A)->A. */
26225 copy_guide_p (const_tree fn
)
26227 gcc_assert (deduction_guide_p (fn
));
26228 if (!DECL_ARTIFICIAL (fn
))
26230 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (DECL_TI_TEMPLATE (fn
));
26231 return (TREE_CHAIN (parms
) == void_list_node
26232 && same_type_p (TREE_VALUE (parms
), TREE_TYPE (DECL_NAME (fn
))));
26235 /* True if FN is a guide generated from a constructor template. */
26238 template_guide_p (const_tree fn
)
26240 gcc_assert (deduction_guide_p (fn
));
26241 if (!DECL_ARTIFICIAL (fn
))
26243 tree tmpl
= DECL_TI_TEMPLATE (fn
);
26244 if (tree org
= DECL_ABSTRACT_ORIGIN (tmpl
))
26245 return PRIMARY_TEMPLATE_P (org
);
26249 /* OLDDECL is a _DECL for a template parameter. Return a similar parameter at
26250 LEVEL:INDEX, using tsubst_args and complain for substitution into non-type
26251 template parameter types. Note that the handling of template template
26252 parameters relies on current_template_parms being set appropriately for the
26256 rewrite_template_parm (tree olddecl
, unsigned index
, unsigned level
,
26257 tree tsubst_args
, tsubst_flags_t complain
)
26259 if (olddecl
== error_mark_node
)
26260 return error_mark_node
;
26262 tree oldidx
= get_template_parm_index (olddecl
);
26265 if (TREE_CODE (olddecl
) == TYPE_DECL
26266 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
26268 tree oldtype
= TREE_TYPE (olddecl
);
26269 newtype
= cxx_make_type (TREE_CODE (oldtype
));
26270 TYPE_MAIN_VARIANT (newtype
) = newtype
;
26271 if (TREE_CODE (oldtype
) == TEMPLATE_TYPE_PARM
)
26272 TEMPLATE_TYPE_PARM_FOR_CLASS (newtype
)
26273 = TEMPLATE_TYPE_PARM_FOR_CLASS (oldtype
);
26277 newtype
= TREE_TYPE (olddecl
);
26278 if (type_uses_auto (newtype
))
26280 // Substitute once to fix references to other template parameters.
26281 newtype
= tsubst (newtype
, tsubst_args
,
26282 complain
|tf_partial
, NULL_TREE
);
26283 // Now substitute again to reduce the level of the auto.
26284 newtype
= tsubst (newtype
, current_template_args (),
26285 complain
, NULL_TREE
);
26288 newtype
= tsubst (newtype
, tsubst_args
,
26289 complain
, NULL_TREE
);
26293 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TREE_CODE (olddecl
),
26294 DECL_NAME (olddecl
), newtype
);
26295 SET_DECL_TEMPLATE_PARM_P (newdecl
);
26298 if (TREE_CODE (olddecl
) == TYPE_DECL
26299 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
26301 newidx
= TEMPLATE_TYPE_PARM_INDEX (newtype
)
26302 = build_template_parm_index (index
, level
, level
,
26304 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
26305 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
26306 TYPE_STUB_DECL (newtype
) = TYPE_NAME (newtype
) = newdecl
;
26307 TYPE_CANONICAL (newtype
) = canonical_type_parameter (newtype
);
26309 if (TREE_CODE (olddecl
) == TEMPLATE_DECL
)
26311 DECL_TEMPLATE_RESULT (newdecl
)
26312 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TYPE_DECL
,
26313 DECL_NAME (olddecl
), newtype
);
26314 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (newdecl
)) = true;
26315 // First create a copy (ttargs) of tsubst_args with an
26316 // additional level for the template template parameter's own
26317 // template parameters (ttparms).
26318 tree ttparms
= (INNERMOST_TEMPLATE_PARMS
26319 (DECL_TEMPLATE_PARMS (olddecl
)));
26320 const int depth
= TMPL_ARGS_DEPTH (tsubst_args
);
26321 tree ttargs
= make_tree_vec (depth
+ 1);
26322 for (int i
= 0; i
< depth
; ++i
)
26323 TREE_VEC_ELT (ttargs
, i
) = TREE_VEC_ELT (tsubst_args
, i
);
26324 TREE_VEC_ELT (ttargs
, depth
)
26325 = template_parms_level_to_args (ttparms
);
26326 // Substitute ttargs into ttparms to fix references to
26327 // other template parameters.
26328 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
26329 complain
|tf_partial
);
26330 // Now substitute again with args based on tparms, to reduce
26331 // the level of the ttparms.
26332 ttargs
= current_template_args ();
26333 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
26335 // Finally, tack the adjusted parms onto tparms.
26336 ttparms
= tree_cons (size_int (depth
), ttparms
,
26337 current_template_parms
);
26338 DECL_TEMPLATE_PARMS (newdecl
) = ttparms
;
26343 tree oldconst
= TEMPLATE_PARM_DECL (oldidx
);
26345 = build_decl (DECL_SOURCE_LOCATION (oldconst
),
26346 TREE_CODE (oldconst
),
26347 DECL_NAME (oldconst
), newtype
);
26348 TREE_CONSTANT (newconst
) = TREE_CONSTANT (newdecl
)
26349 = TREE_READONLY (newconst
) = TREE_READONLY (newdecl
) = true;
26350 SET_DECL_TEMPLATE_PARM_P (newconst
);
26351 newidx
= build_template_parm_index (index
, level
, level
,
26352 newconst
, newtype
);
26353 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
26354 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
26355 DECL_INITIAL (newdecl
) = DECL_INITIAL (newconst
) = newidx
;
26361 /* Returns a C++17 class deduction guide template based on the constructor
26362 CTOR. As a special case, CTOR can be a RECORD_TYPE for an implicit default
26363 guide, or REFERENCE_TYPE for an implicit copy/move guide. */
26366 build_deduction_guide (tree ctor
, tree outer_args
, tsubst_flags_t complain
)
26368 tree type
, tparms
, targs
, fparms
, fargs
, ci
;
26369 bool memtmpl
= false;
26372 tree fn_tmpl
= NULL_TREE
;
26377 bool copy_p
= TYPE_REF_P (type
);
26380 type
= TREE_TYPE (type
);
26381 fparms
= tree_cons (NULL_TREE
, type
, void_list_node
);
26384 fparms
= void_list_node
;
26386 tree ctmpl
= CLASSTYPE_TI_TEMPLATE (type
);
26387 tparms
= DECL_TEMPLATE_PARMS (ctmpl
);
26388 targs
= CLASSTYPE_TI_ARGS (type
);
26391 loc
= DECL_SOURCE_LOCATION (ctmpl
);
26392 explicit_p
= false;
26396 ++processing_template_decl
;
26400 = (TREE_CODE (ctor
) == TEMPLATE_DECL
? ctor
26401 : DECL_TI_TEMPLATE (ctor
));
26403 fn_tmpl
= tsubst (fn_tmpl
, outer_args
, complain
, ctor
);
26404 ctor
= DECL_TEMPLATE_RESULT (fn_tmpl
);
26406 type
= DECL_CONTEXT (ctor
);
26408 tparms
= DECL_TEMPLATE_PARMS (fn_tmpl
);
26409 /* If type is a member class template, DECL_TI_ARGS (ctor) will have
26410 fully specialized args for the enclosing class. Strip those off, as
26411 the deduction guide won't have those template parameters. */
26412 targs
= get_innermost_template_args (DECL_TI_ARGS (ctor
),
26413 TMPL_PARMS_DEPTH (tparms
));
26414 /* Discard the 'this' parameter. */
26415 fparms
= FUNCTION_ARG_CHAIN (ctor
);
26416 fargs
= TREE_CHAIN (DECL_ARGUMENTS (ctor
));
26417 ci
= get_constraints (ctor
);
26418 loc
= DECL_SOURCE_LOCATION (ctor
);
26419 explicit_p
= DECL_NONCONVERTING_P (ctor
);
26421 if (PRIMARY_TEMPLATE_P (fn_tmpl
))
26425 /* For a member template constructor, we need to flatten the two
26426 template parameter lists into one, and then adjust the function
26427 signature accordingly. This gets...complicated. */
26428 tree save_parms
= current_template_parms
;
26430 /* For a member template we should have two levels of parms/args, one
26431 for the class and one for the constructor. We stripped
26432 specialized args for further enclosing classes above. */
26433 const int depth
= 2;
26434 gcc_assert (TMPL_ARGS_DEPTH (targs
) == depth
);
26436 /* Template args for translating references to the two-level template
26437 parameters into references to the one-level template parameters we
26439 tree tsubst_args
= copy_node (targs
);
26440 TMPL_ARGS_LEVEL (tsubst_args
, depth
)
26441 = copy_node (TMPL_ARGS_LEVEL (tsubst_args
, depth
));
26443 /* Template parms for the constructor template. */
26444 tree ftparms
= TREE_VALUE (tparms
);
26445 unsigned flen
= TREE_VEC_LENGTH (ftparms
);
26446 /* Template parms for the class template. */
26447 tparms
= TREE_CHAIN (tparms
);
26448 tree ctparms
= TREE_VALUE (tparms
);
26449 unsigned clen
= TREE_VEC_LENGTH (ctparms
);
26450 /* Template parms for the deduction guide start as a copy of the
26451 template parms for the class. We set current_template_parms for
26452 lookup_template_class_1. */
26453 current_template_parms
= tparms
= copy_node (tparms
);
26454 tree new_vec
= TREE_VALUE (tparms
) = make_tree_vec (flen
+ clen
);
26455 for (unsigned i
= 0; i
< clen
; ++i
)
26456 TREE_VEC_ELT (new_vec
, i
) = TREE_VEC_ELT (ctparms
, i
);
26458 /* Now we need to rewrite the constructor parms to append them to the
26460 for (unsigned i
= 0; i
< flen
; ++i
)
26462 unsigned index
= i
+ clen
;
26463 unsigned level
= 1;
26464 tree oldelt
= TREE_VEC_ELT (ftparms
, i
);
26465 tree olddecl
= TREE_VALUE (oldelt
);
26466 tree newdecl
= rewrite_template_parm (olddecl
, index
, level
,
26467 tsubst_args
, complain
);
26468 if (newdecl
== error_mark_node
)
26470 tree newdef
= tsubst_template_arg (TREE_PURPOSE (oldelt
),
26471 tsubst_args
, complain
, ctor
);
26472 tree list
= build_tree_list (newdef
, newdecl
);
26473 TEMPLATE_PARM_CONSTRAINTS (list
)
26474 = tsubst_constraint_info (TEMPLATE_PARM_CONSTRAINTS (oldelt
),
26475 tsubst_args
, complain
, ctor
);
26476 TREE_VEC_ELT (new_vec
, index
) = list
;
26477 TMPL_ARG (tsubst_args
, depth
, i
) = template_parm_to_arg (list
);
26480 /* Now we have a final set of template parms to substitute into the
26481 function signature. */
26482 targs
= template_parms_to_args (tparms
);
26483 fparms
= tsubst_arg_types (fparms
, tsubst_args
, NULL_TREE
,
26485 fargs
= tsubst (fargs
, tsubst_args
, complain
, ctor
);
26487 ci
= tsubst_constraint_info (ci
, tsubst_args
, complain
, ctor
);
26489 current_template_parms
= save_parms
;
26492 --processing_template_decl
;
26494 return error_mark_node
;
26499 /* Copy the parms so we can set DECL_PRIMARY_TEMPLATE. */
26500 tparms
= copy_node (tparms
);
26501 INNERMOST_TEMPLATE_PARMS (tparms
)
26502 = copy_node (INNERMOST_TEMPLATE_PARMS (tparms
));
26505 tree fntype
= build_function_type (type
, fparms
);
26506 tree ded_fn
= build_lang_decl_loc (loc
,
26508 dguide_name (type
), fntype
);
26509 DECL_ARGUMENTS (ded_fn
) = fargs
;
26510 DECL_ARTIFICIAL (ded_fn
) = true;
26511 DECL_NONCONVERTING_P (ded_fn
) = explicit_p
;
26512 tree ded_tmpl
= build_template_decl (ded_fn
, tparms
, /*member*/false);
26513 DECL_ARTIFICIAL (ded_tmpl
) = true;
26514 DECL_TEMPLATE_RESULT (ded_tmpl
) = ded_fn
;
26515 TREE_TYPE (ded_tmpl
) = TREE_TYPE (ded_fn
);
26516 DECL_TEMPLATE_INFO (ded_fn
) = build_template_info (ded_tmpl
, targs
);
26517 DECL_PRIMARY_TEMPLATE (ded_tmpl
) = ded_tmpl
;
26519 DECL_ABSTRACT_ORIGIN (ded_tmpl
) = fn_tmpl
;
26521 set_constraints (ded_tmpl
, ci
);
26526 /* Deduce template arguments for the class template placeholder PTYPE for
26527 template TMPL based on the initializer INIT, and return the resulting
26531 do_class_deduction (tree ptype
, tree tmpl
, tree init
, int flags
,
26532 tsubst_flags_t complain
)
26534 if (!DECL_CLASS_TEMPLATE_P (tmpl
))
26536 /* We should have handled this in the caller. */
26537 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
))
26539 if (complain
& tf_error
)
26540 error ("non-class template %qT used without template arguments", tmpl
);
26541 return error_mark_node
;
26544 tree type
= TREE_TYPE (tmpl
);
26546 bool try_list_ctor
= false;
26548 vec
<tree
,va_gc
> *args
;
26549 if (init
== NULL_TREE
26550 || TREE_CODE (init
) == TREE_LIST
)
26551 args
= make_tree_vector_from_list (init
);
26552 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
26554 try_list_ctor
= TYPE_HAS_LIST_CTOR (type
);
26555 if (try_list_ctor
&& CONSTRUCTOR_NELTS (init
) == 1)
26557 /* As an exception, the first phase in 16.3.1.7 (considering the
26558 initializer list as a single argument) is omitted if the
26559 initializer list consists of a single expression of type cv U,
26560 where U is a specialization of C or a class derived from a
26561 specialization of C. */
26562 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
26563 tree etype
= TREE_TYPE (elt
);
26565 tree tparms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
26566 tree targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
26567 int err
= unify (tparms
, targs
, type
, etype
,
26568 UNIFY_ALLOW_DERIVED
, /*explain*/false);
26570 try_list_ctor
= false;
26573 if (try_list_ctor
|| is_std_init_list (type
))
26574 args
= make_tree_vector_single (init
);
26576 args
= make_tree_vector_from_ctor (init
);
26579 args
= make_tree_vector_single (init
);
26581 tree dname
= dguide_name (tmpl
);
26582 tree cands
= lookup_qualified_name (CP_DECL_CONTEXT (tmpl
), dname
,
26583 /*type*/false, /*complain*/false,
26585 bool elided
= false;
26586 if (cands
== error_mark_node
)
26589 /* Prune explicit deduction guides in copy-initialization context. */
26590 if (flags
& LOOKUP_ONLYCONVERTING
)
26592 for (lkp_iterator
iter (cands
); !elided
&& iter
; ++iter
)
26593 if (DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
26598 /* Found a nonconverting guide, prune the candidates. */
26599 tree pruned
= NULL_TREE
;
26600 for (lkp_iterator
iter (cands
); iter
; ++iter
)
26601 if (!DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
26602 pruned
= lookup_add (*iter
, pruned
);
26608 tree outer_args
= NULL_TREE
;
26609 if (DECL_CLASS_SCOPE_P (tmpl
)
26610 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (tmpl
)))
26612 outer_args
= CLASSTYPE_TI_ARGS (DECL_CONTEXT (tmpl
));
26613 type
= TREE_TYPE (most_general_template (tmpl
));
26616 bool saw_ctor
= false;
26617 // FIXME cache artificial deduction guides
26618 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (type
)); iter
; ++iter
)
26620 /* Skip inherited constructors. */
26621 if (iter
.using_p ())
26624 tree guide
= build_deduction_guide (*iter
, outer_args
, complain
);
26625 if (guide
== error_mark_node
)
26626 return error_mark_node
;
26627 if ((flags
& LOOKUP_ONLYCONVERTING
)
26628 && DECL_NONCONVERTING_P (STRIP_TEMPLATE (guide
)))
26631 cands
= lookup_add (guide
, cands
);
26636 tree call
= error_mark_node
;
26638 /* If this is list-initialization and the class has a list constructor, first
26639 try deducing from the list as a single argument, as [over.match.list]. */
26640 tree list_cands
= NULL_TREE
;
26641 if (try_list_ctor
&& cands
)
26642 for (lkp_iterator
iter (cands
); iter
; ++iter
)
26645 if (is_list_ctor (dg
))
26646 list_cands
= lookup_add (dg
, list_cands
);
26650 ++cp_unevaluated_operand
;
26651 call
= build_new_function_call (list_cands
, &args
, tf_decltype
);
26652 --cp_unevaluated_operand
;
26654 if (call
== error_mark_node
)
26656 /* That didn't work, now try treating the list as a sequence of
26658 release_tree_vector (args
);
26659 args
= make_tree_vector_from_ctor (init
);
26663 /* Maybe generate an implicit deduction guide. */
26664 if (call
== error_mark_node
&& args
->length () < 2)
26666 tree gtype
= NULL_TREE
;
26668 if (args
->length () == 1)
26669 /* Generate a copy guide. */
26670 gtype
= build_reference_type (type
);
26671 else if (!saw_ctor
)
26672 /* Generate a default guide. */
26677 tree guide
= build_deduction_guide (gtype
, outer_args
, complain
);
26678 if (guide
== error_mark_node
)
26679 return error_mark_node
;
26680 cands
= lookup_add (guide
, cands
);
26684 if (elided
&& !cands
)
26686 error ("cannot deduce template arguments for copy-initialization"
26687 " of %qT, as it has no non-explicit deduction guides or "
26688 "user-declared constructors", type
);
26689 return error_mark_node
;
26691 else if (!cands
&& call
== error_mark_node
)
26693 error ("cannot deduce template arguments of %qT, as it has no viable "
26694 "deduction guides", type
);
26695 return error_mark_node
;
26698 if (call
== error_mark_node
)
26700 ++cp_unevaluated_operand
;
26701 call
= build_new_function_call (cands
, &args
, tf_decltype
);
26702 --cp_unevaluated_operand
;
26705 if (call
== error_mark_node
&& (complain
& tf_warning_or_error
))
26707 error ("class template argument deduction failed:");
26709 ++cp_unevaluated_operand
;
26710 call
= build_new_function_call (cands
, &args
, complain
| tf_decltype
);
26711 --cp_unevaluated_operand
;
26714 inform (input_location
, "explicit deduction guides not considered "
26715 "for copy-initialization");
26718 release_tree_vector (args
);
26720 return cp_build_qualified_type (TREE_TYPE (call
), cp_type_quals (ptype
));
26723 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
26724 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
26725 The CONTEXT determines the context in which auto deduction is performed
26726 and is used to control error diagnostics. FLAGS are the LOOKUP_* flags.
26727 OUTER_TARGS are used during template argument deduction
26728 (context == adc_unify) to properly substitute the result, and is ignored
26731 For partial-concept-ids, extra args may be appended to the list of deduced
26732 template arguments prior to determining constraint satisfaction. */
26735 do_auto_deduction (tree type
, tree init
, tree auto_node
,
26736 tsubst_flags_t complain
, auto_deduction_context context
,
26737 tree outer_targs
, int flags
)
26741 if (init
== error_mark_node
)
26742 return error_mark_node
;
26744 if (init
&& type_dependent_expression_p (init
)
26745 && context
!= adc_unify
)
26746 /* Defining a subset of type-dependent expressions that we can deduce
26747 from ahead of time isn't worth the trouble. */
26750 /* Similarly, we can't deduce from another undeduced decl. */
26751 if (init
&& undeduced_auto_decl (init
))
26754 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
26755 /* C++17 class template argument deduction. */
26756 return do_class_deduction (type
, tmpl
, init
, flags
, complain
);
26758 if (init
== NULL_TREE
|| TREE_TYPE (init
) == NULL_TREE
)
26759 /* Nothing we can do with this, even in deduction context. */
26762 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
26763 with either a new invented type template parameter U or, if the
26764 initializer is a braced-init-list (8.5.4), with
26765 std::initializer_list<U>. */
26766 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
26768 if (!DIRECT_LIST_INIT_P (init
))
26769 type
= listify_autos (type
, auto_node
);
26770 else if (CONSTRUCTOR_NELTS (init
) == 1)
26771 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
26774 if (complain
& tf_warning_or_error
)
26776 if (permerror (input_location
, "direct-list-initialization of "
26777 "%<auto%> requires exactly one element"))
26778 inform (input_location
,
26779 "for deduction to %<std::initializer_list%>, use copy-"
26780 "list-initialization (i.e. add %<=%> before the %<{%>)");
26782 type
= listify_autos (type
, auto_node
);
26786 if (type
== error_mark_node
)
26787 return error_mark_node
;
26789 init
= resolve_nondeduced_context (init
, complain
);
26791 if (context
== adc_decomp_type
26792 && auto_node
== type
26793 && init
!= error_mark_node
26794 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
26795 /* [dcl.decomp]/1 - if decomposition declaration has no ref-qualifiers
26796 and initializer has array type, deduce cv-qualified array type. */
26797 return cp_build_qualified_type_real (TREE_TYPE (init
), TYPE_QUALS (type
),
26799 else if (AUTO_IS_DECLTYPE (auto_node
))
26801 bool id
= (DECL_P (init
)
26802 || ((TREE_CODE (init
) == COMPONENT_REF
26803 || TREE_CODE (init
) == SCOPE_REF
)
26804 && !REF_PARENTHESIZED_P (init
)));
26805 targs
= make_tree_vec (1);
26806 TREE_VEC_ELT (targs
, 0)
26807 = finish_decltype_type (init
, id
, tf_warning_or_error
);
26808 if (type
!= auto_node
)
26810 if (complain
& tf_error
)
26811 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
26812 return error_mark_node
;
26817 tree parms
= build_tree_list (NULL_TREE
, type
);
26821 tparms
= extract_autos (type
);
26824 tparms
= make_tree_vec (1);
26825 TREE_VEC_ELT (tparms
, 0)
26826 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
26829 targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
26830 int val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
26832 NULL
, /*explain_p=*/false);
26835 if (processing_template_decl
)
26836 /* Try again at instantiation time. */
26838 if (type
&& type
!= error_mark_node
26839 && (complain
& tf_error
))
26840 /* If type is error_mark_node a diagnostic must have been
26841 emitted by now. Also, having a mention to '<type error>'
26842 in the diagnostic is not really useful to the user. */
26844 if (cfun
&& auto_node
== current_function_auto_return_pattern
26845 && LAMBDA_FUNCTION_P (current_function_decl
))
26846 error ("unable to deduce lambda return type from %qE", init
);
26848 error ("unable to deduce %qT from %qE", type
, init
);
26849 type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
26851 NULL
, /*explain_p=*/true);
26853 return error_mark_node
;
26857 /* Check any placeholder constraints against the deduced type. */
26858 if (flag_concepts
&& !processing_template_decl
)
26859 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (auto_node
))
26861 /* Use the deduced type to check the associated constraints. If we
26862 have a partial-concept-id, rebuild the argument list so that
26863 we check using the extra arguments. */
26864 gcc_assert (TREE_CODE (constr
) == CHECK_CONSTR
);
26865 tree cargs
= CHECK_CONSTR_ARGS (constr
);
26866 if (TREE_VEC_LENGTH (cargs
) > 1)
26868 cargs
= copy_node (cargs
);
26869 TREE_VEC_ELT (cargs
, 0) = TREE_VEC_ELT (targs
, 0);
26873 if (!constraints_satisfied_p (constr
, cargs
))
26875 if (complain
& tf_warning_or_error
)
26879 case adc_unspecified
:
26881 error("placeholder constraints not satisfied");
26883 case adc_variable_type
:
26884 case adc_decomp_type
:
26885 error ("deduced initializer does not satisfy "
26886 "placeholder constraints");
26888 case adc_return_type
:
26889 error ("deduced return type does not satisfy "
26890 "placeholder constraints");
26892 case adc_requirement
:
26893 error ("deduced expression type does not satisfy "
26894 "placeholder constraints");
26897 diagnose_constraints (input_location
, constr
, targs
);
26899 return error_mark_node
;
26903 if (processing_template_decl
&& context
!= adc_unify
)
26904 outer_targs
= current_template_args ();
26905 targs
= add_to_template_args (outer_targs
, targs
);
26906 return tsubst (type
, targs
, complain
, NULL_TREE
);
26909 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
26913 splice_late_return_type (tree type
, tree late_return_type
)
26915 if (is_auto (type
))
26917 if (late_return_type
)
26918 return late_return_type
;
26920 tree idx
= get_template_parm_index (type
);
26921 if (TEMPLATE_PARM_LEVEL (idx
) <= processing_template_decl
)
26922 /* In an abbreviated function template we didn't know we were dealing
26923 with a function template when we saw the auto return type, so update
26924 it to have the correct level. */
26925 return make_auto_1 (TYPE_IDENTIFIER (type
), true);
26930 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
26931 'decltype(auto)' or a deduced class template. */
26934 is_auto (const_tree type
)
26936 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
26937 && (TYPE_IDENTIFIER (type
) == auto_identifier
26938 || TYPE_IDENTIFIER (type
) == decltype_auto_identifier
26939 || CLASS_PLACEHOLDER_TEMPLATE (type
)))
26945 /* for_each_template_parm callback for type_uses_auto. */
26948 is_auto_r (tree tp
, void */
*data*/
)
26950 return is_auto (tp
);
26953 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
26954 a use of `auto'. Returns NULL_TREE otherwise. */
26957 type_uses_auto (tree type
)
26959 if (type
== NULL_TREE
)
26961 else if (flag_concepts
)
26963 /* The Concepts TS allows multiple autos in one type-specifier; just
26964 return the first one we find, do_auto_deduction will collect all of
26966 if (uses_template_parms (type
))
26967 return for_each_template_parm (type
, is_auto_r
, /*data*/NULL
,
26968 /*visited*/NULL
, /*nondeduced*/false);
26973 return find_type_usage (type
, is_auto
);
26976 /* Report ill-formed occurrences of auto types in ARGUMENTS. If
26977 concepts are enabled, auto is acceptable in template arguments, but
26978 only when TEMPL identifies a template class. Return TRUE if any
26979 such errors were reported. */
26982 check_auto_in_tmpl_args (tree tmpl
, tree args
)
26984 /* If there were previous errors, nevermind. */
26985 if (!args
|| TREE_CODE (args
) != TREE_VEC
)
26988 /* If TMPL is an identifier, we're parsing and we can't tell yet
26989 whether TMPL is supposed to be a type, a function or a variable.
26990 We'll only be able to tell during template substitution, so we
26991 expect to be called again then. If concepts are enabled and we
26992 know we have a type, we're ok. */
26994 && (identifier_p (tmpl
)
26996 && (DECL_TYPE_TEMPLATE_P (tmpl
)
26997 || DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)))))
27000 /* Quickly search for any occurrences of auto; usually there won't
27001 be any, and then we'll avoid allocating the vector. */
27002 if (!type_uses_auto (args
))
27005 bool errors
= false;
27007 tree vec
= extract_autos (args
);
27008 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); i
++)
27010 tree xauto
= TREE_VALUE (TREE_VEC_ELT (vec
, i
));
27011 error_at (DECL_SOURCE_LOCATION (xauto
),
27012 "invalid use of %qT in template argument", xauto
);
27019 /* For a given template T, return the vector of typedefs referenced
27020 in T for which access check is needed at T instantiation time.
27021 T is either a FUNCTION_DECL or a RECORD_TYPE.
27022 Those typedefs were added to T by the function
27023 append_type_to_template_for_access_check. */
27025 vec
<qualified_typedef_usage_t
, va_gc
> *
27026 get_types_needing_access_check (tree t
)
27029 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
27031 if (!t
|| t
== error_mark_node
)
27034 if (!(ti
= get_template_info (t
)))
27037 if (CLASS_TYPE_P (t
)
27038 || TREE_CODE (t
) == FUNCTION_DECL
)
27040 if (!TI_TEMPLATE (ti
))
27043 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
27049 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
27050 tied to T. That list of typedefs will be access checked at
27051 T instantiation time.
27052 T is either a FUNCTION_DECL or a RECORD_TYPE.
27053 TYPE_DECL is a TYPE_DECL node representing a typedef.
27054 SCOPE is the scope through which TYPE_DECL is accessed.
27055 LOCATION is the location of the usage point of TYPE_DECL.
27057 This function is a subroutine of
27058 append_type_to_template_for_access_check. */
27061 append_type_to_template_for_access_check_1 (tree t
,
27064 location_t location
)
27066 qualified_typedef_usage_t typedef_usage
;
27069 if (!t
|| t
== error_mark_node
)
27072 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
27073 || CLASS_TYPE_P (t
))
27075 && TREE_CODE (type_decl
) == TYPE_DECL
27078 if (!(ti
= get_template_info (t
)))
27081 gcc_assert (TI_TEMPLATE (ti
));
27083 typedef_usage
.typedef_decl
= type_decl
;
27084 typedef_usage
.context
= scope
;
27085 typedef_usage
.locus
= location
;
27087 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
27090 /* Append TYPE_DECL to the template TEMPL.
27091 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
27092 At TEMPL instanciation time, TYPE_DECL will be checked to see
27093 if it can be accessed through SCOPE.
27094 LOCATION is the location of the usage point of TYPE_DECL.
27096 e.g. consider the following code snippet:
27103 template<class U> struct S
27105 C::myint mi; // <-- usage point of the typedef C::myint
27110 At S<char> instantiation time, we need to check the access of C::myint
27111 In other words, we need to check the access of the myint typedef through
27112 the C scope. For that purpose, this function will add the myint typedef
27113 and the scope C through which its being accessed to a list of typedefs
27114 tied to the template S. That list will be walked at template instantiation
27115 time and access check performed on each typedefs it contains.
27116 Note that this particular code snippet should yield an error because
27117 myint is private to C. */
27120 append_type_to_template_for_access_check (tree templ
,
27123 location_t location
)
27125 qualified_typedef_usage_t
*iter
;
27128 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
27130 /* Make sure we don't append the type to the template twice. */
27131 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
27132 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
27135 append_type_to_template_for_access_check_1 (templ
, type_decl
,
27139 /* Convert the generic type parameters in PARM that match the types given in the
27140 range [START_IDX, END_IDX) from the current_template_parms into generic type
27144 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
27146 tree current
= current_template_parms
;
27147 int depth
= TMPL_PARMS_DEPTH (current
);
27148 current
= INNERMOST_TEMPLATE_PARMS (current
);
27149 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
27151 for (int i
= 0; i
< start_idx
; ++i
)
27152 TREE_VEC_ELT (replacement
, i
)
27153 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
27155 for (int i
= start_idx
; i
< end_idx
; ++i
)
27157 /* Create a distinct parameter pack type from the current parm and add it
27158 to the replacement args to tsubst below into the generic function
27161 tree o
= TREE_TYPE (TREE_VALUE
27162 (TREE_VEC_ELT (current
, i
)));
27163 tree t
= copy_type (o
);
27164 TEMPLATE_TYPE_PARM_INDEX (t
)
27165 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
27167 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
27168 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
27169 TYPE_MAIN_VARIANT (t
) = t
;
27170 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
27171 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
27172 TREE_VEC_ELT (replacement
, i
) = t
;
27173 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
27176 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
27177 TREE_VEC_ELT (replacement
, i
)
27178 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
27180 /* If there are more levels then build up the replacement with the outer
27183 replacement
= add_to_template_args (template_parms_to_args
27184 (TREE_CHAIN (current_template_parms
)),
27187 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
27190 /* Entries in the decl_constraint hash table. */
27191 struct GTY((for_user
)) constr_entry
27197 /* Hashing function and equality for constraint entries. */
27198 struct constr_hasher
: ggc_ptr_hash
<constr_entry
>
27200 static hashval_t
hash (constr_entry
*e
)
27202 return (hashval_t
)DECL_UID (e
->decl
);
27205 static bool equal (constr_entry
*e1
, constr_entry
*e2
)
27207 return e1
->decl
== e2
->decl
;
27211 /* A mapping from declarations to constraint information. Note that
27212 both templates and their underlying declarations are mapped to the
27213 same constraint information.
27215 FIXME: This is defined in pt.c because garbage collection
27216 code is not being generated for constraint.cc. */
27218 static GTY (()) hash_table
<constr_hasher
> *decl_constraints
;
27220 /* Returns the template constraints of declaration T. If T is not
27221 constrained, return NULL_TREE. Note that T must be non-null. */
27224 get_constraints (tree t
)
27226 if (!flag_concepts
)
27229 gcc_assert (DECL_P (t
));
27230 if (TREE_CODE (t
) == TEMPLATE_DECL
)
27231 t
= DECL_TEMPLATE_RESULT (t
);
27232 constr_entry elt
= { t
, NULL_TREE
};
27233 constr_entry
* found
= decl_constraints
->find (&elt
);
27240 /* Associate the given constraint information CI with the declaration
27241 T. If T is a template, then the constraints are associated with
27242 its underlying declaration. Don't build associations if CI is
27246 set_constraints (tree t
, tree ci
)
27250 gcc_assert (t
&& flag_concepts
);
27251 if (TREE_CODE (t
) == TEMPLATE_DECL
)
27252 t
= DECL_TEMPLATE_RESULT (t
);
27253 gcc_assert (!get_constraints (t
));
27254 constr_entry elt
= {t
, ci
};
27255 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, INSERT
);
27256 constr_entry
* entry
= ggc_alloc
<constr_entry
> ();
27261 /* Remove the associated constraints of the declaration T. */
27264 remove_constraints (tree t
)
27266 gcc_assert (DECL_P (t
));
27267 if (TREE_CODE (t
) == TEMPLATE_DECL
)
27268 t
= DECL_TEMPLATE_RESULT (t
);
27270 constr_entry elt
= {t
, NULL_TREE
};
27271 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, NO_INSERT
);
27273 decl_constraints
->clear_slot (slot
);
27276 /* Memoized satisfaction results for declarations. This
27277 maps the pair (constraint_info, arguments) to the result computed
27278 by constraints_satisfied_p. */
27280 struct GTY((for_user
)) constraint_sat_entry
27287 /* Hashing function and equality for constraint entries. */
27289 struct constraint_sat_hasher
: ggc_ptr_hash
<constraint_sat_entry
>
27291 static hashval_t
hash (constraint_sat_entry
*e
)
27293 hashval_t val
= iterative_hash_object(e
->ci
, 0);
27294 return iterative_hash_template_arg (e
->args
, val
);
27297 static bool equal (constraint_sat_entry
*e1
, constraint_sat_entry
*e2
)
27299 return e1
->ci
== e2
->ci
&& comp_template_args (e1
->args
, e2
->args
);
27303 /* Memoized satisfaction results for concept checks. */
27305 struct GTY((for_user
)) concept_spec_entry
27312 /* Hashing function and equality for constraint entries. */
27314 struct concept_spec_hasher
: ggc_ptr_hash
<concept_spec_entry
>
27316 static hashval_t
hash (concept_spec_entry
*e
)
27318 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
27321 static bool equal (concept_spec_entry
*e1
, concept_spec_entry
*e2
)
27323 ++comparing_specializations
;
27324 bool eq
= e1
->tmpl
== e2
->tmpl
&& comp_template_args (e1
->args
, e2
->args
);
27325 --comparing_specializations
;
27330 static GTY (()) hash_table
<constraint_sat_hasher
> *constraint_memos
;
27331 static GTY (()) hash_table
<concept_spec_hasher
> *concept_memos
;
27333 /* Search for a memoized satisfaction result. Returns one of the
27334 truth value nodes if previously memoized, or NULL_TREE otherwise. */
27337 lookup_constraint_satisfaction (tree ci
, tree args
)
27339 constraint_sat_entry elt
= { ci
, args
, NULL_TREE
};
27340 constraint_sat_entry
* found
= constraint_memos
->find (&elt
);
27342 return found
->result
;
27347 /* Memoize the result of a satisfication test. Returns the saved result. */
27350 memoize_constraint_satisfaction (tree ci
, tree args
, tree result
)
27352 constraint_sat_entry elt
= {ci
, args
, result
};
27353 constraint_sat_entry
** slot
= constraint_memos
->find_slot (&elt
, INSERT
);
27354 constraint_sat_entry
* entry
= ggc_alloc
<constraint_sat_entry
> ();
27360 /* Search for a memoized satisfaction result for a concept. */
27363 lookup_concept_satisfaction (tree tmpl
, tree args
)
27365 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
27366 concept_spec_entry
* found
= concept_memos
->find (&elt
);
27368 return found
->result
;
27373 /* Memoize the result of a concept check. Returns the saved result. */
27376 memoize_concept_satisfaction (tree tmpl
, tree args
, tree result
)
27378 concept_spec_entry elt
= {tmpl
, args
, result
};
27379 concept_spec_entry
** slot
= concept_memos
->find_slot (&elt
, INSERT
);
27380 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
27386 static GTY (()) hash_table
<concept_spec_hasher
> *concept_expansions
;
27388 /* Returns a prior concept specialization. This returns the substituted
27389 and normalized constraints defined by the concept. */
27392 get_concept_expansion (tree tmpl
, tree args
)
27394 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
27395 concept_spec_entry
* found
= concept_expansions
->find (&elt
);
27397 return found
->result
;
27402 /* Save a concept expansion for later. */
27405 save_concept_expansion (tree tmpl
, tree args
, tree def
)
27407 concept_spec_entry elt
= {tmpl
, args
, def
};
27408 concept_spec_entry
** slot
= concept_expansions
->find_slot (&elt
, INSERT
);
27409 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
27416 hash_subsumption_args (tree t1
, tree t2
)
27418 gcc_assert (TREE_CODE (t1
) == CHECK_CONSTR
);
27419 gcc_assert (TREE_CODE (t2
) == CHECK_CONSTR
);
27421 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t1
), val
);
27422 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t1
), val
);
27423 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t2
), val
);
27424 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t2
), val
);
27428 /* Compare the constraints of two subsumption entries. The LEFT1 and
27429 LEFT2 arguments comprise the first subsumption pair and the RIGHT1
27430 and RIGHT2 arguments comprise the second. These are all CHECK_CONSTRs. */
27433 comp_subsumption_args (tree left1
, tree left2
, tree right1
, tree right2
)
27435 if (CHECK_CONSTR_CONCEPT (left1
) == CHECK_CONSTR_CONCEPT (right1
))
27436 if (CHECK_CONSTR_CONCEPT (left2
) == CHECK_CONSTR_CONCEPT (right2
))
27437 if (comp_template_args (CHECK_CONSTR_ARGS (left1
),
27438 CHECK_CONSTR_ARGS (right1
)))
27439 return comp_template_args (CHECK_CONSTR_ARGS (left2
),
27440 CHECK_CONSTR_ARGS (right2
));
27444 /* Key/value pair for learning and memoizing subsumption results. This
27445 associates a pair of check constraints (including arguments) with
27446 a boolean value indicating the result. */
27448 struct GTY((for_user
)) subsumption_entry
27455 /* Hashing function and equality for constraint entries. */
27457 struct subsumption_hasher
: ggc_ptr_hash
<subsumption_entry
>
27459 static hashval_t
hash (subsumption_entry
*e
)
27461 return hash_subsumption_args (e
->t1
, e
->t2
);
27464 static bool equal (subsumption_entry
*e1
, subsumption_entry
*e2
)
27466 ++comparing_specializations
;
27467 bool eq
= comp_subsumption_args(e1
->t1
, e1
->t2
, e2
->t1
, e2
->t2
);
27468 --comparing_specializations
;
27473 static GTY (()) hash_table
<subsumption_hasher
> *subsumption_table
;
27475 /* Search for a previously cached subsumption result. */
27478 lookup_subsumption_result (tree t1
, tree t2
)
27480 subsumption_entry elt
= { t1
, t2
, false };
27481 subsumption_entry
* found
= subsumption_table
->find (&elt
);
27483 return &found
->result
;
27488 /* Save a subsumption result. */
27491 save_subsumption_result (tree t1
, tree t2
, bool result
)
27493 subsumption_entry elt
= {t1
, t2
, result
};
27494 subsumption_entry
** slot
= subsumption_table
->find_slot (&elt
, INSERT
);
27495 subsumption_entry
* entry
= ggc_alloc
<subsumption_entry
> ();
27501 /* Set up the hash table for constraint association. */
27504 init_constraint_processing (void)
27506 if (!flag_concepts
)
27509 decl_constraints
= hash_table
<constr_hasher
>::create_ggc(37);
27510 constraint_memos
= hash_table
<constraint_sat_hasher
>::create_ggc(37);
27511 concept_memos
= hash_table
<concept_spec_hasher
>::create_ggc(37);
27512 concept_expansions
= hash_table
<concept_spec_hasher
>::create_ggc(37);
27513 subsumption_table
= hash_table
<subsumption_hasher
>::create_ggc(37);
27516 /* __integer_pack(N) in a pack expansion expands to a sequence of numbers from
27520 declare_integer_pack (void)
27522 tree ipfn
= push_library_fn (get_identifier ("__integer_pack"),
27523 build_function_type_list (integer_type_node
,
27526 NULL_TREE
, ECF_CONST
);
27527 DECL_DECLARED_CONSTEXPR_P (ipfn
) = true;
27528 DECL_BUILT_IN_CLASS (ipfn
) = BUILT_IN_FRONTEND
;
27531 /* Set up the hash tables for template instantiations. */
27534 init_template_processing (void)
27536 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
27537 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
27539 if (cxx_dialect
>= cxx11
)
27540 declare_integer_pack ();
27543 /* Print stats about the template hash tables for -fstats. */
27546 print_template_statistics (void)
27548 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
27549 "%f collisions\n", (long) decl_specializations
->size (),
27550 (long) decl_specializations
->elements (),
27551 decl_specializations
->collisions ());
27552 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
27553 "%f collisions\n", (long) type_specializations
->size (),
27554 (long) type_specializations
->elements (),
27555 type_specializations
->collisions ());
27560 namespace selftest
{
27562 /* Verify that build_non_dependent_expr () works, for various expressions,
27563 and that location wrappers don't affect the results. */
27566 test_build_non_dependent_expr ()
27568 location_t loc
= BUILTINS_LOCATION
;
27570 /* Verify constants, without and with location wrappers. */
27571 tree int_cst
= build_int_cst (integer_type_node
, 42);
27572 ASSERT_EQ (int_cst
, build_non_dependent_expr (int_cst
));
27574 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
27575 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
27576 ASSERT_EQ (wrapped_int_cst
, build_non_dependent_expr (wrapped_int_cst
));
27578 tree string_lit
= build_string (4, "foo");
27579 TREE_TYPE (string_lit
) = char_array_type_node
;
27580 string_lit
= fix_string_type (string_lit
);
27581 ASSERT_EQ (string_lit
, build_non_dependent_expr (string_lit
));
27583 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
27584 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
27585 ASSERT_EQ (wrapped_string_lit
,
27586 build_non_dependent_expr (wrapped_string_lit
));
27589 /* Verify that type_dependent_expression_p () works correctly, even
27590 in the presence of location wrapper nodes. */
27593 test_type_dependent_expression_p ()
27595 location_t loc
= BUILTINS_LOCATION
;
27597 tree name
= get_identifier ("foo");
27599 /* If no templates are involved, nothing is type-dependent. */
27600 gcc_assert (!processing_template_decl
);
27601 ASSERT_FALSE (type_dependent_expression_p (name
));
27603 ++processing_template_decl
;
27605 /* Within a template, an unresolved name is always type-dependent. */
27606 ASSERT_TRUE (type_dependent_expression_p (name
));
27608 /* Ensure it copes with NULL_TREE and errors. */
27609 ASSERT_FALSE (type_dependent_expression_p (NULL_TREE
));
27610 ASSERT_FALSE (type_dependent_expression_p (error_mark_node
));
27612 /* A USING_DECL in a template should be type-dependent, even if wrapped
27613 with a location wrapper (PR c++/83799). */
27614 tree using_decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
27615 TREE_TYPE (using_decl
) = integer_type_node
;
27616 ASSERT_TRUE (type_dependent_expression_p (using_decl
));
27617 tree wrapped_using_decl
= maybe_wrap_with_location (using_decl
, loc
);
27618 ASSERT_TRUE (location_wrapper_p (wrapped_using_decl
));
27619 ASSERT_TRUE (type_dependent_expression_p (wrapped_using_decl
));
27621 --processing_template_decl
;
27624 /* Run all of the selftests within this file. */
27629 test_build_non_dependent_expr ();
27630 test_type_dependent_expression_p ();
27633 } // namespace selftest
27635 #endif /* #if CHECKING_P */
27637 #include "gt-cp-pt.h"