1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2017 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Known bugs or deficiencies include:
24 all methods must be provided in header files; can't use a source
25 file that contains only the method templates and "just win". */
29 #include "coretypes.h"
32 #include "stringpool.h"
35 #include "stor-layout.h"
37 #include "c-family/c-objc.h"
38 #include "cp-objcp-common.h"
40 #include "tree-iterator.h"
41 #include "type-utils.h"
43 #include "gcc-rich-location.h"
45 /* The type of functions taking a tree, and some additional data, and
47 typedef int (*tree_fn_t
) (tree
, void*);
49 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
50 instantiations have been deferred, either because their definitions
51 were not yet available, or because we were putting off doing the work. */
52 struct GTY ((chain_next ("%h.next"))) pending_template
{
53 struct pending_template
*next
;
54 struct tinst_level
*tinst
;
57 static GTY(()) struct pending_template
*pending_templates
;
58 static GTY(()) struct pending_template
*last_pending_template
;
60 int processing_template_parmlist
;
61 static int template_header_count
;
63 static GTY(()) tree saved_trees
;
64 static vec
<int> inline_parm_levels
;
66 static GTY(()) struct tinst_level
*current_tinst_level
;
68 static GTY(()) tree saved_access_scope
;
70 /* Live only within one (recursive) call to tsubst_expr. We use
71 this to pass the statement expression node from the STMT_EXPR
72 to the EXPR_STMT that is its result. */
73 static tree cur_stmt_expr
;
75 // -------------------------------------------------------------------------- //
76 // Local Specialization Stack
78 // Implementation of the RAII helper for creating new local
80 local_specialization_stack::local_specialization_stack ()
81 : saved (local_specializations
)
83 local_specializations
= new hash_map
<tree
, tree
>;
86 local_specialization_stack::~local_specialization_stack ()
88 delete local_specializations
;
89 local_specializations
= saved
;
92 /* True if we've recursed into fn_type_unification too many times. */
93 static bool excessive_deduction_depth
;
95 struct GTY((for_user
)) spec_entry
102 struct spec_hasher
: ggc_ptr_hash
<spec_entry
>
104 static hashval_t
hash (spec_entry
*);
105 static bool equal (spec_entry
*, spec_entry
*);
108 static GTY (()) hash_table
<spec_hasher
> *decl_specializations
;
110 static GTY (()) hash_table
<spec_hasher
> *type_specializations
;
112 /* Contains canonical template parameter types. The vector is indexed by
113 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
114 TREE_LIST, whose TREE_VALUEs contain the canonical template
115 parameters of various types and levels. */
116 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
118 #define UNIFY_ALLOW_NONE 0
119 #define UNIFY_ALLOW_MORE_CV_QUAL 1
120 #define UNIFY_ALLOW_LESS_CV_QUAL 2
121 #define UNIFY_ALLOW_DERIVED 4
122 #define UNIFY_ALLOW_INTEGER 8
123 #define UNIFY_ALLOW_OUTER_LEVEL 16
124 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
125 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
127 enum template_base_result
{
129 tbr_ambiguous_baseclass
,
133 static void push_access_scope (tree
);
134 static void pop_access_scope (tree
);
135 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
136 unification_kind_t
, int,
138 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
139 unification_kind_t
, int, bool, bool);
140 static int unify (tree
, tree
, tree
, tree
, int, bool);
141 static void add_pending_template (tree
);
142 static tree
reopen_tinst_level (struct tinst_level
*);
143 static tree
tsubst_initializer_list (tree
, tree
);
144 static tree
get_partial_spec_bindings (tree
, tree
, tree
);
145 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
147 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
149 static void tsubst_enum (tree
, tree
, tree
);
150 static tree
add_to_template_args (tree
, tree
);
151 static tree
add_outermost_template_args (tree
, tree
);
152 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
153 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
155 static int type_unification_real (tree
, tree
, tree
, const tree
*,
156 unsigned int, int, unification_kind_t
, int,
157 vec
<deferred_access_check
, va_gc
> **,
159 static void note_template_header (int);
160 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
161 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
162 static tree
convert_template_argument (tree
, tree
, tree
,
163 tsubst_flags_t
, int, tree
);
164 static tree
for_each_template_parm (tree
, tree_fn_t
, void*,
165 hash_set
<tree
> *, bool, tree_fn_t
= NULL
);
166 static tree
expand_template_argument_pack (tree
);
167 static tree
build_template_parm_index (int, int, int, tree
, tree
);
168 static bool inline_needs_template_parms (tree
, bool);
169 static void push_inline_template_parms_recursive (tree
, int);
170 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
171 static int mark_template_parm (tree
, void *);
172 static int template_parm_this_level_p (tree
, void *);
173 static tree
tsubst_friend_function (tree
, tree
);
174 static tree
tsubst_friend_class (tree
, tree
);
175 static int can_complete_type_without_circularity (tree
);
176 static tree
get_bindings (tree
, tree
, tree
, bool);
177 static int template_decl_level (tree
);
178 static int check_cv_quals_for_unify (int, tree
, tree
);
179 static void template_parm_level_and_index (tree
, int*, int*);
180 static int unify_pack_expansion (tree
, tree
, tree
,
181 tree
, unification_kind_t
, bool, bool);
182 static tree
copy_template_args (tree
);
183 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
184 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
185 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
186 static tree
most_specialized_partial_spec (tree
, tsubst_flags_t
);
187 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
188 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
189 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
190 static bool check_specialization_scope (void);
191 static tree
process_partial_specialization (tree
);
192 static void set_current_access_from_decl (tree
);
193 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
195 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
196 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
198 static bool template_template_parm_bindings_ok_p (tree
, tree
);
199 static void tsubst_default_arguments (tree
, tsubst_flags_t
);
200 static tree
for_each_template_parm_r (tree
*, int *, void *);
201 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
202 static void copy_default_args_to_explicit_spec (tree
);
203 static int invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
204 static bool dependent_template_arg_p (tree
);
205 static bool any_template_arguments_need_structural_equality_p (tree
);
206 static bool dependent_type_p_r (tree
);
207 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
208 static tree
tsubst_decl (tree
, tree
, tsubst_flags_t
);
209 static void perform_typedefs_access_check (tree tmpl
, tree targs
);
210 static void append_type_to_template_for_access_check_1 (tree
, tree
, tree
,
212 static tree
listify (tree
);
213 static tree
listify_autos (tree
, tree
);
214 static tree
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
215 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
216 static bool complex_alias_template_p (const_tree tmpl
);
217 static tree
tsubst_attributes (tree
, tree
, tsubst_flags_t
, tree
);
218 static tree
canonicalize_expr_argument (tree
, tsubst_flags_t
);
219 static tree
make_argument_pack (tree
);
221 /* Make the current scope suitable for access checking when we are
222 processing T. T can be FUNCTION_DECL for instantiated function
223 template, VAR_DECL for static member variable, or TYPE_DECL for
224 alias template (needed by instantiate_decl). */
227 push_access_scope (tree t
)
229 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
230 || TREE_CODE (t
) == TYPE_DECL
);
232 if (DECL_FRIEND_CONTEXT (t
))
233 push_nested_class (DECL_FRIEND_CONTEXT (t
));
234 else if (DECL_CLASS_SCOPE_P (t
))
235 push_nested_class (DECL_CONTEXT (t
));
237 push_to_top_level ();
239 if (TREE_CODE (t
) == FUNCTION_DECL
)
241 saved_access_scope
= tree_cons
242 (NULL_TREE
, current_function_decl
, saved_access_scope
);
243 current_function_decl
= t
;
247 /* Restore the scope set up by push_access_scope. T is the node we
251 pop_access_scope (tree t
)
253 if (TREE_CODE (t
) == FUNCTION_DECL
)
255 current_function_decl
= TREE_VALUE (saved_access_scope
);
256 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
259 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
262 pop_from_top_level ();
265 /* Do any processing required when DECL (a member template
266 declaration) is finished. Returns the TEMPLATE_DECL corresponding
267 to DECL, unless it is a specialization, in which case the DECL
268 itself is returned. */
271 finish_member_template_decl (tree decl
)
273 if (decl
== error_mark_node
)
274 return error_mark_node
;
276 gcc_assert (DECL_P (decl
));
278 if (TREE_CODE (decl
) == TYPE_DECL
)
282 type
= TREE_TYPE (decl
);
283 if (type
== error_mark_node
)
284 return error_mark_node
;
285 if (MAYBE_CLASS_TYPE_P (type
)
286 && CLASSTYPE_TEMPLATE_INFO (type
)
287 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
289 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
290 check_member_template (tmpl
);
295 else if (TREE_CODE (decl
) == FIELD_DECL
)
296 error ("data member %qD cannot be a member template", decl
);
297 else if (DECL_TEMPLATE_INFO (decl
))
299 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
301 check_member_template (DECL_TI_TEMPLATE (decl
));
302 return DECL_TI_TEMPLATE (decl
);
308 error ("invalid member template declaration %qD", decl
);
310 return error_mark_node
;
313 /* Create a template info node. */
316 build_template_info (tree template_decl
, tree template_args
)
318 tree result
= make_node (TEMPLATE_INFO
);
319 TI_TEMPLATE (result
) = template_decl
;
320 TI_ARGS (result
) = template_args
;
324 /* Return the template info node corresponding to T, whatever T is. */
327 get_template_info (const_tree t
)
329 tree tinfo
= NULL_TREE
;
331 if (!t
|| t
== error_mark_node
)
334 if (TREE_CODE (t
) == NAMESPACE_DECL
335 || TREE_CODE (t
) == PARM_DECL
)
338 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
339 tinfo
= DECL_TEMPLATE_INFO (t
);
341 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
344 if (OVERLOAD_TYPE_P (t
))
345 tinfo
= TYPE_TEMPLATE_INFO (t
);
346 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
347 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
352 /* Returns the template nesting level of the indicated class TYPE.
362 A<T>::B<U> has depth two, while A<T> has depth one.
363 Both A<T>::B<int> and A<int>::B<U> have depth one, if
364 they are instantiations, not specializations.
366 This function is guaranteed to return 0 if passed NULL_TREE so
367 that, for example, `template_class_depth (current_class_type)' is
371 template_class_depth (tree type
)
375 for (depth
= 0; type
&& TREE_CODE (type
) != NAMESPACE_DECL
; )
377 tree tinfo
= get_template_info (type
);
379 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
380 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
384 type
= CP_DECL_CONTEXT (type
);
385 else if (LAMBDA_TYPE_P (type
))
386 type
= LAMBDA_TYPE_EXTRA_SCOPE (type
);
388 type
= CP_TYPE_CONTEXT (type
);
394 /* Subroutine of maybe_begin_member_template_processing.
395 Returns true if processing DECL needs us to push template parms. */
398 inline_needs_template_parms (tree decl
, bool nsdmi
)
400 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
403 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
404 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
407 /* Subroutine of maybe_begin_member_template_processing.
408 Push the template parms in PARMS, starting from LEVELS steps into the
409 chain, and ending at the beginning, since template parms are listed
413 push_inline_template_parms_recursive (tree parmlist
, int levels
)
415 tree parms
= TREE_VALUE (parmlist
);
419 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
421 ++processing_template_decl
;
422 current_template_parms
423 = tree_cons (size_int (processing_template_decl
),
424 parms
, current_template_parms
);
425 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
427 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
429 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
431 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
433 if (error_operand_p (parm
))
436 gcc_assert (DECL_P (parm
));
438 switch (TREE_CODE (parm
))
446 /* Push the CONST_DECL. */
447 pushdecl (TEMPLATE_PARM_DECL (DECL_INITIAL (parm
)));
456 /* Restore the template parameter context for a member template, a
457 friend template defined in a class definition, or a non-template
458 member of template class. */
461 maybe_begin_member_template_processing (tree decl
)
465 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
469 tree ctx
= DECL_CONTEXT (decl
);
470 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
471 /* Disregard full specializations (c++/60999). */
472 && uses_template_parms (ctx
)
473 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
476 if (inline_needs_template_parms (decl
, nsdmi
))
478 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
479 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
481 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
484 parms
= TREE_CHAIN (parms
);
487 push_inline_template_parms_recursive (parms
, levels
);
490 /* Remember how many levels of template parameters we pushed so that
491 we can pop them later. */
492 inline_parm_levels
.safe_push (levels
);
495 /* Undo the effects of maybe_begin_member_template_processing. */
498 maybe_end_member_template_processing (void)
503 if (inline_parm_levels
.length () == 0)
506 last
= inline_parm_levels
.pop ();
507 for (i
= 0; i
< last
; ++i
)
509 --processing_template_decl
;
510 current_template_parms
= TREE_CHAIN (current_template_parms
);
515 /* Return a new template argument vector which contains all of ARGS,
516 but has as its innermost set of arguments the EXTRA_ARGS. */
519 add_to_template_args (tree args
, tree extra_args
)
526 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
529 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
530 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
532 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
533 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
535 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
536 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
541 /* Like add_to_template_args, but only the outermost ARGS are added to
542 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
543 (EXTRA_ARGS) levels are added. This function is used to combine
544 the template arguments from a partial instantiation with the
545 template arguments used to attain the full instantiation from the
546 partial instantiation. */
549 add_outermost_template_args (tree args
, tree extra_args
)
553 /* If there are more levels of EXTRA_ARGS than there are ARGS,
554 something very fishy is going on. */
555 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
557 /* If *all* the new arguments will be the EXTRA_ARGS, just return
559 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
562 /* For the moment, we make ARGS look like it contains fewer levels. */
563 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
565 new_args
= add_to_template_args (args
, extra_args
);
567 /* Now, we restore ARGS to its full dimensions. */
568 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
573 /* Return the N levels of innermost template arguments from the ARGS. */
576 get_innermost_template_args (tree args
, int n
)
584 /* If N is 1, just return the innermost set of template arguments. */
586 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
588 /* If we're not removing anything, just return the arguments we were
590 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
591 gcc_assert (extra_levels
>= 0);
592 if (extra_levels
== 0)
595 /* Make a new set of arguments, not containing the outer arguments. */
596 new_args
= make_tree_vec (n
);
597 for (i
= 1; i
<= n
; ++i
)
598 SET_TMPL_ARGS_LEVEL (new_args
, i
,
599 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
604 /* The inverse of get_innermost_template_args: Return all but the innermost
605 EXTRA_LEVELS levels of template arguments from the ARGS. */
608 strip_innermost_template_args (tree args
, int extra_levels
)
611 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
616 /* If N is 1, just return the outermost set of template arguments. */
618 return TMPL_ARGS_LEVEL (args
, 1);
620 /* If we're not removing anything, just return the arguments we were
622 gcc_assert (extra_levels
>= 0);
623 if (extra_levels
== 0)
626 /* Make a new set of arguments, not containing the inner arguments. */
627 new_args
= make_tree_vec (n
);
628 for (i
= 1; i
<= n
; ++i
)
629 SET_TMPL_ARGS_LEVEL (new_args
, i
,
630 TMPL_ARGS_LEVEL (args
, i
));
635 /* We've got a template header coming up; push to a new level for storing
639 begin_template_parm_list (void)
641 /* We use a non-tag-transparent scope here, which causes pushtag to
642 put tags in this scope, rather than in the enclosing class or
643 namespace scope. This is the right thing, since we want
644 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
645 global template class, push_template_decl handles putting the
646 TEMPLATE_DECL into top-level scope. For a nested template class,
649 template <class T> struct S1 {
650 template <class T> struct S2 {};
653 pushtag contains special code to insert the TEMPLATE_DECL for S2
654 at the right scope. */
655 begin_scope (sk_template_parms
, NULL
);
656 ++processing_template_decl
;
657 ++processing_template_parmlist
;
658 note_template_header (0);
660 /* Add a dummy parameter level while we process the parameter list. */
661 current_template_parms
662 = tree_cons (size_int (processing_template_decl
),
664 current_template_parms
);
667 /* This routine is called when a specialization is declared. If it is
668 invalid to declare a specialization here, an error is reported and
669 false is returned, otherwise this routine will return true. */
672 check_specialization_scope (void)
674 tree scope
= current_scope ();
678 An explicit specialization shall be declared in the namespace of
679 which the template is a member, or, for member templates, in the
680 namespace of which the enclosing class or enclosing class
681 template is a member. An explicit specialization of a member
682 function, member class or static data member of a class template
683 shall be declared in the namespace of which the class template
685 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
687 error ("explicit specialization in non-namespace scope %qD", scope
);
693 In an explicit specialization declaration for a member of a class
694 template or a member template that appears in namespace scope,
695 the member template and some of its enclosing class templates may
696 remain unspecialized, except that the declaration shall not
697 explicitly specialize a class member template if its enclosing
698 class templates are not explicitly specialized as well. */
699 if (current_template_parms
)
701 error ("enclosing class templates are not explicitly specialized");
708 /* We've just seen template <>. */
711 begin_specialization (void)
713 begin_scope (sk_template_spec
, NULL
);
714 note_template_header (1);
715 return check_specialization_scope ();
718 /* Called at then end of processing a declaration preceded by
722 end_specialization (void)
725 reset_specialization ();
728 /* Any template <>'s that we have seen thus far are not referring to a
729 function specialization. */
732 reset_specialization (void)
734 processing_specialization
= 0;
735 template_header_count
= 0;
738 /* We've just seen a template header. If SPECIALIZATION is nonzero,
739 it was of the form template <>. */
742 note_template_header (int specialization
)
744 processing_specialization
= specialization
;
745 template_header_count
++;
748 /* We're beginning an explicit instantiation. */
751 begin_explicit_instantiation (void)
753 gcc_assert (!processing_explicit_instantiation
);
754 processing_explicit_instantiation
= true;
759 end_explicit_instantiation (void)
761 gcc_assert (processing_explicit_instantiation
);
762 processing_explicit_instantiation
= false;
765 /* An explicit specialization or partial specialization of TMPL is being
766 declared. Check that the namespace in which the specialization is
767 occurring is permissible. Returns false iff it is invalid to
768 specialize TMPL in the current namespace. */
771 check_specialization_namespace (tree tmpl
)
773 tree tpl_ns
= decl_namespace_context (tmpl
);
777 An explicit specialization shall be declared in a namespace enclosing the
778 specialized template. An explicit specialization whose declarator-id is
779 not qualified shall be declared in the nearest enclosing namespace of the
780 template, or, if the namespace is inline (7.3.1), any namespace from its
781 enclosing namespace set. */
782 if (current_scope() != DECL_CONTEXT (tmpl
)
783 && !at_namespace_scope_p ())
785 error ("specialization of %qD must appear at namespace scope", tmpl
);
789 if (is_nested_namespace (current_namespace
, tpl_ns
, cxx_dialect
< cxx11
))
790 /* Same or enclosing namespace. */
794 permerror (input_location
,
795 "specialization of %qD in different namespace", tmpl
);
796 inform (DECL_SOURCE_LOCATION (tmpl
),
797 " from definition of %q#D", tmpl
);
802 /* SPEC is an explicit instantiation. Check that it is valid to
803 perform this explicit instantiation in the current namespace. */
806 check_explicit_instantiation_namespace (tree spec
)
810 /* DR 275: An explicit instantiation shall appear in an enclosing
811 namespace of its template. */
812 ns
= decl_namespace_context (spec
);
813 if (!is_nested_namespace (current_namespace
, ns
))
814 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
815 "(which does not enclose namespace %qD)",
816 spec
, current_namespace
, ns
);
819 // Returns the type of a template specialization only if that
820 // specialization needs to be defined. Otherwise (e.g., if the type has
821 // already been defined), the function returns NULL_TREE.
823 maybe_new_partial_specialization (tree type
)
825 // An implicit instantiation of an incomplete type implies
826 // the definition of a new class template.
828 // template<typename T>
831 // template<typename T>
834 // Here, S<T*> is an implicit instantiation of S whose type
836 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
) && !COMPLETE_TYPE_P (type
))
839 // It can also be the case that TYPE is a completed specialization.
840 // Continuing the previous example, suppose we also declare:
842 // template<typename T>
843 // requires Integral<T>
846 // Here, S<T*> refers to the specialization S<T*> defined
847 // above. However, we need to differentiate definitions because
848 // we intend to define a new partial specialization. In this case,
849 // we rely on the fact that the constraints are different for
850 // this declaration than that above.
852 // Note that we also get here for injected class names and
853 // late-parsed template definitions. We must ensure that we
854 // do not create new type declarations for those cases.
855 if (flag_concepts
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
857 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
858 tree args
= CLASSTYPE_TI_ARGS (type
);
860 // If there are no template parameters, this cannot be a new
861 // partial template specializtion?
862 if (!current_template_parms
)
865 // The injected-class-name is not a new partial specialization.
866 if (DECL_SELF_REFERENCE_P (TYPE_NAME (type
)))
869 // If the constraints are not the same as those of the primary
870 // then, we can probably create a new specialization.
871 tree type_constr
= current_template_constraints ();
873 if (type
== TREE_TYPE (tmpl
))
875 tree main_constr
= get_constraints (tmpl
);
876 if (equivalent_constraints (type_constr
, main_constr
))
880 // Also, if there's a pre-existing specialization with matching
881 // constraints, then this also isn't new.
882 tree specs
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
885 tree spec_tmpl
= TREE_VALUE (specs
);
886 tree spec_args
= TREE_PURPOSE (specs
);
887 tree spec_constr
= get_constraints (spec_tmpl
);
888 if (comp_template_args (args
, spec_args
)
889 && equivalent_constraints (type_constr
, spec_constr
))
891 specs
= TREE_CHAIN (specs
);
894 // Create a new type node (and corresponding type decl)
895 // for the newly declared specialization.
896 tree t
= make_class_type (TREE_CODE (type
));
897 CLASSTYPE_DECLARED_CLASS (t
) = CLASSTYPE_DECLARED_CLASS (type
);
898 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (tmpl
, args
));
900 /* We only need a separate type node for storing the definition of this
901 partial specialization; uses of S<T*> are unconstrained, so all are
902 equivalent. So keep TYPE_CANONICAL the same. */
903 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
905 // Build the corresponding type decl.
906 tree d
= create_implicit_typedef (DECL_NAME (tmpl
), t
);
907 DECL_CONTEXT (d
) = TYPE_CONTEXT (t
);
908 DECL_SOURCE_LOCATION (d
) = input_location
;
916 /* The TYPE is being declared. If it is a template type, that means it
917 is a partial specialization. Do appropriate error-checking. */
920 maybe_process_partial_specialization (tree type
)
924 if (type
== error_mark_node
)
925 return error_mark_node
;
927 /* A lambda that appears in specialization context is not itself a
929 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
932 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
934 error ("name of class shadows template template parameter %qD",
936 return error_mark_node
;
939 context
= TYPE_CONTEXT (type
);
941 if (TYPE_ALIAS_P (type
))
943 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (type
);
945 if (tinfo
&& DECL_ALIAS_TEMPLATE_P (TI_TEMPLATE (tinfo
)))
946 error ("specialization of alias template %qD",
947 TI_TEMPLATE (tinfo
));
949 error ("explicit specialization of non-template %qT", type
);
950 return error_mark_node
;
952 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
954 /* This is for ordinary explicit specialization and partial
955 specialization of a template class such as:
957 template <> class C<int>;
961 template <class T> class C<T*>;
963 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
965 if (tree t
= maybe_new_partial_specialization (type
))
967 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (t
))
968 && !at_namespace_scope_p ())
969 return error_mark_node
;
970 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t
);
971 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (t
)) = input_location
;
972 if (processing_template_decl
)
974 tree decl
= push_template_decl (TYPE_MAIN_DECL (t
));
975 if (decl
== error_mark_node
)
976 return error_mark_node
;
977 return TREE_TYPE (decl
);
980 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
981 error ("specialization of %qT after instantiation", type
);
982 else if (errorcount
&& !processing_specialization
983 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
984 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
985 /* Trying to define a specialization either without a template<> header
986 or in an inappropriate place. We've already given an error, so just
987 bail now so we don't actually define the specialization. */
988 return error_mark_node
;
990 else if (CLASS_TYPE_P (type
)
991 && !CLASSTYPE_USE_TEMPLATE (type
)
992 && CLASSTYPE_TEMPLATE_INFO (type
)
993 && context
&& CLASS_TYPE_P (context
)
994 && CLASSTYPE_TEMPLATE_INFO (context
))
996 /* This is for an explicit specialization of member class
997 template according to [temp.expl.spec/18]:
999 template <> template <class U> class C<int>::D;
1001 The context `C<int>' must be an implicit instantiation.
1002 Otherwise this is just a member class template declared
1005 template <> class C<int> { template <class U> class D; };
1006 template <> template <class U> class C<int>::D;
1008 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1009 while in the second case, `C<int>::D' is a primary template
1010 and `C<T>::D' may not exist. */
1012 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
1013 && !COMPLETE_TYPE_P (type
))
1016 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1018 if (current_namespace
1019 != decl_namespace_context (tmpl
))
1021 permerror (input_location
,
1022 "specializing %q#T in different namespace", type
);
1023 permerror (DECL_SOURCE_LOCATION (tmpl
),
1024 " from definition of %q#D", tmpl
);
1027 /* Check for invalid specialization after instantiation:
1029 template <> template <> class C<int>::D<int>;
1030 template <> template <class U> class C<int>::D; */
1032 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
1033 t
; t
= TREE_CHAIN (t
))
1035 tree inst
= TREE_VALUE (t
);
1036 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
1037 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
1039 /* We already have a full specialization of this partial
1040 instantiation, or a full specialization has been
1041 looked up but not instantiated. Reassign it to the
1042 new member specialization template. */
1046 elt
.tmpl
= most_general_template (tmpl
);
1047 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
1050 type_specializations
->remove_elt (&elt
);
1053 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
1056 = type_specializations
->find_slot (&elt
, INSERT
);
1057 entry
= ggc_alloc
<spec_entry
> ();
1062 /* But if we've had an implicit instantiation, that's a
1063 problem ([temp.expl.spec]/6). */
1064 error ("specialization %qT after instantiation %qT",
1068 /* Mark TYPE as a specialization. And as a result, we only
1069 have one level of template argument for the innermost
1071 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
1072 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
1073 CLASSTYPE_TI_ARGS (type
)
1074 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
1077 else if (processing_specialization
)
1079 /* Someday C++0x may allow for enum template specialization. */
1080 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
1081 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
1082 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
1083 "of %qD not allowed by ISO C++", type
);
1086 error ("explicit specialization of non-template %qT", type
);
1087 return error_mark_node
;
1094 /* Returns nonzero if we can optimize the retrieval of specializations
1095 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1096 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1099 optimize_specialization_lookup_p (tree tmpl
)
1101 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
1102 && DECL_CLASS_SCOPE_P (tmpl
)
1103 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1105 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
1106 /* The optimized lookup depends on the fact that the
1107 template arguments for the member function template apply
1108 purely to the containing class, which is not true if the
1109 containing class is an explicit or partial
1111 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1112 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1113 && !DECL_CONV_FN_P (tmpl
)
1114 /* It is possible to have a template that is not a member
1115 template and is not a member of a template class:
1117 template <typename T>
1118 struct S { friend A::f(); };
1120 Here, the friend function is a template, but the context does
1121 not have template information. The optimized lookup relies
1122 on having ARGS be the template arguments for both the class
1123 and the function template. */
1124 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1127 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1128 gone through coerce_template_parms by now. */
1131 verify_unstripped_args (tree args
)
1133 ++processing_template_decl
;
1134 if (!any_dependent_template_arguments_p (args
))
1136 tree inner
= INNERMOST_TEMPLATE_ARGS (args
);
1137 for (int i
= 0; i
< TREE_VEC_LENGTH (inner
); ++i
)
1139 tree arg
= TREE_VEC_ELT (inner
, i
);
1140 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1142 else if (TYPE_P (arg
))
1143 gcc_assert (strip_typedefs (arg
, NULL
) == arg
);
1144 else if (strip_typedefs (TREE_TYPE (arg
), NULL
) != TREE_TYPE (arg
))
1145 /* Allow typedefs on the type of a non-type argument, since a
1146 parameter can have them. */;
1148 gcc_assert (strip_typedefs_expr (arg
, NULL
) == arg
);
1151 --processing_template_decl
;
1154 /* Retrieve the specialization (in the sense of [temp.spec] - a
1155 specialization is either an instantiation or an explicit
1156 specialization) of TMPL for the given template ARGS. If there is
1157 no such specialization, return NULL_TREE. The ARGS are a vector of
1158 arguments, or a vector of vectors of arguments, in the case of
1159 templates with more than one level of parameters.
1161 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1162 then we search for a partial specialization matching ARGS. This
1163 parameter is ignored if TMPL is not a class template.
1165 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1166 result is a NONTYPE_ARGUMENT_PACK. */
1169 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1171 if (tmpl
== NULL_TREE
)
1174 if (args
== error_mark_node
)
1177 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1178 || TREE_CODE (tmpl
) == FIELD_DECL
);
1180 /* There should be as many levels of arguments as there are
1181 levels of parameters. */
1182 gcc_assert (TMPL_ARGS_DEPTH (args
)
1183 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1184 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1185 : template_class_depth (DECL_CONTEXT (tmpl
))));
1188 verify_unstripped_args (args
);
1190 if (optimize_specialization_lookup_p (tmpl
))
1192 /* The template arguments actually apply to the containing
1193 class. Find the class specialization with those
1195 tree class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1196 tree class_specialization
1197 = retrieve_specialization (class_template
, args
, 0);
1198 if (!class_specialization
)
1201 /* Find the instance of TMPL. */
1202 tree fns
= lookup_fnfields_slot (class_specialization
, DECL_NAME (tmpl
));
1203 for (ovl_iterator
iter (fns
); iter
; ++iter
)
1206 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1207 /* using-declarations can add base methods to the method vec,
1208 and we don't want those here. */
1209 && DECL_CONTEXT (fn
) == class_specialization
)
1218 hash_table
<spec_hasher
> *specializations
;
1222 elt
.spec
= NULL_TREE
;
1224 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1225 specializations
= type_specializations
;
1227 specializations
= decl_specializations
;
1230 hash
= spec_hasher::hash (&elt
);
1231 found
= specializations
->find_with_hash (&elt
, hash
);
1239 /* Like retrieve_specialization, but for local declarations. */
1242 retrieve_local_specialization (tree tmpl
)
1244 if (local_specializations
== NULL
)
1247 tree
*slot
= local_specializations
->get (tmpl
);
1248 return slot
? *slot
: NULL_TREE
;
1251 /* Returns nonzero iff DECL is a specialization of TMPL. */
1254 is_specialization_of (tree decl
, tree tmpl
)
1258 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1262 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1268 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1270 for (t
= TREE_TYPE (decl
);
1272 t
= CLASSTYPE_USE_TEMPLATE (t
)
1273 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1274 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1281 /* Returns nonzero iff DECL is a specialization of friend declaration
1282 FRIEND_DECL according to [temp.friend]. */
1285 is_specialization_of_friend (tree decl
, tree friend_decl
)
1287 bool need_template
= true;
1290 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1291 || TREE_CODE (decl
) == TYPE_DECL
);
1293 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1294 of a template class, we want to check if DECL is a specialization
1296 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1297 && DECL_TEMPLATE_INFO (friend_decl
)
1298 && !DECL_USE_TEMPLATE (friend_decl
))
1300 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1301 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1302 need_template
= false;
1304 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1305 && !PRIMARY_TEMPLATE_P (friend_decl
))
1306 need_template
= false;
1308 /* There is nothing to do if this is not a template friend. */
1309 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1312 if (is_specialization_of (decl
, friend_decl
))
1316 A member of a class template may be declared to be a friend of a
1317 non-template class. In this case, the corresponding member of
1318 every specialization of the class template is a friend of the
1319 class granting friendship.
1321 For example, given a template friend declaration
1323 template <class T> friend void A<T>::f();
1325 the member function below is considered a friend
1327 template <> struct A<int> {
1331 For this type of template friend, TEMPLATE_DEPTH below will be
1332 nonzero. To determine if DECL is a friend of FRIEND, we first
1333 check if the enclosing class is a specialization of another. */
1335 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1337 && DECL_CLASS_SCOPE_P (decl
)
1338 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1339 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1341 /* Next, we check the members themselves. In order to handle
1342 a few tricky cases, such as when FRIEND_DECL's are
1344 template <class T> friend void A<T>::g(T t);
1345 template <class T> template <T t> friend void A<T>::h();
1349 void A<int>::g(int);
1350 template <int> void A<int>::h();
1352 we need to figure out ARGS, the template arguments from
1353 the context of DECL. This is required for template substitution
1354 of `T' in the function parameter of `g' and template parameter
1355 of `h' in the above examples. Here ARGS corresponds to `int'. */
1357 tree context
= DECL_CONTEXT (decl
);
1358 tree args
= NULL_TREE
;
1359 int current_depth
= 0;
1361 while (current_depth
< template_depth
)
1363 if (CLASSTYPE_TEMPLATE_INFO (context
))
1365 if (current_depth
== 0)
1366 args
= TYPE_TI_ARGS (context
);
1368 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1371 context
= TYPE_CONTEXT (context
);
1374 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1379 tree friend_args_type
;
1380 tree decl_args_type
;
1382 /* Make sure that both DECL and FRIEND_DECL are templates or
1384 is_template
= DECL_TEMPLATE_INFO (decl
)
1385 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1386 if (need_template
^ is_template
)
1388 else if (is_template
)
1390 /* If both are templates, check template parameter list. */
1392 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1394 if (!comp_template_parms
1395 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1399 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1402 decl_type
= TREE_TYPE (decl
);
1404 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1405 tf_none
, NULL_TREE
);
1406 if (friend_type
== error_mark_node
)
1409 /* Check if return types match. */
1410 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1413 /* Check if function parameter types match, ignoring the
1414 `this' parameter. */
1415 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1416 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1417 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1418 friend_args_type
= TREE_CHAIN (friend_args_type
);
1419 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1420 decl_args_type
= TREE_CHAIN (decl_args_type
);
1422 return compparms (decl_args_type
, friend_args_type
);
1426 /* DECL is a TYPE_DECL */
1428 tree decl_type
= TREE_TYPE (decl
);
1430 /* Make sure that both DECL and FRIEND_DECL are templates or
1433 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1434 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1436 if (need_template
^ is_template
)
1438 else if (is_template
)
1441 /* If both are templates, check the name of the two
1442 TEMPLATE_DECL's first because is_friend didn't. */
1443 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1444 != DECL_NAME (friend_decl
))
1447 /* Now check template parameter list. */
1449 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1451 return comp_template_parms
1452 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1456 return (DECL_NAME (decl
)
1457 == DECL_NAME (friend_decl
));
1463 /* Register the specialization SPEC as a specialization of TMPL with
1464 the indicated ARGS. IS_FRIEND indicates whether the specialization
1465 is actually just a friend declaration. Returns SPEC, or an
1466 equivalent prior declaration, if available.
1468 We also store instantiations of field packs in the hash table, even
1469 though they are not themselves templates, to make lookup easier. */
1472 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1476 spec_entry
**slot
= NULL
;
1479 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1480 || (TREE_CODE (tmpl
) == FIELD_DECL
1481 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1483 if (TREE_CODE (spec
) == FUNCTION_DECL
1484 && uses_template_parms (DECL_TI_ARGS (spec
)))
1485 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1486 register it; we want the corresponding TEMPLATE_DECL instead.
1487 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1488 the more obvious `uses_template_parms (spec)' to avoid problems
1489 with default function arguments. In particular, given
1490 something like this:
1492 template <class T> void f(T t1, T t = T())
1494 the default argument expression is not substituted for in an
1495 instantiation unless and until it is actually needed. */
1498 if (optimize_specialization_lookup_p (tmpl
))
1499 /* We don't put these specializations in the hash table, but we might
1500 want to give an error about a mismatch. */
1501 fn
= retrieve_specialization (tmpl
, args
, 0);
1509 hash
= spec_hasher::hash (&elt
);
1512 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1514 fn
= ((spec_entry
*) *slot
)->spec
;
1519 /* We can sometimes try to re-register a specialization that we've
1520 already got. In particular, regenerate_decl_from_template calls
1521 duplicate_decls which will update the specialization list. But,
1522 we'll still get called again here anyhow. It's more convenient
1523 to simply allow this than to try to prevent it. */
1526 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1528 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1530 if (DECL_ODR_USED (fn
)
1531 || DECL_EXPLICIT_INSTANTIATION (fn
))
1533 error ("specialization of %qD after instantiation",
1535 return error_mark_node
;
1540 /* This situation should occur only if the first
1541 specialization is an implicit instantiation, the
1542 second is an explicit specialization, and the
1543 implicit instantiation has not yet been used. That
1544 situation can occur if we have implicitly
1545 instantiated a member function and then specialized
1548 We can also wind up here if a friend declaration that
1549 looked like an instantiation turns out to be a
1552 template <class T> void foo(T);
1553 class S { friend void foo<>(int) };
1554 template <> void foo(int);
1556 We transform the existing DECL in place so that any
1557 pointers to it become pointers to the updated
1560 If there was a definition for the template, but not
1561 for the specialization, we want this to look as if
1562 there were no definition, and vice versa. */
1563 DECL_INITIAL (fn
) = NULL_TREE
;
1564 duplicate_decls (spec
, fn
, is_friend
);
1565 /* The call to duplicate_decls will have applied
1568 An explicit specialization of a function template
1569 is inline only if it is explicitly declared to be,
1570 and independently of whether its function template
1573 to the primary function; now copy the inline bits to
1574 the various clones. */
1575 FOR_EACH_CLONE (clone
, fn
)
1577 DECL_DECLARED_INLINE_P (clone
)
1578 = DECL_DECLARED_INLINE_P (fn
);
1579 DECL_SOURCE_LOCATION (clone
)
1580 = DECL_SOURCE_LOCATION (fn
);
1581 DECL_DELETED_FN (clone
)
1582 = DECL_DELETED_FN (fn
);
1584 check_specialization_namespace (tmpl
);
1589 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1591 tree dd
= duplicate_decls (spec
, fn
, is_friend
);
1592 if (dd
== error_mark_node
)
1593 /* We've already complained in duplicate_decls. */
1594 return error_mark_node
;
1596 if (dd
== NULL_TREE
&& DECL_INITIAL (spec
))
1597 /* Dup decl failed, but this is a new definition. Set the
1598 line number so any errors match this new
1600 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1606 return duplicate_decls (spec
, fn
, is_friend
);
1608 /* A specialization must be declared in the same namespace as the
1609 template it is specializing. */
1610 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1611 && !check_specialization_namespace (tmpl
))
1612 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1614 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1616 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1617 gcc_assert (tmpl
&& args
&& spec
);
1620 if ((TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1621 && PRIMARY_TEMPLATE_P (tmpl
)
1622 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1623 || variable_template_p (tmpl
))
1624 /* If TMPL is a forward declaration of a template function, keep a list
1625 of all specializations in case we need to reassign them to a friend
1626 template later in tsubst_friend_function.
1628 Also keep a list of all variable template instantiations so that
1629 process_partial_specialization can check whether a later partial
1630 specialization would have used it. */
1631 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1632 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1638 /* Returns true iff two spec_entry nodes are equivalent. */
1640 int comparing_specializations
;
1643 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1647 ++comparing_specializations
;
1648 equal
= (e1
->tmpl
== e2
->tmpl
1649 && comp_template_args (e1
->args
, e2
->args
));
1650 if (equal
&& flag_concepts
1651 /* tmpl could be a FIELD_DECL for a capture pack. */
1652 && TREE_CODE (e1
->tmpl
) == TEMPLATE_DECL
1653 && VAR_P (DECL_TEMPLATE_RESULT (e1
->tmpl
))
1654 && uses_template_parms (e1
->args
))
1656 /* Partial specializations of a variable template can be distinguished by
1658 tree c1
= e1
->spec
? get_constraints (e1
->spec
) : NULL_TREE
;
1659 tree c2
= e2
->spec
? get_constraints (e2
->spec
) : NULL_TREE
;
1660 equal
= equivalent_constraints (c1
, c2
);
1662 --comparing_specializations
;
1667 /* Returns a hash for a template TMPL and template arguments ARGS. */
1670 hash_tmpl_and_args (tree tmpl
, tree args
)
1672 hashval_t val
= iterative_hash_object (DECL_UID (tmpl
), 0);
1673 return iterative_hash_template_arg (args
, val
);
1676 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1680 spec_hasher::hash (spec_entry
*e
)
1682 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1685 /* Recursively calculate a hash value for a template argument ARG, for use
1686 in the hash tables of template specializations. */
1689 iterative_hash_template_arg (tree arg
, hashval_t val
)
1691 unsigned HOST_WIDE_INT i
;
1692 enum tree_code code
;
1695 if (arg
== NULL_TREE
)
1696 return iterative_hash_object (arg
, val
);
1701 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1704 code
= TREE_CODE (arg
);
1705 tclass
= TREE_CODE_CLASS (code
);
1707 val
= iterative_hash_object (code
, val
);
1714 case IDENTIFIER_NODE
:
1715 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1719 int i
, len
= TREE_VEC_LENGTH (arg
);
1720 for (i
= 0; i
< len
; ++i
)
1721 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1725 case TYPE_PACK_EXPANSION
:
1726 case EXPR_PACK_EXPANSION
:
1727 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1728 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1730 case TYPE_ARGUMENT_PACK
:
1731 case NONTYPE_ARGUMENT_PACK
:
1732 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1735 for (; arg
; arg
= TREE_CHAIN (arg
))
1736 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1740 for (lkp_iterator
iter (arg
); iter
; ++iter
)
1741 val
= iterative_hash_template_arg (*iter
, val
);
1747 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1748 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1750 val
= iterative_hash_template_arg (field
, val
);
1751 val
= iterative_hash_template_arg (value
, val
);
1757 if (!DECL_ARTIFICIAL (arg
))
1759 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1760 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1762 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1765 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1768 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1769 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1771 case TEMPLATE_PARM_INDEX
:
1772 val
= iterative_hash_template_arg
1773 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1774 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1775 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1778 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1779 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1780 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1783 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1785 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1789 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1790 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1791 val
= iterative_hash_object (code
, val
);
1792 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1795 /* A lambda can't appear in a template arg, but don't crash on
1797 gcc_assert (seen_error ());
1801 case IMPLICIT_CONV_EXPR
:
1802 case STATIC_CAST_EXPR
:
1803 case REINTERPRET_CAST_EXPR
:
1804 case CONST_CAST_EXPR
:
1805 case DYNAMIC_CAST_EXPR
:
1807 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1808 /* Now hash operands as usual. */
1818 if (alias_template_specialization_p (arg
))
1820 // We want an alias specialization that survived strip_typedefs
1821 // to hash differently from its TYPE_CANONICAL, to avoid hash
1822 // collisions that compare as different in template_args_equal.
1823 // These could be dependent specializations that strip_typedefs
1824 // left alone, or untouched specializations because
1825 // coerce_template_parms returns the unconverted template
1826 // arguments if it sees incomplete argument packs.
1827 tree ti
= TYPE_ALIAS_TEMPLATE_INFO (arg
);
1828 return hash_tmpl_and_args (TI_TEMPLATE (ti
), TI_ARGS (ti
));
1830 if (TYPE_CANONICAL (arg
))
1831 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1833 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1834 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1835 /* Otherwise just compare the types during lookup. */
1838 case tcc_declaration
:
1840 return iterative_hash_expr (arg
, val
);
1843 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1845 unsigned n
= cp_tree_operand_length (arg
);
1846 for (i
= 0; i
< n
; ++i
)
1847 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1855 /* Unregister the specialization SPEC as a specialization of TMPL.
1856 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1857 if the SPEC was listed as a specialization of TMPL.
1859 Note that SPEC has been ggc_freed, so we can't look inside it. */
1862 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1867 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1868 elt
.args
= TI_ARGS (tinfo
);
1869 elt
.spec
= NULL_TREE
;
1871 entry
= decl_specializations
->find (&elt
);
1874 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1875 gcc_assert (new_spec
!= NULL_TREE
);
1876 entry
->spec
= new_spec
;
1883 /* Like register_specialization, but for local declarations. We are
1884 registering SPEC, an instantiation of TMPL. */
1887 register_local_specialization (tree spec
, tree tmpl
)
1889 local_specializations
->put (tmpl
, spec
);
1892 /* TYPE is a class type. Returns true if TYPE is an explicitly
1893 specialized class. */
1896 explicit_class_specialization_p (tree type
)
1898 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1900 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1903 /* Print the list of functions at FNS, going through all the overloads
1904 for each element of the list. Alternatively, FNS can not be a
1905 TREE_LIST, in which case it will be printed together with all the
1908 MORE and *STR should respectively be FALSE and NULL when the function
1909 is called from the outside. They are used internally on recursive
1910 calls. print_candidates manages the two parameters and leaves NULL
1911 in *STR when it ends. */
1914 print_candidates_1 (tree fns
, char **str
, bool more
= false)
1916 if (TREE_CODE (fns
) == TREE_LIST
)
1917 for (; fns
; fns
= TREE_CHAIN (fns
))
1918 print_candidates_1 (TREE_VALUE (fns
), str
, more
|| TREE_CHAIN (fns
));
1920 for (lkp_iterator
iter (fns
); iter
;)
1925 const char *pfx
= *str
;
1929 pfx
= _("candidates are:");
1931 pfx
= _("candidate is:");
1932 *str
= get_spaces (pfx
);
1934 inform (DECL_SOURCE_LOCATION (cand
), "%s %#qD", pfx
, cand
);
1938 /* Print the list of candidate FNS in an error message. FNS can also
1939 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1942 print_candidates (tree fns
)
1945 print_candidates_1 (fns
, &str
);
1949 /* Get a (possibly) constrained template declaration for the
1950 purpose of ordering candidates. */
1952 get_template_for_ordering (tree list
)
1954 gcc_assert (TREE_CODE (list
) == TREE_LIST
);
1955 tree f
= TREE_VALUE (list
);
1956 if (tree ti
= DECL_TEMPLATE_INFO (f
))
1957 return TI_TEMPLATE (ti
);
1961 /* Among candidates having the same signature, return the
1962 most constrained or NULL_TREE if there is no best candidate.
1963 If the signatures of candidates vary (e.g., template
1964 specialization vs. member function), then there can be no
1967 Note that we don't compare constraints on the functions
1968 themselves, but rather those of their templates. */
1970 most_constrained_function (tree candidates
)
1972 // Try to find the best candidate in a first pass.
1973 tree champ
= candidates
;
1974 for (tree c
= TREE_CHAIN (champ
); c
; c
= TREE_CHAIN (c
))
1976 int winner
= more_constrained (get_template_for_ordering (champ
),
1977 get_template_for_ordering (c
));
1979 champ
= c
; // The candidate is more constrained
1980 else if (winner
== 0)
1981 return NULL_TREE
; // Neither is more constrained
1984 // Verify that the champ is better than previous candidates.
1985 for (tree c
= candidates
; c
!= champ
; c
= TREE_CHAIN (c
)) {
1986 if (!more_constrained (get_template_for_ordering (champ
),
1987 get_template_for_ordering (c
)))
1995 /* Returns the template (one of the functions given by TEMPLATE_ID)
1996 which can be specialized to match the indicated DECL with the
1997 explicit template args given in TEMPLATE_ID. The DECL may be
1998 NULL_TREE if none is available. In that case, the functions in
1999 TEMPLATE_ID are non-members.
2001 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2002 specialization of a member template.
2004 The TEMPLATE_COUNT is the number of references to qualifying
2005 template classes that appeared in the name of the function. See
2006 check_explicit_specialization for a more accurate description.
2008 TSK indicates what kind of template declaration (if any) is being
2009 declared. TSK_TEMPLATE indicates that the declaration given by
2010 DECL, though a FUNCTION_DECL, has template parameters, and is
2011 therefore a template function.
2013 The template args (those explicitly specified and those deduced)
2014 are output in a newly created vector *TARGS_OUT.
2016 If it is impossible to determine the result, an error message is
2017 issued. The error_mark_node is returned to indicate failure. */
2020 determine_specialization (tree template_id
,
2023 int need_member_template
,
2029 tree explicit_targs
;
2030 tree candidates
= NULL_TREE
;
2032 /* A TREE_LIST of templates of which DECL may be a specialization.
2033 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2034 corresponding TREE_PURPOSE is the set of template arguments that,
2035 when used to instantiate the template, would produce a function
2036 with the signature of DECL. */
2037 tree templates
= NULL_TREE
;
2039 cp_binding_level
*b
;
2041 *targs_out
= NULL_TREE
;
2043 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
2044 return error_mark_node
;
2046 /* We shouldn't be specializing a member template of an
2047 unspecialized class template; we already gave an error in
2048 check_specialization_scope, now avoid crashing. */
2049 if (template_count
&& DECL_CLASS_SCOPE_P (decl
)
2050 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
2052 gcc_assert (errorcount
);
2053 return error_mark_node
;
2056 fns
= TREE_OPERAND (template_id
, 0);
2057 explicit_targs
= TREE_OPERAND (template_id
, 1);
2059 if (fns
== error_mark_node
)
2060 return error_mark_node
;
2062 /* Check for baselinks. */
2063 if (BASELINK_P (fns
))
2064 fns
= BASELINK_FUNCTIONS (fns
);
2066 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
2068 error ("%qD is not a function template", fns
);
2069 return error_mark_node
;
2071 else if (VAR_P (decl
) && !variable_template_p (fns
))
2073 error ("%qD is not a variable template", fns
);
2074 return error_mark_node
;
2077 /* Count the number of template headers specified for this
2080 for (b
= current_binding_level
;
2081 b
->kind
== sk_template_parms
;
2085 tree orig_fns
= fns
;
2087 if (variable_template_p (fns
))
2089 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns
));
2090 targs
= coerce_template_parms (parms
, explicit_targs
, fns
,
2091 tf_warning_or_error
,
2092 /*req_all*/true, /*use_defarg*/true);
2093 if (targs
!= error_mark_node
)
2094 templates
= tree_cons (targs
, fns
, templates
);
2096 else for (lkp_iterator
iter (fns
); iter
; ++iter
)
2100 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2102 tree decl_arg_types
;
2106 /* In case of explicit specialization, we need to check if
2107 the number of template headers appearing in the specialization
2108 is correct. This is usually done in check_explicit_specialization,
2109 but the check done there cannot be exhaustive when specializing
2110 member functions. Consider the following code:
2112 template <> void A<int>::f(int);
2113 template <> template <> void A<int>::f(int);
2115 Assuming that A<int> is not itself an explicit specialization
2116 already, the first line specializes "f" which is a non-template
2117 member function, whilst the second line specializes "f" which
2118 is a template member function. So both lines are syntactically
2119 correct, and check_explicit_specialization does not reject
2122 Here, we can do better, as we are matching the specialization
2123 against the declarations. We count the number of template
2124 headers, and we check if they match TEMPLATE_COUNT + 1
2125 (TEMPLATE_COUNT is the number of qualifying template classes,
2126 plus there must be another header for the member template
2129 Notice that if header_count is zero, this is not a
2130 specialization but rather a template instantiation, so there
2131 is no check we can perform here. */
2132 if (header_count
&& header_count
!= template_count
+ 1)
2135 /* Check that the number of template arguments at the
2136 innermost level for DECL is the same as for FN. */
2137 if (current_binding_level
->kind
== sk_template_parms
2138 && !current_binding_level
->explicit_spec_p
2139 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
2140 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
2141 (current_template_parms
))))
2144 /* DECL might be a specialization of FN. */
2145 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2146 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2148 /* For a non-static member function, we need to make sure
2149 that the const qualification is the same. Since
2150 get_bindings does not try to merge the "this" parameter,
2151 we must do the comparison explicitly. */
2152 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2153 && !same_type_p (TREE_VALUE (fn_arg_types
),
2154 TREE_VALUE (decl_arg_types
)))
2157 /* Skip the "this" parameter and, for constructors of
2158 classes with virtual bases, the VTT parameter. A
2159 full specialization of a constructor will have a VTT
2160 parameter, but a template never will. */
2162 = skip_artificial_parms_for (decl
, decl_arg_types
);
2164 = skip_artificial_parms_for (fn
, fn_arg_types
);
2166 /* Function templates cannot be specializations; there are
2167 no partial specializations of functions. Therefore, if
2168 the type of DECL does not match FN, there is no
2171 Note that it should never be the case that we have both
2172 candidates added here, and for regular member functions
2174 if (tsk
== tsk_template
)
2176 if (compparms (fn_arg_types
, decl_arg_types
))
2177 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2181 /* See whether this function might be a specialization of this
2182 template. Suppress access control because we might be trying
2183 to make this specialization a friend, and we have already done
2184 access control for the declaration of the specialization. */
2185 push_deferring_access_checks (dk_no_check
);
2186 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
2187 pop_deferring_access_checks ();
2190 /* We cannot deduce template arguments that when used to
2191 specialize TMPL will produce DECL. */
2194 /* Remove, from the set of candidates, all those functions
2195 whose constraints are not satisfied. */
2196 if (flag_concepts
&& !constraints_satisfied_p (fn
, targs
))
2199 // Then, try to form the new function type.
2200 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_fndecl_type
, NULL_TREE
);
2201 if (insttype
== error_mark_node
)
2204 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
2205 if (!compparms (fn_arg_types
, decl_arg_types
))
2208 /* Save this template, and the arguments deduced. */
2209 templates
= tree_cons (targs
, fn
, templates
);
2211 else if (need_member_template
)
2212 /* FN is an ordinary member function, and we need a
2213 specialization of a member template. */
2215 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2216 /* We can get IDENTIFIER_NODEs here in certain erroneous
2219 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2220 /* This is just an ordinary non-member function. Nothing can
2221 be a specialization of that. */
2223 else if (DECL_ARTIFICIAL (fn
))
2224 /* Cannot specialize functions that are created implicitly. */
2228 tree decl_arg_types
;
2230 /* This is an ordinary member function. However, since
2231 we're here, we can assume its enclosing class is a
2232 template class. For example,
2234 template <typename T> struct S { void f(); };
2235 template <> void S<int>::f() {}
2237 Here, S<int>::f is a non-template, but S<int> is a
2238 template class. If FN has the same type as DECL, we
2239 might be in business. */
2241 if (!DECL_TEMPLATE_INFO (fn
))
2242 /* Its enclosing class is an explicit specialization
2243 of a template class. This is not a candidate. */
2246 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2247 TREE_TYPE (TREE_TYPE (fn
))))
2248 /* The return types differ. */
2251 /* Adjust the type of DECL in case FN is a static member. */
2252 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2253 if (DECL_STATIC_FUNCTION_P (fn
)
2254 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2255 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2257 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2261 // If the deduced arguments do not satisfy the constraints,
2262 // this is not a candidate.
2263 if (flag_concepts
&& !constraints_satisfied_p (fn
))
2266 // Add the candidate.
2267 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2271 if (templates
&& TREE_CHAIN (templates
))
2277 It is possible for a specialization with a given function
2278 signature to be instantiated from more than one function
2279 template. In such cases, explicit specification of the
2280 template arguments must be used to uniquely identify the
2281 function template specialization being specialized.
2283 Note that here, there's no suggestion that we're supposed to
2284 determine which of the candidate templates is most
2285 specialized. However, we, also have:
2289 Partial ordering of overloaded function template
2290 declarations is used in the following contexts to select
2291 the function template to which a function template
2292 specialization refers:
2294 -- when an explicit specialization refers to a function
2297 So, we do use the partial ordering rules, at least for now.
2298 This extension can only serve to make invalid programs valid,
2299 so it's safe. And, there is strong anecdotal evidence that
2300 the committee intended the partial ordering rules to apply;
2301 the EDG front end has that behavior, and John Spicer claims
2302 that the committee simply forgot to delete the wording in
2303 [temp.expl.spec]. */
2304 tree tmpl
= most_specialized_instantiation (templates
);
2305 if (tmpl
!= error_mark_node
)
2308 TREE_CHAIN (templates
) = NULL_TREE
;
2312 // Concepts allows multiple declarations of member functions
2313 // with the same signature. Like above, we need to rely on
2314 // on the partial ordering of those candidates to determine which
2316 if (flag_concepts
&& candidates
&& TREE_CHAIN (candidates
))
2318 if (tree cand
= most_constrained_function (candidates
))
2321 TREE_CHAIN (cand
) = NULL_TREE
;
2325 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2327 error ("template-id %qD for %q+D does not match any template "
2328 "declaration", template_id
, decl
);
2329 if (header_count
&& header_count
!= template_count
+ 1)
2330 inform (input_location
, "saw %d %<template<>%>, need %d for "
2331 "specializing a member function template",
2332 header_count
, template_count
+ 1);
2334 print_candidates (orig_fns
);
2335 return error_mark_node
;
2337 else if ((templates
&& TREE_CHAIN (templates
))
2338 || (candidates
&& TREE_CHAIN (candidates
))
2339 || (templates
&& candidates
))
2341 error ("ambiguous template specialization %qD for %q+D",
2343 candidates
= chainon (candidates
, templates
);
2344 print_candidates (candidates
);
2345 return error_mark_node
;
2348 /* We have one, and exactly one, match. */
2351 tree fn
= TREE_VALUE (candidates
);
2352 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2354 // Propagate the candidate's constraints to the declaration.
2355 set_constraints (decl
, get_constraints (fn
));
2357 /* DECL is a re-declaration or partial instantiation of a template
2359 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2361 /* It was a specialization of an ordinary member function in a
2363 return DECL_TI_TEMPLATE (fn
);
2366 /* It was a specialization of a template. */
2367 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2368 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2370 *targs_out
= copy_node (targs
);
2371 SET_TMPL_ARGS_LEVEL (*targs_out
,
2372 TMPL_ARGS_DEPTH (*targs_out
),
2373 TREE_PURPOSE (templates
));
2376 *targs_out
= TREE_PURPOSE (templates
);
2377 return TREE_VALUE (templates
);
2380 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2381 but with the default argument values filled in from those in the
2385 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2388 tree new_spec_types
;
2393 if (spec_types
== void_list_node
)
2394 return void_list_node
;
2396 /* Substitute into the rest of the list. */
2398 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2399 TREE_CHAIN (tmpl_types
));
2401 /* Add the default argument for this parameter. */
2402 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2403 TREE_VALUE (spec_types
),
2407 /* DECL is an explicit specialization. Replicate default arguments
2408 from the template it specializes. (That way, code like:
2410 template <class T> void f(T = 3);
2411 template <> void f(double);
2414 works, as required.) An alternative approach would be to look up
2415 the correct default arguments at the call-site, but this approach
2416 is consistent with how implicit instantiations are handled. */
2419 copy_default_args_to_explicit_spec (tree decl
)
2424 tree new_spec_types
;
2428 tree object_type
= NULL_TREE
;
2429 tree in_charge
= NULL_TREE
;
2430 tree vtt
= NULL_TREE
;
2432 /* See if there's anything we need to do. */
2433 tmpl
= DECL_TI_TEMPLATE (decl
);
2434 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2435 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2436 if (TREE_PURPOSE (t
))
2441 old_type
= TREE_TYPE (decl
);
2442 spec_types
= TYPE_ARG_TYPES (old_type
);
2444 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2446 /* Remove the this pointer, but remember the object's type for
2448 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2449 spec_types
= TREE_CHAIN (spec_types
);
2450 tmpl_types
= TREE_CHAIN (tmpl_types
);
2452 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2454 /* DECL may contain more parameters than TMPL due to the extra
2455 in-charge parameter in constructors and destructors. */
2456 in_charge
= spec_types
;
2457 spec_types
= TREE_CHAIN (spec_types
);
2459 if (DECL_HAS_VTT_PARM_P (decl
))
2462 spec_types
= TREE_CHAIN (spec_types
);
2466 /* Compute the merged default arguments. */
2468 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2470 /* Compute the new FUNCTION_TYPE. */
2474 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2479 /* Put the in-charge parameter back. */
2480 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2481 TREE_VALUE (in_charge
),
2484 new_type
= build_method_type_directly (object_type
,
2485 TREE_TYPE (old_type
),
2489 new_type
= build_function_type (TREE_TYPE (old_type
),
2491 new_type
= cp_build_type_attribute_variant (new_type
,
2492 TYPE_ATTRIBUTES (old_type
));
2493 new_type
= build_exception_variant (new_type
,
2494 TYPE_RAISES_EXCEPTIONS (old_type
));
2496 if (TYPE_HAS_LATE_RETURN_TYPE (old_type
))
2497 TYPE_HAS_LATE_RETURN_TYPE (new_type
) = 1;
2499 TREE_TYPE (decl
) = new_type
;
2502 /* Return the number of template headers we expect to see for a definition
2503 or specialization of CTYPE or one of its non-template members. */
2506 num_template_headers_for_class (tree ctype
)
2508 int num_templates
= 0;
2510 while (ctype
&& CLASS_TYPE_P (ctype
))
2512 /* You're supposed to have one `template <...>' for every
2513 template class, but you don't need one for a full
2514 specialization. For example:
2516 template <class T> struct S{};
2517 template <> struct S<int> { void f(); };
2518 void S<int>::f () {}
2520 is correct; there shouldn't be a `template <>' for the
2521 definition of `S<int>::f'. */
2522 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2523 /* If CTYPE does not have template information of any
2524 kind, then it is not a template, nor is it nested
2525 within a template. */
2527 if (explicit_class_specialization_p (ctype
))
2529 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2532 ctype
= TYPE_CONTEXT (ctype
);
2535 return num_templates
;
2538 /* Do a simple sanity check on the template headers that precede the
2539 variable declaration DECL. */
2542 check_template_variable (tree decl
)
2544 tree ctx
= CP_DECL_CONTEXT (decl
);
2545 int wanted
= num_template_headers_for_class (ctx
);
2546 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2547 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2549 if (cxx_dialect
< cxx14
)
2550 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2551 "variable templates only available with "
2552 "-std=c++14 or -std=gnu++14");
2554 // Namespace-scope variable templates should have a template header.
2557 if (template_header_count
> wanted
)
2559 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2560 "too many template headers for %qD "
2563 if (warned
&& CLASS_TYPE_P (ctx
)
2564 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2565 inform (DECL_SOURCE_LOCATION (decl
),
2566 "members of an explicitly specialized class are defined "
2567 "without a template header");
2571 /* An explicit specialization whose declarator-id or class-head-name is not
2572 qualified shall be declared in the nearest enclosing namespace of the
2573 template, or, if the namespace is inline (7.3.1), any namespace from its
2574 enclosing namespace set.
2576 If the name declared in the explicit instantiation is an unqualified name,
2577 the explicit instantiation shall appear in the namespace where its template
2578 is declared or, if that namespace is inline (7.3.1), any namespace from its
2579 enclosing namespace set. */
2582 check_unqualified_spec_or_inst (tree t
, location_t loc
)
2584 tree tmpl
= most_general_template (t
);
2585 if (DECL_NAMESPACE_SCOPE_P (tmpl
)
2586 && !is_nested_namespace (current_namespace
,
2587 CP_DECL_CONTEXT (tmpl
), true))
2589 if (processing_specialization
)
2590 permerror (loc
, "explicit specialization of %qD outside its "
2591 "namespace must use a nested-name-specifier", tmpl
);
2592 else if (processing_explicit_instantiation
2593 && cxx_dialect
>= cxx11
)
2594 /* This was allowed in C++98, so only pedwarn. */
2595 pedwarn (loc
, OPT_Wpedantic
, "explicit instantiation of %qD "
2596 "outside its namespace must use a nested-name-"
2601 /* Check to see if the function just declared, as indicated in
2602 DECLARATOR, and in DECL, is a specialization of a function
2603 template. We may also discover that the declaration is an explicit
2604 instantiation at this point.
2606 Returns DECL, or an equivalent declaration that should be used
2607 instead if all goes well. Issues an error message if something is
2608 amiss. Returns error_mark_node if the error is not easily
2611 FLAGS is a bitmask consisting of the following flags:
2613 2: The function has a definition.
2614 4: The function is a friend.
2616 The TEMPLATE_COUNT is the number of references to qualifying
2617 template classes that appeared in the name of the function. For
2620 template <class T> struct S { void f(); };
2623 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2624 classes are not counted in the TEMPLATE_COUNT, so that in
2626 template <class T> struct S {};
2627 template <> struct S<int> { void f(); }
2628 template <> void S<int>::f();
2630 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2631 invalid; there should be no template <>.)
2633 If the function is a specialization, it is marked as such via
2634 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2635 is set up correctly, and it is added to the list of specializations
2636 for that template. */
2639 check_explicit_specialization (tree declarator
,
2644 int have_def
= flags
& 2;
2645 int is_friend
= flags
& 4;
2646 bool is_concept
= flags
& 8;
2647 int specialization
= 0;
2648 int explicit_instantiation
= 0;
2649 int member_specialization
= 0;
2650 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2651 tree dname
= DECL_NAME (decl
);
2656 if (!processing_specialization
)
2659 tsk
= tsk_excessive_parms
;
2662 tsk
= current_tmpl_spec_kind (template_count
);
2667 if (processing_specialization
&& !VAR_P (decl
))
2670 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2672 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2675 /* This could be something like:
2677 template <class T> void f(T);
2678 class S { friend void f<>(int); } */
2682 /* This case handles bogus declarations like template <>
2683 template <class T> void f<int>(); */
2685 error ("template-id %qD in declaration of primary template",
2692 case tsk_invalid_member_spec
:
2693 /* The error has already been reported in
2694 check_specialization_scope. */
2695 return error_mark_node
;
2697 case tsk_invalid_expl_inst
:
2698 error ("template parameter list used in explicit instantiation");
2704 error ("definition provided for explicit instantiation");
2706 explicit_instantiation
= 1;
2709 case tsk_excessive_parms
:
2710 case tsk_insufficient_parms
:
2711 if (tsk
== tsk_excessive_parms
)
2712 error ("too many template parameter lists in declaration of %qD",
2714 else if (template_header_count
)
2715 error("too few template parameter lists in declaration of %qD", decl
);
2717 error("explicit specialization of %qD must be introduced by "
2718 "%<template <>%>", decl
);
2723 error ("explicit specialization declared %<concept%>");
2725 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2726 /* In cases like template<> constexpr bool v = true;
2727 We'll give an error in check_template_variable. */
2730 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2732 member_specialization
= 1;
2738 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2740 /* This case handles bogus declarations like template <>
2741 template <class T> void f<int>(); */
2743 if (!uses_template_parms (declarator
))
2744 error ("template-id %qD in declaration of primary template",
2746 else if (variable_template_p (TREE_OPERAND (declarator
, 0)))
2748 /* Partial specialization of variable template. */
2749 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2753 else if (cxx_dialect
< cxx14
)
2754 error ("non-type partial specialization %qD "
2755 "is not allowed", declarator
);
2757 error ("non-class, non-variable partial specialization %qD "
2758 "is not allowed", declarator
);
2763 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2764 /* This is a specialization of a member template, without
2765 specialization the containing class. Something like:
2767 template <class T> struct S {
2768 template <class U> void f (U);
2770 template <> template <class U> void S<int>::f(U) {}
2772 That's a specialization -- but of the entire template. */
2780 if ((specialization
|| member_specialization
)
2781 /* This doesn't apply to variable templates. */
2782 && (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
2783 || TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
))
2785 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2786 for (; t
; t
= TREE_CHAIN (t
))
2787 if (TREE_PURPOSE (t
))
2789 permerror (input_location
,
2790 "default argument specified in explicit specialization");
2795 if (specialization
|| member_specialization
|| explicit_instantiation
)
2797 tree tmpl
= NULL_TREE
;
2798 tree targs
= NULL_TREE
;
2799 bool was_template_id
= (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
);
2801 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2802 if (!was_template_id
)
2806 gcc_assert (identifier_p (declarator
));
2811 /* If there is no class context, the explicit instantiation
2812 must be at namespace scope. */
2813 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2815 /* Find the namespace binding, using the declaration
2817 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2819 if (fns
== error_mark_node
)
2820 /* If lookup fails, look for a friend declaration so we can
2821 give a better diagnostic. */
2822 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2823 /*type*/false, /*complain*/true,
2826 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2828 error ("%qD is not a template function", dname
);
2829 fns
= error_mark_node
;
2833 declarator
= lookup_template_function (fns
, NULL_TREE
);
2836 if (declarator
== error_mark_node
)
2837 return error_mark_node
;
2839 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2841 if (!explicit_instantiation
)
2842 /* A specialization in class scope. This is invalid,
2843 but the error will already have been flagged by
2844 check_specialization_scope. */
2845 return error_mark_node
;
2848 /* It's not valid to write an explicit instantiation in
2851 class C { template void f(); }
2853 This case is caught by the parser. However, on
2856 template class C { void f(); };
2858 (which is invalid) we can get here. The error will be
2865 else if (ctype
!= NULL_TREE
2866 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2868 // We'll match variable templates in start_decl.
2872 /* Find the list of functions in ctype that have the same
2873 name as the declared function. */
2874 tree name
= TREE_OPERAND (declarator
, 0);
2876 if (constructor_name_p (name
, ctype
))
2878 if (DECL_CONSTRUCTOR_P (decl
)
2879 ? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2880 : !CLASSTYPE_DESTRUCTOR (ctype
))
2882 /* From [temp.expl.spec]:
2884 If such an explicit specialization for the member
2885 of a class template names an implicitly-declared
2886 special member function (clause _special_), the
2887 program is ill-formed.
2889 Similar language is found in [temp.explicit]. */
2890 error ("specialization of implicitly-declared special member function");
2891 return error_mark_node
;
2894 name
= DECL_NAME (decl
);
2897 tree fns
= NULL_TREE
;
2898 if (DECL_CONV_FN_P (decl
))
2899 /* For a type-conversion operator, we cannot do a
2900 name-based lookup. We might be looking for `operator
2901 int' which will be a specialization of `operator T'.
2902 Grab all the conversion operators, and then select from
2904 fns
= lookup_all_conversions (ctype
);
2906 fns
= lookup_fnfields_slot_nolazy (ctype
, name
);
2908 if (fns
== NULL_TREE
)
2910 error ("no member function %qD declared in %qT", name
, ctype
);
2911 return error_mark_node
;
2914 TREE_OPERAND (declarator
, 0) = fns
;
2917 /* Figure out what exactly is being specialized at this point.
2918 Note that for an explicit instantiation, even one for a
2919 member function, we cannot tell a priori whether the
2920 instantiation is for a member template, or just a member
2921 function of a template class. Even if a member template is
2922 being instantiated, the member template arguments may be
2923 elided if they can be deduced from the rest of the
2925 tmpl
= determine_specialization (declarator
, decl
,
2927 member_specialization
,
2931 if (!tmpl
|| tmpl
== error_mark_node
)
2932 /* We couldn't figure out what this declaration was
2934 return error_mark_node
;
2937 if (TREE_CODE (decl
) == FUNCTION_DECL
2938 && DECL_HIDDEN_FRIEND_P (tmpl
))
2940 if (pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2941 "friend declaration %qD is not visible to "
2942 "explicit specialization", tmpl
))
2943 inform (DECL_SOURCE_LOCATION (tmpl
),
2944 "friend declaration here");
2946 else if (!ctype
&& !is_friend
2947 && CP_DECL_CONTEXT (decl
) == current_namespace
)
2948 check_unqualified_spec_or_inst (tmpl
, DECL_SOURCE_LOCATION (decl
));
2950 tree gen_tmpl
= most_general_template (tmpl
);
2952 if (explicit_instantiation
)
2954 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2955 is done by do_decl_instantiation later. */
2957 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2958 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2960 if (arg_depth
> parm_depth
)
2962 /* If TMPL is not the most general template (for
2963 example, if TMPL is a friend template that is
2964 injected into namespace scope), then there will
2965 be too many levels of TARGS. Remove some of them
2970 new_targs
= make_tree_vec (parm_depth
);
2971 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2972 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2973 = TREE_VEC_ELT (targs
, i
);
2977 return instantiate_template (tmpl
, targs
, tf_error
);
2980 /* If we thought that the DECL was a member function, but it
2981 turns out to be specializing a static member function,
2982 make DECL a static member function as well. */
2983 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
2984 && DECL_STATIC_FUNCTION_P (tmpl
)
2985 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2986 revert_static_member_fn (decl
);
2988 /* If this is a specialization of a member template of a
2989 template class, we want to return the TEMPLATE_DECL, not
2990 the specialization of it. */
2991 if (tsk
== tsk_template
&& !was_template_id
)
2993 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
2994 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2995 DECL_INITIAL (result
) = NULL_TREE
;
2999 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
3000 DECL_SOURCE_LOCATION (result
)
3001 = DECL_SOURCE_LOCATION (decl
);
3002 /* We want to use the argument list specified in the
3003 definition, not in the original declaration. */
3004 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
3005 for (parm
= DECL_ARGUMENTS (result
); parm
;
3006 parm
= DECL_CHAIN (parm
))
3007 DECL_CONTEXT (parm
) = result
;
3009 return register_specialization (tmpl
, gen_tmpl
, targs
,
3013 /* Set up the DECL_TEMPLATE_INFO for DECL. */
3014 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
3016 if (was_template_id
)
3017 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
)) = true;
3019 /* Inherit default function arguments from the template
3020 DECL is specializing. */
3021 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
3022 copy_default_args_to_explicit_spec (decl
);
3024 /* This specialization has the same protection as the
3025 template it specializes. */
3026 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
3027 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
3029 /* 7.1.1-1 [dcl.stc]
3031 A storage-class-specifier shall not be specified in an
3032 explicit specialization...
3034 The parser rejects these, so unless action is taken here,
3035 explicit function specializations will always appear with
3038 The action recommended by the C++ CWG in response to C++
3039 defect report 605 is to make the storage class and linkage
3040 of the explicit specialization match the templated function:
3042 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3044 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
3046 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
3047 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
3049 /* A concept cannot be specialized. */
3050 if (DECL_DECLARED_CONCEPT_P (tmpl_func
))
3052 error ("explicit specialization of function concept %qD",
3054 return error_mark_node
;
3057 /* This specialization has the same linkage and visibility as
3058 the function template it specializes. */
3059 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
3060 if (! TREE_PUBLIC (decl
))
3062 DECL_INTERFACE_KNOWN (decl
) = 1;
3063 DECL_NOT_REALLY_EXTERN (decl
) = 1;
3065 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
3066 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
3068 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3069 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
3073 /* If DECL is a friend declaration, declared using an
3074 unqualified name, the namespace associated with DECL may
3075 have been set incorrectly. For example, in:
3077 template <typename T> void f(T);
3079 struct S { friend void f<int>(int); }
3082 we will have set the DECL_CONTEXT for the friend
3083 declaration to N, rather than to the global namespace. */
3084 if (DECL_NAMESPACE_SCOPE_P (decl
))
3085 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
3087 if (is_friend
&& !have_def
)
3088 /* This is not really a declaration of a specialization.
3089 It's just the name of an instantiation. But, it's not
3090 a request for an instantiation, either. */
3091 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
3092 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3093 /* A specialization is not necessarily COMDAT. */
3094 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
3095 && DECL_DECLARED_INLINE_P (decl
));
3096 else if (VAR_P (decl
))
3097 DECL_COMDAT (decl
) = false;
3099 /* If this is a full specialization, register it so that we can find
3100 it again. Partial specializations will be registered in
3101 process_partial_specialization. */
3102 if (!processing_template_decl
)
3103 decl
= register_specialization (decl
, gen_tmpl
, targs
,
3106 /* A 'structor should already have clones. */
3107 gcc_assert (decl
== error_mark_node
3108 || variable_template_p (tmpl
)
3109 || !(DECL_CONSTRUCTOR_P (decl
)
3110 || DECL_DESTRUCTOR_P (decl
))
3111 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
3118 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3119 parameters. These are represented in the same format used for
3120 DECL_TEMPLATE_PARMS. */
3123 comp_template_parms (const_tree parms1
, const_tree parms2
)
3128 if (parms1
== parms2
)
3131 for (p1
= parms1
, p2
= parms2
;
3132 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
3133 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
3135 tree t1
= TREE_VALUE (p1
);
3136 tree t2
= TREE_VALUE (p2
);
3139 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
3140 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
3142 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3145 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
3147 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
3148 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
3150 /* If either of the template parameters are invalid, assume
3151 they match for the sake of error recovery. */
3152 if (error_operand_p (parm1
) || error_operand_p (parm2
))
3155 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
3158 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
3159 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
3160 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
3162 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
3167 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
3168 /* One set of parameters has more parameters lists than the
3175 /* Determine whether PARM is a parameter pack. */
3178 template_parameter_pack_p (const_tree parm
)
3180 /* Determine if we have a non-type template parameter pack. */
3181 if (TREE_CODE (parm
) == PARM_DECL
)
3182 return (DECL_TEMPLATE_PARM_P (parm
)
3183 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
3184 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
3185 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
3187 /* If this is a list of template parameters, we could get a
3188 TYPE_DECL or a TEMPLATE_DECL. */
3189 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
3190 parm
= TREE_TYPE (parm
);
3192 /* Otherwise it must be a type template parameter. */
3193 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
3194 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
3195 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
3198 /* Determine if T is a function parameter pack. */
3201 function_parameter_pack_p (const_tree t
)
3203 if (t
&& TREE_CODE (t
) == PARM_DECL
)
3204 return DECL_PACK_P (t
);
3208 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3209 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3212 get_function_template_decl (const_tree primary_func_tmpl_inst
)
3214 if (! primary_func_tmpl_inst
3215 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
3216 || ! primary_template_instantiation_p (primary_func_tmpl_inst
))
3219 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
3222 /* Return true iff the function parameter PARAM_DECL was expanded
3223 from the function parameter pack PACK. */
3226 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
3228 if (DECL_ARTIFICIAL (param_decl
)
3229 || !function_parameter_pack_p (pack
))
3232 /* The parameter pack and its pack arguments have the same
3234 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
3237 /* Determine whether ARGS describes a variadic template args list,
3238 i.e., one that is terminated by a template argument pack. */
3241 template_args_variadic_p (tree args
)
3246 if (args
== NULL_TREE
)
3249 args
= INNERMOST_TEMPLATE_ARGS (args
);
3250 nargs
= TREE_VEC_LENGTH (args
);
3255 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
3257 return ARGUMENT_PACK_P (last_parm
);
3260 /* Generate a new name for the parameter pack name NAME (an
3261 IDENTIFIER_NODE) that incorporates its */
3264 make_ith_pack_parameter_name (tree name
, int i
)
3266 /* Munge the name to include the parameter index. */
3267 #define NUMBUF_LEN 128
3268 char numbuf
[NUMBUF_LEN
];
3272 if (name
== NULL_TREE
)
3274 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
3275 newname_len
= IDENTIFIER_LENGTH (name
)
3276 + strlen (numbuf
) + 2;
3277 newname
= (char*)alloca (newname_len
);
3278 snprintf (newname
, newname_len
,
3279 "%s#%i", IDENTIFIER_POINTER (name
), i
);
3280 return get_identifier (newname
);
3283 /* Return true if T is a primary function, class or alias template
3287 primary_template_instantiation_p (const_tree t
)
3292 if (TREE_CODE (t
) == FUNCTION_DECL
)
3293 return DECL_LANG_SPECIFIC (t
)
3294 && DECL_TEMPLATE_INSTANTIATION (t
)
3295 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
));
3296 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3297 return CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
3298 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
));
3299 else if (alias_template_specialization_p (t
))
3304 /* Return true if PARM is a template template parameter. */
3307 template_template_parameter_p (const_tree parm
)
3309 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3312 /* Return true iff PARM is a DECL representing a type template
3316 template_type_parameter_p (const_tree parm
)
3319 && (TREE_CODE (parm
) == TYPE_DECL
3320 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3321 && DECL_TEMPLATE_PARM_P (parm
));
3324 /* Return the template parameters of T if T is a
3325 primary template instantiation, NULL otherwise. */
3328 get_primary_template_innermost_parameters (const_tree t
)
3330 tree parms
= NULL
, template_info
= NULL
;
3332 if ((template_info
= get_template_info (t
))
3333 && primary_template_instantiation_p (t
))
3334 parms
= INNERMOST_TEMPLATE_PARMS
3335 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3340 /* Return the template parameters of the LEVELth level from the full list
3341 of template parameters PARMS. */
3344 get_template_parms_at_level (tree parms
, int level
)
3348 || TREE_CODE (parms
) != TREE_LIST
3349 || level
> TMPL_PARMS_DEPTH (parms
))
3352 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3353 if (TMPL_PARMS_DEPTH (p
) == level
)
3359 /* Returns the template arguments of T if T is a template instantiation,
3363 get_template_innermost_arguments (const_tree t
)
3365 tree args
= NULL
, template_info
= NULL
;
3367 if ((template_info
= get_template_info (t
))
3368 && TI_ARGS (template_info
))
3369 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3374 /* Return the argument pack elements of T if T is a template argument pack,
3378 get_template_argument_pack_elems (const_tree t
)
3380 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3381 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3384 return ARGUMENT_PACK_ARGS (t
);
3387 /* True iff FN is a function representing a built-in variadic parameter
3391 builtin_pack_fn_p (tree fn
)
3394 || TREE_CODE (fn
) != FUNCTION_DECL
3395 || !DECL_IS_BUILTIN (fn
))
3398 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3404 /* True iff CALL is a call to a function representing a built-in variadic
3408 builtin_pack_call_p (tree call
)
3410 if (TREE_CODE (call
) != CALL_EXPR
)
3412 return builtin_pack_fn_p (CALL_EXPR_FN (call
));
3415 /* Return a TREE_VEC for the expansion of __integer_pack(HI). */
3418 expand_integer_pack (tree call
, tree args
, tsubst_flags_t complain
,
3421 tree ohi
= CALL_EXPR_ARG (call
, 0);
3422 tree hi
= tsubst_copy_and_build (ohi
, args
, complain
, in_decl
,
3423 false/*fn*/, true/*int_cst*/);
3425 if (value_dependent_expression_p (hi
))
3429 call
= copy_node (call
);
3430 CALL_EXPR_ARG (call
, 0) = hi
;
3432 tree ex
= make_pack_expansion (call
);
3433 tree vec
= make_tree_vec (1);
3434 TREE_VEC_ELT (vec
, 0) = ex
;
3439 hi
= cxx_constant_value (hi
);
3440 int len
= valid_constant_size_p (hi
) ? tree_to_shwi (hi
) : -1;
3442 /* Calculate the largest value of len that won't make the size of the vec
3443 overflow an int. The compiler will exceed resource limits long before
3444 this, but it seems a decent place to diagnose. */
3445 int max
= ((INT_MAX
- sizeof (tree_vec
)) / sizeof (tree
)) + 1;
3447 if (len
< 0 || len
> max
)
3449 if ((complain
& tf_error
)
3450 && hi
!= error_mark_node
)
3451 error ("argument to __integer_pack must be between 0 and %d", max
);
3452 return error_mark_node
;
3455 tree vec
= make_tree_vec (len
);
3457 for (int i
= 0; i
< len
; ++i
)
3458 TREE_VEC_ELT (vec
, i
) = size_int (i
);
3464 /* Return a TREE_VEC for the expansion of built-in template parameter pack
3468 expand_builtin_pack_call (tree call
, tree args
, tsubst_flags_t complain
,
3471 if (!builtin_pack_call_p (call
))
3474 tree fn
= CALL_EXPR_FN (call
);
3476 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3477 return expand_integer_pack (call
, args
, complain
, in_decl
);
3482 /* Structure used to track the progress of find_parameter_packs_r. */
3483 struct find_parameter_pack_data
3485 /* TREE_LIST that will contain all of the parameter packs found by
3487 tree
* parameter_packs
;
3489 /* Set of AST nodes that have been visited by the traversal. */
3490 hash_set
<tree
> *visited
;
3492 /* True iff we're making a type pack expansion. */
3493 bool type_pack_expansion_p
;
3496 /* Identifies all of the argument packs that occur in a template
3497 argument and appends them to the TREE_LIST inside DATA, which is a
3498 find_parameter_pack_data structure. This is a subroutine of
3499 make_pack_expansion and uses_parameter_packs. */
3501 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3504 struct find_parameter_pack_data
* ppd
=
3505 (struct find_parameter_pack_data
*)data
;
3506 bool parameter_pack_p
= false;
3508 /* Handle type aliases/typedefs. */
3509 if (TYPE_ALIAS_P (t
))
3511 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
3512 cp_walk_tree (&TI_ARGS (tinfo
),
3513 &find_parameter_packs_r
,
3519 /* Identify whether this is a parameter pack or not. */
3520 switch (TREE_CODE (t
))
3522 case TEMPLATE_PARM_INDEX
:
3523 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3524 parameter_pack_p
= true;
3527 case TEMPLATE_TYPE_PARM
:
3528 t
= TYPE_MAIN_VARIANT (t
);
3530 case TEMPLATE_TEMPLATE_PARM
:
3531 /* If the placeholder appears in the decl-specifier-seq of a function
3532 parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3533 is a pack expansion, the invented template parameter is a template
3535 if (ppd
->type_pack_expansion_p
&& is_auto (t
))
3536 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
3537 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3538 parameter_pack_p
= true;
3543 if (DECL_PACK_P (t
))
3545 /* We don't want to walk into the type of a PARM_DECL,
3546 because we don't want to see the type parameter pack. */
3548 parameter_pack_p
= true;
3552 /* Look through a lambda capture proxy to the field pack. */
3554 if (DECL_HAS_VALUE_EXPR_P (t
))
3556 tree v
= DECL_VALUE_EXPR (t
);
3558 &find_parameter_packs_r
,
3562 else if (variable_template_specialization_p (t
))
3564 cp_walk_tree (&DECL_TI_ARGS (t
),
3565 find_parameter_packs_r
,
3572 if (builtin_pack_call_p (t
))
3573 parameter_pack_p
= true;
3577 parameter_pack_p
= true;
3580 /* Not a parameter pack. */
3584 if (parameter_pack_p
)
3586 /* Add this parameter pack to the list. */
3587 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3591 cp_walk_tree (&TYPE_CONTEXT (t
),
3592 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3594 /* This switch statement will return immediately if we don't find a
3596 switch (TREE_CODE (t
))
3598 case TEMPLATE_PARM_INDEX
:
3601 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3602 /* Check the template itself. */
3603 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3604 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3605 /* Check the template arguments. */
3606 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3611 case TEMPLATE_TYPE_PARM
:
3612 case TEMPLATE_TEMPLATE_PARM
:
3619 if (TYPE_PTRMEMFUNC_P (t
))
3625 if (TYPE_TEMPLATE_INFO (t
))
3626 cp_walk_tree (&TYPE_TI_ARGS (t
),
3627 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3633 if (!DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
3638 cp_walk_tree (&TREE_TYPE (t
),
3639 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3643 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3648 case TYPE_PACK_EXPANSION
:
3649 case EXPR_PACK_EXPANSION
:
3654 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3659 case IDENTIFIER_NODE
:
3660 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3667 /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
3668 type_pack_expansion_p to false so that any placeholders
3669 within the expression don't get marked as parameter packs. */
3670 bool type_pack_expansion_p
= ppd
->type_pack_expansion_p
;
3671 ppd
->type_pack_expansion_p
= false;
3672 cp_walk_tree (&DECLTYPE_TYPE_EXPR (t
), &find_parameter_packs_r
,
3674 ppd
->type_pack_expansion_p
= type_pack_expansion_p
;
3686 /* Determines if the expression or type T uses any parameter packs. */
3688 uses_parameter_packs (tree t
)
3690 tree parameter_packs
= NULL_TREE
;
3691 struct find_parameter_pack_data ppd
;
3692 ppd
.parameter_packs
= ¶meter_packs
;
3693 ppd
.visited
= new hash_set
<tree
>;
3694 ppd
.type_pack_expansion_p
= false;
3695 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3697 return parameter_packs
!= NULL_TREE
;
3700 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3701 representation a base-class initializer into a parameter pack
3702 expansion. If all goes well, the resulting node will be an
3703 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3706 make_pack_expansion (tree arg
)
3709 tree parameter_packs
= NULL_TREE
;
3710 bool for_types
= false;
3711 struct find_parameter_pack_data ppd
;
3713 if (!arg
|| arg
== error_mark_node
)
3716 if (TREE_CODE (arg
) == TREE_LIST
&& TREE_PURPOSE (arg
))
3718 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3719 class initializer. In this case, the TREE_PURPOSE will be a
3720 _TYPE node (representing the base class expansion we're
3721 initializing) and the TREE_VALUE will be a TREE_LIST
3722 containing the initialization arguments.
3724 The resulting expansion looks somewhat different from most
3725 expansions. Rather than returning just one _EXPANSION, we
3726 return a TREE_LIST whose TREE_PURPOSE is a
3727 TYPE_PACK_EXPANSION containing the bases that will be
3728 initialized. The TREE_VALUE will be identical to the
3729 original TREE_VALUE, which is a list of arguments that will
3730 be passed to each base. We do not introduce any new pack
3731 expansion nodes into the TREE_VALUE (although it is possible
3732 that some already exist), because the TREE_PURPOSE and
3733 TREE_VALUE all need to be expanded together with the same
3734 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3735 resulting TREE_PURPOSE will mention the parameter packs in
3736 both the bases and the arguments to the bases. */
3739 tree parameter_packs
= NULL_TREE
;
3741 /* Determine which parameter packs will be used by the base
3743 ppd
.visited
= new hash_set
<tree
>;
3744 ppd
.parameter_packs
= ¶meter_packs
;
3745 ppd
.type_pack_expansion_p
= true;
3746 gcc_assert (TYPE_P (TREE_PURPOSE (arg
)));
3747 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3750 if (parameter_packs
== NULL_TREE
)
3752 error ("base initializer expansion %qT contains no parameter packs", arg
);
3754 return error_mark_node
;
3757 if (TREE_VALUE (arg
) != void_type_node
)
3759 /* Collect the sets of parameter packs used in each of the
3760 initialization arguments. */
3761 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3763 /* Determine which parameter packs will be expanded in this
3765 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3772 /* Create the pack expansion type for the base type. */
3773 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3774 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3775 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3777 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3778 they will rarely be compared to anything. */
3779 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3781 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3784 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3787 /* Build the PACK_EXPANSION_* node. */
3789 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3790 : make_node (EXPR_PACK_EXPANSION
);
3791 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3792 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3794 /* Propagate type and const-expression information. */
3795 TREE_TYPE (result
) = TREE_TYPE (arg
);
3796 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3797 /* Mark this read now, since the expansion might be length 0. */
3798 mark_exp_read (arg
);
3801 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3802 they will rarely be compared to anything. */
3803 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3805 /* Determine which parameter packs will be expanded. */
3806 ppd
.parameter_packs
= ¶meter_packs
;
3807 ppd
.visited
= new hash_set
<tree
>;
3808 ppd
.type_pack_expansion_p
= TYPE_P (arg
);
3809 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3812 /* Make sure we found some parameter packs. */
3813 if (parameter_packs
== NULL_TREE
)
3816 error ("expansion pattern %qT contains no argument packs", arg
);
3818 error ("expansion pattern %qE contains no argument packs", arg
);
3819 return error_mark_node
;
3821 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3823 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3828 /* Checks T for any "bare" parameter packs, which have not yet been
3829 expanded, and issues an error if any are found. This operation can
3830 only be done on full expressions or types (e.g., an expression
3831 statement, "if" condition, etc.), because we could have expressions like:
3833 foo(f(g(h(args)))...)
3835 where "args" is a parameter pack. check_for_bare_parameter_packs
3836 should not be called for the subexpressions args, h(args),
3837 g(h(args)), or f(g(h(args))), because we would produce erroneous
3840 Returns TRUE and emits an error if there were bare parameter packs,
3841 returns FALSE otherwise. */
3843 check_for_bare_parameter_packs (tree t
)
3845 tree parameter_packs
= NULL_TREE
;
3846 struct find_parameter_pack_data ppd
;
3848 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3851 if (TREE_CODE (t
) == TYPE_DECL
)
3854 ppd
.parameter_packs
= ¶meter_packs
;
3855 ppd
.visited
= new hash_set
<tree
>;
3856 ppd
.type_pack_expansion_p
= false;
3857 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3860 if (parameter_packs
)
3862 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
3863 error_at (loc
, "parameter packs not expanded with %<...%>:");
3864 while (parameter_packs
)
3866 tree pack
= TREE_VALUE (parameter_packs
);
3867 tree name
= NULL_TREE
;
3869 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3870 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3871 name
= TYPE_NAME (pack
);
3872 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3873 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3874 else if (TREE_CODE (pack
) == CALL_EXPR
)
3875 name
= DECL_NAME (CALL_EXPR_FN (pack
));
3877 name
= DECL_NAME (pack
);
3880 inform (loc
, " %qD", name
);
3882 inform (loc
, " <anonymous>");
3884 parameter_packs
= TREE_CHAIN (parameter_packs
);
3893 /* Expand any parameter packs that occur in the template arguments in
3896 expand_template_argument_pack (tree args
)
3898 if (args
== error_mark_node
)
3899 return error_mark_node
;
3901 tree result_args
= NULL_TREE
;
3902 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3903 int num_result_args
= -1;
3904 int non_default_args_count
= -1;
3906 /* First, determine if we need to expand anything, and the number of
3907 slots we'll need. */
3908 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3910 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3911 if (arg
== NULL_TREE
)
3913 if (ARGUMENT_PACK_P (arg
))
3915 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3916 if (num_result_args
< 0)
3917 num_result_args
= in_arg
+ num_packed
;
3919 num_result_args
+= num_packed
;
3923 if (num_result_args
>= 0)
3928 /* If no expansion is necessary, we're done. */
3929 if (num_result_args
< 0)
3932 /* Expand arguments. */
3933 result_args
= make_tree_vec (num_result_args
);
3934 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3935 non_default_args_count
=
3936 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3937 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3939 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3940 if (ARGUMENT_PACK_P (arg
))
3942 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3943 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3944 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3945 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3946 if (non_default_args_count
> 0)
3947 non_default_args_count
+= num_packed
- 1;
3951 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3955 if (non_default_args_count
>= 0)
3956 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3960 /* Checks if DECL shadows a template parameter.
3962 [temp.local]: A template-parameter shall not be redeclared within its
3963 scope (including nested scopes).
3965 Emits an error and returns TRUE if the DECL shadows a parameter,
3966 returns FALSE otherwise. */
3969 check_template_shadow (tree decl
)
3973 /* If we're not in a template, we can't possibly shadow a template
3975 if (!current_template_parms
)
3978 /* Figure out what we're shadowing. */
3979 decl
= OVL_FIRST (decl
);
3980 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
3982 /* If there's no previous binding for this name, we're not shadowing
3983 anything, let alone a template parameter. */
3987 /* If we're not shadowing a template parameter, we're done. Note
3988 that OLDDECL might be an OVERLOAD (or perhaps even an
3989 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3991 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
3994 /* We check for decl != olddecl to avoid bogus errors for using a
3995 name inside a class. We check TPFI to avoid duplicate errors for
3996 inline member templates. */
3998 || (DECL_TEMPLATE_PARM_P (decl
)
3999 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
4002 /* Don't complain about the injected class name, as we've already
4003 complained about the class itself. */
4004 if (DECL_SELF_REFERENCE_P (decl
))
4007 if (DECL_TEMPLATE_PARM_P (decl
))
4008 error ("declaration of template parameter %q+D shadows "
4009 "template parameter", decl
);
4011 error ("declaration of %q+#D shadows template parameter", decl
);
4012 inform (DECL_SOURCE_LOCATION (olddecl
),
4013 "template parameter %qD declared here", olddecl
);
4017 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
4018 ORIG_LEVEL, DECL, and TYPE. */
4021 build_template_parm_index (int index
,
4027 tree t
= make_node (TEMPLATE_PARM_INDEX
);
4028 TEMPLATE_PARM_IDX (t
) = index
;
4029 TEMPLATE_PARM_LEVEL (t
) = level
;
4030 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
4031 TEMPLATE_PARM_DECL (t
) = decl
;
4032 TREE_TYPE (t
) = type
;
4033 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
4034 TREE_READONLY (t
) = TREE_READONLY (decl
);
4039 /* Find the canonical type parameter for the given template type
4040 parameter. Returns the canonical type parameter, which may be TYPE
4041 if no such parameter existed. */
4044 canonical_type_parameter (tree type
)
4047 int idx
= TEMPLATE_TYPE_IDX (type
);
4048 if (!canonical_template_parms
)
4049 vec_alloc (canonical_template_parms
, idx
+ 1);
4051 if (canonical_template_parms
->length () <= (unsigned) idx
)
4052 vec_safe_grow_cleared (canonical_template_parms
, idx
+ 1);
4054 list
= (*canonical_template_parms
)[idx
];
4055 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
4056 list
= TREE_CHAIN (list
);
4059 return TREE_VALUE (list
);
4062 (*canonical_template_parms
)[idx
]
4063 = tree_cons (NULL_TREE
, type
, (*canonical_template_parms
)[idx
]);
4068 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
4069 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
4070 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
4071 new one is created. */
4074 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
4075 tsubst_flags_t complain
)
4077 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
4078 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
4079 != TEMPLATE_PARM_LEVEL (index
) - levels
)
4080 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
4082 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
4085 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
4086 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
4087 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
4088 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
4089 DECL_ARTIFICIAL (decl
) = 1;
4090 SET_DECL_TEMPLATE_PARM_P (decl
);
4092 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
4093 TEMPLATE_PARM_LEVEL (index
) - levels
,
4094 TEMPLATE_PARM_ORIG_LEVEL (index
),
4096 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
4097 TEMPLATE_PARM_PARAMETER_PACK (t
)
4098 = TEMPLATE_PARM_PARAMETER_PACK (index
);
4100 /* Template template parameters need this. */
4101 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4103 DECL_TEMPLATE_RESULT (decl
)
4104 = build_decl (DECL_SOURCE_LOCATION (decl
),
4105 TYPE_DECL
, DECL_NAME (decl
), type
);
4106 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (decl
)) = true;
4107 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
4108 (DECL_TEMPLATE_PARMS (orig_decl
), args
, complain
);
4112 return TEMPLATE_PARM_DESCENDANTS (index
);
4115 /* Process information from new template parameter PARM and append it
4116 to the LIST being built. This new parameter is a non-type
4117 parameter iff IS_NON_TYPE is true. This new parameter is a
4118 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4122 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
4123 bool is_non_type
, bool is_parameter_pack
)
4128 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
4129 tree defval
= TREE_PURPOSE (parm
);
4130 tree constr
= TREE_TYPE (parm
);
4134 tree p
= tree_last (list
);
4136 if (p
&& TREE_VALUE (p
) != error_mark_node
)
4139 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
4140 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
4142 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
4150 parm
= TREE_VALUE (parm
);
4152 SET_DECL_TEMPLATE_PARM_P (parm
);
4154 if (TREE_TYPE (parm
) != error_mark_node
)
4158 The top-level cv-qualifiers on the template-parameter are
4159 ignored when determining its type. */
4160 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
4161 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
4162 TREE_TYPE (parm
) = error_mark_node
;
4163 else if (uses_parameter_packs (TREE_TYPE (parm
))
4164 && !is_parameter_pack
4165 /* If we're in a nested template parameter list, the template
4166 template parameter could be a parameter pack. */
4167 && processing_template_parmlist
== 1)
4169 /* This template parameter is not a parameter pack, but it
4170 should be. Complain about "bare" parameter packs. */
4171 check_for_bare_parameter_packs (TREE_TYPE (parm
));
4173 /* Recover by calling this a parameter pack. */
4174 is_parameter_pack
= true;
4178 /* A template parameter is not modifiable. */
4179 TREE_CONSTANT (parm
) = 1;
4180 TREE_READONLY (parm
) = 1;
4181 decl
= build_decl (parm_loc
,
4182 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
4183 TREE_CONSTANT (decl
) = 1;
4184 TREE_READONLY (decl
) = 1;
4185 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
4186 = build_template_parm_index (idx
, processing_template_decl
,
4187 processing_template_decl
,
4188 decl
, TREE_TYPE (parm
));
4190 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
4191 = is_parameter_pack
;
4196 parm
= TREE_VALUE (TREE_VALUE (parm
));
4198 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
4200 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
4201 /* This is for distinguishing between real templates and template
4202 template parameters */
4203 TREE_TYPE (parm
) = t
;
4204 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
4209 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
4210 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4211 decl
= build_decl (parm_loc
,
4212 TYPE_DECL
, parm
, t
);
4215 TYPE_NAME (t
) = decl
;
4216 TYPE_STUB_DECL (t
) = decl
;
4218 TEMPLATE_TYPE_PARM_INDEX (t
)
4219 = build_template_parm_index (idx
, processing_template_decl
,
4220 processing_template_decl
,
4221 decl
, TREE_TYPE (parm
));
4222 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
4223 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
4225 DECL_ARTIFICIAL (decl
) = 1;
4226 SET_DECL_TEMPLATE_PARM_P (decl
);
4228 /* Build requirements for the type/template parameter.
4229 This must be done after SET_DECL_TEMPLATE_PARM_P or
4230 process_template_parm could fail. */
4231 tree reqs
= finish_shorthand_constraint (parm
, constr
);
4235 /* Build the parameter node linking the parameter declaration,
4236 its default argument (if any), and its constraints (if any). */
4237 parm
= build_tree_list (defval
, parm
);
4238 TEMPLATE_PARM_CONSTRAINTS (parm
) = reqs
;
4240 return chainon (list
, parm
);
4243 /* The end of a template parameter list has been reached. Process the
4244 tree list into a parameter vector, converting each parameter into a more
4245 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4249 end_template_parm_list (tree parms
)
4253 tree saved_parmlist
= make_tree_vec (list_length (parms
));
4255 /* Pop the dummy parameter level and add the real one. */
4256 current_template_parms
= TREE_CHAIN (current_template_parms
);
4258 current_template_parms
4259 = tree_cons (size_int (processing_template_decl
),
4260 saved_parmlist
, current_template_parms
);
4262 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
4264 next
= TREE_CHAIN (parm
);
4265 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
4266 TREE_CHAIN (parm
) = NULL_TREE
;
4269 --processing_template_parmlist
;
4271 return saved_parmlist
;
4274 // Explicitly indicate the end of the template parameter list. We assume
4275 // that the current template parameters have been constructed and/or
4276 // managed explicitly, as when creating new template template parameters
4277 // from a shorthand constraint.
4279 end_template_parm_list ()
4281 --processing_template_parmlist
;
4284 /* end_template_decl is called after a template declaration is seen. */
4287 end_template_decl (void)
4289 reset_specialization ();
4291 if (! processing_template_decl
)
4294 /* This matches the pushlevel in begin_template_parm_list. */
4297 --processing_template_decl
;
4298 current_template_parms
= TREE_CHAIN (current_template_parms
);
4301 /* Takes a TREE_LIST representing a template parameter and convert it
4302 into an argument suitable to be passed to the type substitution
4303 functions. Note that If the TREE_LIST contains an error_mark
4304 node, the returned argument is error_mark_node. */
4307 template_parm_to_arg (tree t
)
4311 || TREE_CODE (t
) != TREE_LIST
)
4314 if (error_operand_p (TREE_VALUE (t
)))
4315 return error_mark_node
;
4319 if (TREE_CODE (t
) == TYPE_DECL
4320 || TREE_CODE (t
) == TEMPLATE_DECL
)
4324 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
4326 /* Turn this argument into a TYPE_ARGUMENT_PACK
4327 with a single element, which expands T. */
4328 tree vec
= make_tree_vec (1);
4330 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4332 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4334 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
4335 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4340 t
= DECL_INITIAL (t
);
4342 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
4344 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4345 with a single element, which expands T. */
4346 tree vec
= make_tree_vec (1);
4348 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4350 t
= convert_from_reference (t
);
4351 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4353 t
= make_node (NONTYPE_ARGUMENT_PACK
);
4354 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4357 t
= convert_from_reference (t
);
4362 /* Given a single level of template parameters (a TREE_VEC), return it
4363 as a set of template arguments. */
4366 template_parms_level_to_args (tree parms
)
4368 tree a
= copy_node (parms
);
4369 TREE_TYPE (a
) = NULL_TREE
;
4370 for (int i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
4371 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
4374 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
4379 /* Given a set of template parameters, return them as a set of template
4380 arguments. The template parameters are represented as a TREE_VEC, in
4381 the form documented in cp-tree.h for template arguments. */
4384 template_parms_to_args (tree parms
)
4387 tree args
= NULL_TREE
;
4388 int length
= TMPL_PARMS_DEPTH (parms
);
4391 /* If there is only one level of template parameters, we do not
4392 create a TREE_VEC of TREE_VECs. Instead, we return a single
4393 TREE_VEC containing the arguments. */
4395 args
= make_tree_vec (length
);
4397 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
4399 tree a
= template_parms_level_to_args (TREE_VALUE (header
));
4402 TREE_VEC_ELT (args
, --l
) = a
;
4410 /* Within the declaration of a template, return the currently active
4411 template parameters as an argument TREE_VEC. */
4414 current_template_args (void)
4416 return template_parms_to_args (current_template_parms
);
4419 /* Update the declared TYPE by doing any lookups which were thought to be
4420 dependent, but are not now that we know the SCOPE of the declarator. */
4423 maybe_update_decl_type (tree orig_type
, tree scope
)
4425 tree type
= orig_type
;
4427 if (type
== NULL_TREE
)
4430 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4431 type
= TREE_TYPE (type
);
4433 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
4434 && dependent_type_p (type
)
4435 /* Don't bother building up the args in this case. */
4436 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
4438 /* tsubst in the args corresponding to the template parameters,
4439 including auto if present. Most things will be unchanged, but
4440 make_typename_type and tsubst_qualified_id will resolve
4441 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4442 tree args
= current_template_args ();
4443 tree auto_node
= type_uses_auto (type
);
4447 tree auto_vec
= make_tree_vec (1);
4448 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4449 args
= add_to_template_args (args
, auto_vec
);
4451 pushed
= push_scope (scope
);
4452 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4457 if (type
== error_mark_node
)
4460 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4462 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4465 type
= TYPE_NAME (type
);
4470 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4471 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4472 the new template is a member template. */
4475 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4477 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4478 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4479 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4480 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4481 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4486 struct template_parm_data
4488 /* The level of the template parameters we are currently
4492 /* The index of the specialization argument we are currently
4496 /* An array whose size is the number of template parameters. The
4497 elements are nonzero if the parameter has been used in any one
4498 of the arguments processed so far. */
4501 /* An array whose size is the number of template arguments. The
4502 elements are nonzero if the argument makes use of template
4503 parameters of this level. */
4504 int* arg_uses_template_parms
;
4507 /* Subroutine of push_template_decl used to see if each template
4508 parameter in a partial specialization is used in the explicit
4509 argument list. If T is of the LEVEL given in DATA (which is
4510 treated as a template_parm_data*), then DATA->PARMS is marked
4514 mark_template_parm (tree t
, void* data
)
4518 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4520 template_parm_level_and_index (t
, &level
, &idx
);
4522 if (level
== tpd
->level
)
4524 tpd
->parms
[idx
] = 1;
4525 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4528 /* In C++17 the type of a non-type argument is a deduced context. */
4529 if (cxx_dialect
>= cxx1z
4530 && TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4531 for_each_template_parm (TREE_TYPE (t
),
4532 &mark_template_parm
,
4535 /*include_nondeduced_p=*/false);
4537 /* Return zero so that for_each_template_parm will continue the
4538 traversal of the tree; we want to mark *every* template parm. */
4542 /* Process the partial specialization DECL. */
4545 process_partial_specialization (tree decl
)
4547 tree type
= TREE_TYPE (decl
);
4548 tree tinfo
= get_template_info (decl
);
4549 tree maintmpl
= TI_TEMPLATE (tinfo
);
4550 tree specargs
= TI_ARGS (tinfo
);
4551 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4552 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4555 int nargs
= TREE_VEC_LENGTH (inner_args
);
4558 bool did_error_intro
= false;
4559 struct template_parm_data tpd
;
4560 struct template_parm_data tpd2
;
4562 gcc_assert (current_template_parms
);
4564 /* A concept cannot be specialized. */
4565 if (flag_concepts
&& variable_concept_p (maintmpl
))
4567 error ("specialization of variable concept %q#D", maintmpl
);
4568 return error_mark_node
;
4571 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4572 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4574 /* We check that each of the template parameters given in the
4575 partial specialization is used in the argument list to the
4576 specialization. For example:
4578 template <class T> struct S;
4579 template <class T> struct S<T*>;
4581 The second declaration is OK because `T*' uses the template
4582 parameter T, whereas
4584 template <class T> struct S<int>;
4586 is no good. Even trickier is:
4597 The S2<T> declaration is actually invalid; it is a
4598 full-specialization. Of course,
4601 struct S2<T (*)(U)>;
4603 or some such would have been OK. */
4604 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4605 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4606 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4608 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4609 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4610 for (i
= 0; i
< nargs
; ++i
)
4612 tpd
.current_arg
= i
;
4613 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4614 &mark_template_parm
,
4617 /*include_nondeduced_p=*/false);
4619 for (i
= 0; i
< ntparms
; ++i
)
4620 if (tpd
.parms
[i
] == 0)
4622 /* One of the template parms was not used in a deduced context in the
4624 if (!did_error_intro
)
4626 error ("template parameters not deducible in "
4627 "partial specialization:");
4628 did_error_intro
= true;
4631 inform (input_location
, " %qD",
4632 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4635 if (did_error_intro
)
4636 return error_mark_node
;
4638 /* [temp.class.spec]
4640 The argument list of the specialization shall not be identical to
4641 the implicit argument list of the primary template. */
4643 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl
)));
4644 if (comp_template_args (inner_args
, INNERMOST_TEMPLATE_ARGS (main_args
))
4646 || !strictly_subsumes (current_template_constraints (),
4647 get_constraints (maintmpl
))))
4650 error ("partial specialization %q+D does not specialize "
4651 "any template arguments", decl
);
4653 error ("partial specialization %q+D does not specialize any "
4654 "template arguments and is not more constrained than", decl
);
4655 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4658 /* A partial specialization that replaces multiple parameters of the
4659 primary template with a pack expansion is less specialized for those
4661 if (nargs
< DECL_NTPARMS (maintmpl
))
4663 error ("partial specialization is not more specialized than the "
4664 "primary template because it replaces multiple parameters "
4665 "with a pack expansion");
4666 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4667 /* Avoid crash in process_partial_specialization. */
4671 /* If we aren't in a dependent class, we can actually try deduction. */
4672 else if (tpd
.level
== 1
4673 /* FIXME we should be able to handle a partial specialization of a
4674 partial instantiation, but currently we can't (c++/41727). */
4675 && TMPL_ARGS_DEPTH (specargs
) == 1
4676 && !get_partial_spec_bindings (maintmpl
, maintmpl
, specargs
))
4678 if (permerror (input_location
, "partial specialization %qD is not "
4679 "more specialized than", decl
))
4680 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template %qD",
4684 /* [temp.class.spec]
4686 A partially specialized non-type argument expression shall not
4687 involve template parameters of the partial specialization except
4688 when the argument expression is a simple identifier.
4690 The type of a template parameter corresponding to a specialized
4691 non-type argument shall not be dependent on a parameter of the
4694 Also, we verify that pack expansions only occur at the
4695 end of the argument list. */
4696 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4698 for (i
= 0; i
< nargs
; ++i
)
4700 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4701 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4702 tree packed_args
= NULL_TREE
;
4705 if (ARGUMENT_PACK_P (arg
))
4707 /* Extract the arguments from the argument pack. We'll be
4708 iterating over these in the following loop. */
4709 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4710 len
= TREE_VEC_LENGTH (packed_args
);
4713 for (j
= 0; j
< len
; j
++)
4716 /* Get the Jth argument in the parameter pack. */
4717 arg
= TREE_VEC_ELT (packed_args
, j
);
4719 if (PACK_EXPANSION_P (arg
))
4721 /* Pack expansions must come at the end of the
4723 if ((packed_args
&& j
< len
- 1)
4724 || (!packed_args
&& i
< nargs
- 1))
4726 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4727 error ("parameter pack argument %qE must be at the "
4728 "end of the template argument list", arg
);
4730 error ("parameter pack argument %qT must be at the "
4731 "end of the template argument list", arg
);
4735 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4736 /* We only care about the pattern. */
4737 arg
= PACK_EXPANSION_PATTERN (arg
);
4739 if (/* These first two lines are the `non-type' bit. */
4741 && TREE_CODE (arg
) != TEMPLATE_DECL
4742 /* This next two lines are the `argument expression is not just a
4743 simple identifier' condition and also the `specialized
4744 non-type argument' bit. */
4745 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4746 && !(REFERENCE_REF_P (arg
)
4747 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4749 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4750 || (packed_args
&& uses_template_parms (arg
)))
4751 error ("template argument %qE involves template parameter(s)",
4755 /* Look at the corresponding template parameter,
4756 marking which template parameters its type depends
4758 tree type
= TREE_TYPE (parm
);
4762 /* We haven't yet initialized TPD2. Do so now. */
4763 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4764 /* The number of parameters here is the number in the
4765 main template, which, as checked in the assertion
4767 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4769 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4772 /* Mark the template parameters. But this time, we're
4773 looking for the template parameters of the main
4774 template, not in the specialization. */
4775 tpd2
.current_arg
= i
;
4776 tpd2
.arg_uses_template_parms
[i
] = 0;
4777 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4778 for_each_template_parm (type
,
4779 &mark_template_parm
,
4782 /*include_nondeduced_p=*/false);
4784 if (tpd2
.arg_uses_template_parms
[i
])
4786 /* The type depended on some template parameters.
4787 If they are fully specialized in the
4788 specialization, that's OK. */
4791 for (j
= 0; j
< nargs
; ++j
)
4792 if (tpd2
.parms
[j
] != 0
4793 && tpd
.arg_uses_template_parms
[j
])
4796 error_n (input_location
, count
,
4797 "type %qT of template argument %qE depends "
4798 "on a template parameter",
4799 "type %qT of template argument %qE depends "
4800 "on template parameters",
4809 /* We should only get here once. */
4810 if (TREE_CODE (decl
) == TYPE_DECL
)
4811 gcc_assert (!COMPLETE_TYPE_P (type
));
4813 // Build the template decl.
4814 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4815 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4816 TREE_TYPE (tmpl
) = type
;
4817 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4818 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4819 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4820 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4822 /* Give template template parms a DECL_CONTEXT of the template
4823 for which they are a parameter. */
4824 for (i
= 0; i
< ntparms
; ++i
)
4826 tree parm
= TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
));
4827 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
4828 DECL_CONTEXT (parm
) = tmpl
;
4832 /* We didn't register this in check_explicit_specialization so we could
4833 wait until the constraints were set. */
4834 decl
= register_specialization (decl
, maintmpl
, specargs
, false, 0);
4836 associate_classtype_constraints (type
);
4838 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4839 = tree_cons (specargs
, tmpl
,
4840 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4841 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4843 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4844 inst
= TREE_CHAIN (inst
))
4846 tree instance
= TREE_VALUE (inst
);
4847 if (TYPE_P (instance
)
4848 ? (COMPLETE_TYPE_P (instance
)
4849 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance
))
4850 : DECL_TEMPLATE_INSTANTIATION (instance
))
4852 tree spec
= most_specialized_partial_spec (instance
, tf_none
);
4853 tree inst_decl
= (DECL_P (instance
)
4854 ? instance
: TYPE_NAME (instance
));
4857 else if (spec
== error_mark_node
)
4858 permerror (input_location
,
4859 "declaration of %qD ambiguates earlier template "
4860 "instantiation for %qD", decl
, inst_decl
);
4861 else if (TREE_VALUE (spec
) == tmpl
)
4862 permerror (input_location
,
4863 "partial specialization of %qD after instantiation "
4864 "of %qD", decl
, inst_decl
);
4871 /* PARM is a template parameter of some form; return the corresponding
4872 TEMPLATE_PARM_INDEX. */
4875 get_template_parm_index (tree parm
)
4877 if (TREE_CODE (parm
) == PARM_DECL
4878 || TREE_CODE (parm
) == CONST_DECL
)
4879 parm
= DECL_INITIAL (parm
);
4880 else if (TREE_CODE (parm
) == TYPE_DECL
4881 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4882 parm
= TREE_TYPE (parm
);
4883 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4884 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
4885 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4886 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4887 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4891 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4892 parameter packs used by the template parameter PARM. */
4895 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4897 /* A type parm can't refer to another parm. */
4898 if (TREE_CODE (parm
) == TYPE_DECL
)
4900 else if (TREE_CODE (parm
) == PARM_DECL
)
4902 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4907 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4909 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4910 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4911 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4914 /* PARM is a template parameter pack. Return any parameter packs used in
4915 its type or the type of any of its template parameters. If there are
4916 any such packs, it will be instantiated into a fixed template parameter
4917 list by partial instantiation rather than be fully deduced. */
4920 fixed_parameter_pack_p (tree parm
)
4922 /* This can only be true in a member template. */
4923 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4925 /* This can only be true for a parameter pack. */
4926 if (!template_parameter_pack_p (parm
))
4928 /* A type parm can't refer to another parm. */
4929 if (TREE_CODE (parm
) == TYPE_DECL
)
4932 tree parameter_packs
= NULL_TREE
;
4933 struct find_parameter_pack_data ppd
;
4934 ppd
.parameter_packs
= ¶meter_packs
;
4935 ppd
.visited
= new hash_set
<tree
>;
4936 ppd
.type_pack_expansion_p
= false;
4938 fixed_parameter_pack_p_1 (parm
, &ppd
);
4941 return parameter_packs
;
4944 /* Check that a template declaration's use of default arguments and
4945 parameter packs is not invalid. Here, PARMS are the template
4946 parameters. IS_PRIMARY is true if DECL is the thing declared by
4947 a primary template. IS_PARTIAL is true if DECL is a partial
4950 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4951 declaration (but not a definition); 1 indicates a declaration, 2
4952 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4953 emitted for extraneous default arguments.
4955 Returns TRUE if there were no errors found, FALSE otherwise. */
4958 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4959 bool is_partial
, int is_friend_decl
)
4962 int last_level_to_check
;
4964 bool no_errors
= true;
4968 A default template-argument shall not be specified in a
4969 function template declaration or a function template definition, nor
4970 in the template-parameter-list of the definition of a member of a
4973 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
4974 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
4975 /* You can't have a function template declaration in a local
4976 scope, nor you can you define a member of a class template in a
4980 if ((TREE_CODE (decl
) == TYPE_DECL
4982 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4983 || (TREE_CODE (decl
) == FUNCTION_DECL
4984 && LAMBDA_FUNCTION_P (decl
)))
4985 /* A lambda doesn't have an explicit declaration; don't complain
4986 about the parms of the enclosing class. */
4989 if (current_class_type
4990 && !TYPE_BEING_DEFINED (current_class_type
)
4991 && DECL_LANG_SPECIFIC (decl
)
4992 && DECL_DECLARES_FUNCTION_P (decl
)
4993 /* If this is either a friend defined in the scope of the class
4994 or a member function. */
4995 && (DECL_FUNCTION_MEMBER_P (decl
)
4996 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4997 : DECL_FRIEND_CONTEXT (decl
)
4998 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
5000 /* And, if it was a member function, it really was defined in
5001 the scope of the class. */
5002 && (!DECL_FUNCTION_MEMBER_P (decl
)
5003 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
5004 /* We already checked these parameters when the template was
5005 declared, so there's no need to do it again now. This function
5006 was defined in class scope, but we're processing its body now
5007 that the class is complete. */
5010 /* Core issue 226 (C++0x only): the following only applies to class
5013 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
5017 If a template-parameter has a default template-argument, all
5018 subsequent template-parameters shall have a default
5019 template-argument supplied. */
5020 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
5022 tree inner_parms
= TREE_VALUE (parm_level
);
5023 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
5024 int seen_def_arg_p
= 0;
5027 for (i
= 0; i
< ntparms
; ++i
)
5029 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
5031 if (parm
== error_mark_node
)
5034 if (TREE_PURPOSE (parm
))
5036 else if (seen_def_arg_p
5037 && !template_parameter_pack_p (TREE_VALUE (parm
)))
5039 error ("no default argument for %qD", TREE_VALUE (parm
));
5040 /* For better subsequent error-recovery, we indicate that
5041 there should have been a default argument. */
5042 TREE_PURPOSE (parm
) = error_mark_node
;
5045 else if (!is_partial
5047 /* Don't complain about an enclosing partial
5049 && parm_level
== parms
5050 && TREE_CODE (decl
) == TYPE_DECL
5052 && template_parameter_pack_p (TREE_VALUE (parm
))
5053 /* A fixed parameter pack will be partially
5054 instantiated into a fixed length list. */
5055 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
5057 /* A primary class template can only have one
5058 parameter pack, at the end of the template
5061 error ("parameter pack %q+D must be at the end of the"
5062 " template parameter list", TREE_VALUE (parm
));
5064 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
5072 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
5076 /* For an ordinary class template, default template arguments are
5077 allowed at the innermost level, e.g.:
5078 template <class T = int>
5080 but, in a partial specialization, they're not allowed even
5081 there, as we have in [temp.class.spec]:
5083 The template parameter list of a specialization shall not
5084 contain default template argument values.
5086 So, for a partial specialization, or for a function template
5087 (in C++98/C++03), we look at all of them. */
5090 /* But, for a primary class template that is not a partial
5091 specialization we look at all template parameters except the
5093 parms
= TREE_CHAIN (parms
);
5095 /* Figure out what error message to issue. */
5096 if (is_friend_decl
== 2)
5097 msg
= G_("default template arguments may not be used in function template "
5098 "friend re-declaration");
5099 else if (is_friend_decl
)
5100 msg
= G_("default template arguments may not be used in function template "
5101 "friend declarations");
5102 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
5103 msg
= G_("default template arguments may not be used in function templates "
5104 "without -std=c++11 or -std=gnu++11");
5105 else if (is_partial
)
5106 msg
= G_("default template arguments may not be used in "
5107 "partial specializations");
5108 else if (current_class_type
&& CLASSTYPE_IS_TEMPLATE (current_class_type
))
5109 msg
= G_("default argument for template parameter for class enclosing %qD");
5111 /* Per [temp.param]/9, "A default template-argument shall not be
5112 specified in the template-parameter-lists of the definition of
5113 a member of a class template that appears outside of the member's
5114 class.", thus if we aren't handling a member of a class template
5115 there is no need to examine the parameters. */
5118 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
5119 /* If we're inside a class definition, there's no need to
5120 examine the parameters to the class itself. On the one
5121 hand, they will be checked when the class is defined, and,
5122 on the other, default arguments are valid in things like:
5123 template <class T = double>
5124 struct S { template <class U> void f(U); };
5125 Here the default argument for `S' has no bearing on the
5126 declaration of `f'. */
5127 last_level_to_check
= template_class_depth (current_class_type
) + 1;
5129 /* Check everything. */
5130 last_level_to_check
= 0;
5132 for (parm_level
= parms
;
5133 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
5134 parm_level
= TREE_CHAIN (parm_level
))
5136 tree inner_parms
= TREE_VALUE (parm_level
);
5140 ntparms
= TREE_VEC_LENGTH (inner_parms
);
5141 for (i
= 0; i
< ntparms
; ++i
)
5143 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
5146 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
5151 if (is_friend_decl
== 2)
5158 /* Clear out the default argument so that we are not
5160 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
5164 /* At this point, if we're still interested in issuing messages,
5165 they must apply to classes surrounding the object declared. */
5167 msg
= G_("default argument for template parameter for class "
5174 /* Worker for push_template_decl_real, called via
5175 for_each_template_parm. DATA is really an int, indicating the
5176 level of the parameters we are interested in. If T is a template
5177 parameter of that level, return nonzero. */
5180 template_parm_this_level_p (tree t
, void* data
)
5182 int this_level
= *(int *)data
;
5185 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5186 level
= TEMPLATE_PARM_LEVEL (t
);
5188 level
= TEMPLATE_TYPE_LEVEL (t
);
5189 return level
== this_level
;
5192 /* Worker for uses_outer_template_parms, called via for_each_template_parm.
5193 DATA is really an int, indicating the innermost outer level of parameters.
5194 If T is a template parameter of that level or further out, return
5198 template_parm_outer_level (tree t
, void *data
)
5200 int this_level
= *(int *)data
;
5203 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5204 level
= TEMPLATE_PARM_LEVEL (t
);
5206 level
= TEMPLATE_TYPE_LEVEL (t
);
5207 return level
<= this_level
;
5210 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5211 parameters given by current_template_args, or reuses a
5212 previously existing one, if appropriate. Returns the DECL, or an
5213 equivalent one, if it is replaced via a call to duplicate_decls.
5215 If IS_FRIEND is true, DECL is a friend declaration. */
5218 push_template_decl_real (tree decl
, bool is_friend
)
5226 int new_template_p
= 0;
5227 /* True if the template is a member template, in the sense of
5229 bool member_template_p
= false;
5231 if (decl
== error_mark_node
|| !current_template_parms
)
5232 return error_mark_node
;
5234 /* See if this is a partial specialization. */
5235 is_partial
= ((DECL_IMPLICIT_TYPEDEF_P (decl
)
5236 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
5237 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
5239 && DECL_LANG_SPECIFIC (decl
)
5240 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5241 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
))));
5243 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
5247 /* For a friend, we want the context of the friend function, not
5248 the type of which it is a friend. */
5249 ctx
= CP_DECL_CONTEXT (decl
);
5250 else if (CP_DECL_CONTEXT (decl
)
5251 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
5252 /* In the case of a virtual function, we want the class in which
5254 ctx
= CP_DECL_CONTEXT (decl
);
5256 /* Otherwise, if we're currently defining some class, the DECL
5257 is assumed to be a member of the class. */
5258 ctx
= current_scope ();
5260 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5263 if (!DECL_CONTEXT (decl
))
5264 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
5266 /* See if this is a primary template. */
5267 if (is_friend
&& ctx
5268 && uses_template_parms_level (ctx
, processing_template_decl
))
5269 /* A friend template that specifies a class context, i.e.
5270 template <typename T> friend void A<T>::f();
5273 else if (TREE_CODE (decl
) == TYPE_DECL
5274 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5277 is_primary
= template_parm_scope_p ();
5281 warning (OPT_Wtemplates
, "template %qD declared", decl
);
5283 if (DECL_CLASS_SCOPE_P (decl
))
5284 member_template_p
= true;
5285 if (TREE_CODE (decl
) == TYPE_DECL
5286 && anon_aggrname_p (DECL_NAME (decl
)))
5288 error ("template class without a name");
5289 return error_mark_node
;
5291 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
5293 if (member_template_p
)
5295 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
5296 error ("member template %qD may not have virt-specifiers", decl
);
5298 if (DECL_DESTRUCTOR_P (decl
))
5302 A destructor shall not be a member template. */
5303 error ("destructor %qD declared as member template", decl
);
5304 return error_mark_node
;
5306 if (IDENTIFIER_NEWDEL_OP_P (DECL_NAME (decl
))
5307 && (!prototype_p (TREE_TYPE (decl
))
5308 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
5309 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5310 || (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5311 == void_list_node
)))
5313 /* [basic.stc.dynamic.allocation]
5315 An allocation function can be a function
5316 template. ... Template allocation functions shall
5317 have two or more parameters. */
5318 error ("invalid template declaration of %qD", decl
);
5319 return error_mark_node
;
5322 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5323 && CLASS_TYPE_P (TREE_TYPE (decl
)))
5325 /* Class template, set TEMPLATE_TYPE_PARM_FOR_CLASS. */
5326 tree parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
5327 for (int i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
5329 tree t
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5330 if (TREE_CODE (t
) == TYPE_DECL
)
5332 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
5333 TEMPLATE_TYPE_PARM_FOR_CLASS (t
) = true;
5336 else if (TREE_CODE (decl
) == TYPE_DECL
5337 && TYPE_DECL_ALIAS_P (decl
))
5338 /* alias-declaration */
5339 gcc_assert (!DECL_ARTIFICIAL (decl
));
5340 else if (VAR_P (decl
))
5341 /* C++14 variable template. */;
5344 error ("template declaration of %q#D", decl
);
5345 return error_mark_node
;
5349 /* Check to see that the rules regarding the use of default
5350 arguments are not being violated. */
5351 check_default_tmpl_args (decl
, current_template_parms
,
5352 is_primary
, is_partial
, /*is_friend_decl=*/0);
5354 /* Ensure that there are no parameter packs in the type of this
5355 declaration that have not been expanded. */
5356 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5358 /* Check each of the arguments individually to see if there are
5359 any bare parameter packs. */
5360 tree type
= TREE_TYPE (decl
);
5361 tree arg
= DECL_ARGUMENTS (decl
);
5362 tree argtype
= TYPE_ARG_TYPES (type
);
5364 while (arg
&& argtype
)
5366 if (!DECL_PACK_P (arg
)
5367 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
5369 /* This is a PARM_DECL that contains unexpanded parameter
5370 packs. We have already complained about this in the
5371 check_for_bare_parameter_packs call, so just replace
5372 these types with ERROR_MARK_NODE. */
5373 TREE_TYPE (arg
) = error_mark_node
;
5374 TREE_VALUE (argtype
) = error_mark_node
;
5377 arg
= DECL_CHAIN (arg
);
5378 argtype
= TREE_CHAIN (argtype
);
5381 /* Check for bare parameter packs in the return type and the
5382 exception specifiers. */
5383 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
5384 /* Errors were already issued, set return type to int
5385 as the frontend doesn't expect error_mark_node as
5387 TREE_TYPE (type
) = integer_type_node
;
5388 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
5389 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
5391 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
5392 && TYPE_DECL_ALIAS_P (decl
))
5393 ? DECL_ORIGINAL_TYPE (decl
)
5394 : TREE_TYPE (decl
)))
5396 TREE_TYPE (decl
) = error_mark_node
;
5397 return error_mark_node
;
5401 return process_partial_specialization (decl
);
5403 args
= current_template_args ();
5406 || TREE_CODE (ctx
) == FUNCTION_DECL
5407 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
5408 || (TREE_CODE (decl
) == TYPE_DECL
5409 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5410 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
5412 if (DECL_LANG_SPECIFIC (decl
)
5413 && DECL_TEMPLATE_INFO (decl
)
5414 && DECL_TI_TEMPLATE (decl
))
5415 tmpl
= DECL_TI_TEMPLATE (decl
);
5416 /* If DECL is a TYPE_DECL for a class-template, then there won't
5417 be DECL_LANG_SPECIFIC. The information equivalent to
5418 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5419 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5420 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
5421 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
5423 /* Since a template declaration already existed for this
5424 class-type, we must be redeclaring it here. Make sure
5425 that the redeclaration is valid. */
5426 redeclare_class_template (TREE_TYPE (decl
),
5427 current_template_parms
,
5428 current_template_constraints ());
5429 /* We don't need to create a new TEMPLATE_DECL; just use the
5430 one we already had. */
5431 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
5435 tmpl
= build_template_decl (decl
, current_template_parms
,
5439 if (DECL_LANG_SPECIFIC (decl
)
5440 && DECL_TEMPLATE_SPECIALIZATION (decl
))
5442 /* A specialization of a member template of a template
5444 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5445 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
5446 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
5452 tree a
, t
, current
, parms
;
5454 tree tinfo
= get_template_info (decl
);
5458 error ("template definition of non-template %q#D", decl
);
5459 return error_mark_node
;
5462 tmpl
= TI_TEMPLATE (tinfo
);
5464 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
5465 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
5466 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5467 && DECL_MEMBER_TEMPLATE_P (tmpl
))
5471 /* The declaration is a specialization of a member
5472 template, declared outside the class. Therefore, the
5473 innermost template arguments will be NULL, so we
5474 replace them with the arguments determined by the
5475 earlier call to check_explicit_specialization. */
5476 args
= DECL_TI_ARGS (decl
);
5479 = build_template_decl (decl
, current_template_parms
,
5481 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
5482 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
5483 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
5484 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
5485 DECL_TEMPLATE_INFO (new_tmpl
)
5486 = build_template_info (tmpl
, args
);
5488 register_specialization (new_tmpl
,
5489 most_general_template (tmpl
),
5495 /* Make sure the template headers we got make sense. */
5497 parms
= DECL_TEMPLATE_PARMS (tmpl
);
5498 i
= TMPL_PARMS_DEPTH (parms
);
5499 if (TMPL_ARGS_DEPTH (args
) != i
)
5501 error ("expected %d levels of template parms for %q#D, got %d",
5502 i
, decl
, TMPL_ARGS_DEPTH (args
));
5503 DECL_INTERFACE_KNOWN (decl
) = 1;
5504 return error_mark_node
;
5507 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
5509 a
= TMPL_ARGS_LEVEL (args
, i
);
5510 t
= INNERMOST_TEMPLATE_PARMS (parms
);
5512 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
5514 if (current
== decl
)
5515 error ("got %d template parameters for %q#D",
5516 TREE_VEC_LENGTH (a
), decl
);
5518 error ("got %d template parameters for %q#T",
5519 TREE_VEC_LENGTH (a
), current
);
5520 error (" but %d required", TREE_VEC_LENGTH (t
));
5521 /* Avoid crash in import_export_decl. */
5522 DECL_INTERFACE_KNOWN (decl
) = 1;
5523 return error_mark_node
;
5526 if (current
== decl
)
5528 else if (current
== NULL_TREE
)
5529 /* Can happen in erroneous input. */
5532 current
= get_containing_scope (current
);
5535 /* Check that the parms are used in the appropriate qualifying scopes
5536 in the declarator. */
5537 if (!comp_template_args
5539 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
5542 template arguments to %qD do not match original template %qD",
5543 decl
, DECL_TEMPLATE_RESULT (tmpl
));
5544 if (!uses_template_parms (TI_ARGS (tinfo
)))
5545 inform (input_location
, "use template<> for an explicit specialization");
5546 /* Avoid crash in import_export_decl. */
5547 DECL_INTERFACE_KNOWN (decl
) = 1;
5548 return error_mark_node
;
5552 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5553 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5555 /* Push template declarations for global functions and types. Note
5556 that we do not try to push a global template friend declared in a
5557 template class; such a thing may well depend on the template
5558 parameters of the class. */
5559 if (new_template_p
&& !ctx
5560 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5562 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5563 if (tmpl
== error_mark_node
)
5564 return error_mark_node
;
5566 /* Hide template friend classes that haven't been declared yet. */
5567 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5569 DECL_ANTICIPATED (tmpl
) = 1;
5570 DECL_FRIEND_P (tmpl
) = 1;
5576 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5579 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5580 if (DECL_CONV_FN_P (tmpl
))
5582 int depth
= TMPL_PARMS_DEPTH (parms
);
5584 /* It is a conversion operator. See if the type converted to
5585 depends on innermost template operands. */
5587 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
5589 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
5592 /* Give template template parms a DECL_CONTEXT of the template
5593 for which they are a parameter. */
5594 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5595 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5597 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5598 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5599 DECL_CONTEXT (parm
) = tmpl
;
5602 if (TREE_CODE (decl
) == TYPE_DECL
5603 && TYPE_DECL_ALIAS_P (decl
)
5604 && complex_alias_template_p (tmpl
))
5605 TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl
) = true;
5608 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5609 back to its most general template. If TMPL is a specialization,
5610 ARGS may only have the innermost set of arguments. Add the missing
5611 argument levels if necessary. */
5612 if (DECL_TEMPLATE_INFO (tmpl
))
5613 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5615 info
= build_template_info (tmpl
, args
);
5617 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5618 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5622 retrofit_lang_decl (decl
);
5623 if (DECL_LANG_SPECIFIC (decl
))
5624 DECL_TEMPLATE_INFO (decl
) = info
;
5627 if (flag_implicit_templates
5629 && TREE_PUBLIC (decl
)
5630 && VAR_OR_FUNCTION_DECL_P (decl
))
5631 /* Set DECL_COMDAT on template instantiations; if we force
5632 them to be emitted by explicit instantiation or -frepo,
5633 mark_needed will tell cgraph to do the right thing. */
5634 DECL_COMDAT (decl
) = true;
5636 return DECL_TEMPLATE_RESULT (tmpl
);
5640 push_template_decl (tree decl
)
5642 return push_template_decl_real (decl
, false);
5645 /* FN is an inheriting constructor that inherits from the constructor
5646 template INHERITED; turn FN into a constructor template with a matching
5650 add_inherited_template_parms (tree fn
, tree inherited
)
5653 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5654 inner_parms
= copy_node (inner_parms
);
5656 = tree_cons (size_int (processing_template_decl
+ 1),
5657 inner_parms
, current_template_parms
);
5658 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5659 tree args
= template_parms_to_args (parms
);
5660 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5661 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5662 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5663 DECL_ARTIFICIAL (tmpl
) = true;
5664 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5668 /* Called when a class template TYPE is redeclared with the indicated
5669 template PARMS, e.g.:
5671 template <class T> struct S;
5672 template <class T> struct S {}; */
5675 redeclare_class_template (tree type
, tree parms
, tree cons
)
5681 if (!TYPE_TEMPLATE_INFO (type
))
5683 error ("%qT is not a template type", type
);
5687 tmpl
= TYPE_TI_TEMPLATE (type
);
5688 if (!PRIMARY_TEMPLATE_P (tmpl
))
5689 /* The type is nested in some template class. Nothing to worry
5690 about here; there are no new template parameters for the nested
5696 error ("template specifiers not specified in declaration of %qD",
5701 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5702 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5704 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5706 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5707 "redeclared with %d template parameter",
5708 "redeclared with %d template parameters",
5709 TREE_VEC_LENGTH (parms
));
5710 inform_n (DECL_SOURCE_LOCATION (tmpl
), TREE_VEC_LENGTH (tmpl_parms
),
5711 "previous declaration %qD used %d template parameter",
5712 "previous declaration %qD used %d template parameters",
5713 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5717 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5724 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5725 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5728 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5729 if (error_operand_p (tmpl_parm
))
5732 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5733 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5734 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5736 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5738 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5739 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5740 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5741 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5742 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5743 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5744 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5745 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5746 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5748 error ("template parameter %q+#D", tmpl_parm
);
5749 error ("redeclared here as %q#D", parm
);
5753 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5755 /* We have in [temp.param]:
5757 A template-parameter may not be given default arguments
5758 by two different declarations in the same scope. */
5759 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5760 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5761 "original definition appeared here");
5765 if (parm_default
!= NULL_TREE
)
5766 /* Update the previous template parameters (which are the ones
5767 that will really count) with the new default value. */
5768 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5769 else if (tmpl_default
!= NULL_TREE
)
5770 /* Update the new parameters, too; they'll be used as the
5771 parameters for any members. */
5772 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5774 /* Give each template template parm in this redeclaration a
5775 DECL_CONTEXT of the template for which they are a parameter. */
5776 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5778 gcc_assert (DECL_CONTEXT (parm
) == NULL_TREE
);
5779 DECL_CONTEXT (parm
) = tmpl
;
5782 if (TREE_CODE (parm
) == TYPE_DECL
)
5783 TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (parm
)) = true;
5786 // Cannot redeclare a class template with a different set of constraints.
5787 if (!equivalent_constraints (get_constraints (tmpl
), cons
))
5789 error_at (input_location
, "redeclaration %q#D with different "
5790 "constraints", tmpl
);
5791 inform (DECL_SOURCE_LOCATION (tmpl
),
5792 "original declaration appeared here");
5798 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5799 to be used when the caller has already checked
5800 (processing_template_decl
5801 && !instantiation_dependent_expression_p (expr)
5802 && potential_constant_expression (expr))
5803 and cleared processing_template_decl. */
5806 instantiate_non_dependent_expr_internal (tree expr
, tsubst_flags_t complain
)
5808 return tsubst_copy_and_build (expr
,
5811 /*in_decl=*/NULL_TREE
,
5812 /*function_p=*/false,
5813 /*integral_constant_expression_p=*/true);
5816 /* Simplify EXPR if it is a non-dependent expression. Returns the
5817 (possibly simplified) expression. */
5820 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5822 if (expr
== NULL_TREE
)
5825 /* If we're in a template, but EXPR isn't value dependent, simplify
5826 it. We're supposed to treat:
5828 template <typename T> void f(T[1 + 1]);
5829 template <typename T> void f(T[2]);
5831 as two declarations of the same function, for example. */
5832 if (processing_template_decl
5833 && potential_nondependent_constant_expression (expr
))
5835 processing_template_decl_sentinel s
;
5836 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
5842 instantiate_non_dependent_expr (tree expr
)
5844 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
5847 /* Like instantiate_non_dependent_expr, but return NULL_TREE rather than
5848 an uninstantiated expression. */
5851 instantiate_non_dependent_or_null (tree expr
)
5853 if (expr
== NULL_TREE
)
5855 if (processing_template_decl
)
5857 if (!potential_nondependent_constant_expression (expr
))
5861 processing_template_decl_sentinel s
;
5862 expr
= instantiate_non_dependent_expr_internal (expr
, tf_error
);
5868 /* True iff T is a specialization of a variable template. */
5871 variable_template_specialization_p (tree t
)
5873 if (!VAR_P (t
) || !DECL_LANG_SPECIFIC (t
) || !DECL_TEMPLATE_INFO (t
))
5875 tree tmpl
= DECL_TI_TEMPLATE (t
);
5876 return variable_template_p (tmpl
);
5879 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5880 template declaration, or a TYPE_DECL for an alias declaration. */
5883 alias_type_or_template_p (tree t
)
5887 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5890 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5891 || DECL_ALIAS_TEMPLATE_P (t
));
5894 /* Return TRUE iff T is a specialization of an alias template. */
5897 alias_template_specialization_p (const_tree t
)
5899 /* It's an alias template specialization if it's an alias and its
5900 TYPE_NAME is a specialization of a primary template. */
5901 if (TYPE_ALIAS_P (t
))
5902 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
5903 return PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
));
5908 /* An alias template is complex from a SFINAE perspective if a template-id
5909 using that alias can be ill-formed when the expansion is not, as with
5910 the void_t template. We determine this by checking whether the
5911 expansion for the alias template uses all its template parameters. */
5913 struct uses_all_template_parms_data
5920 uses_all_template_parms_r (tree t
, void *data_
)
5922 struct uses_all_template_parms_data
&data
5923 = *(struct uses_all_template_parms_data
*)data_
;
5924 tree idx
= get_template_parm_index (t
);
5926 if (TEMPLATE_PARM_LEVEL (idx
) == data
.level
)
5927 data
.seen
[TEMPLATE_PARM_IDX (idx
)] = true;
5932 complex_alias_template_p (const_tree tmpl
)
5934 struct uses_all_template_parms_data data
;
5935 tree pat
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5936 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5937 data
.level
= TMPL_PARMS_DEPTH (parms
);
5938 int len
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms
));
5939 data
.seen
= XALLOCAVEC (bool, len
);
5940 for (int i
= 0; i
< len
; ++i
)
5941 data
.seen
[i
] = false;
5943 for_each_template_parm (pat
, uses_all_template_parms_r
, &data
, NULL
, true);
5944 for (int i
= 0; i
< len
; ++i
)
5950 /* Return TRUE iff T is a specialization of a complex alias template with
5951 dependent template-arguments. */
5954 dependent_alias_template_spec_p (const_tree t
)
5956 if (!alias_template_specialization_p (t
))
5959 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
);
5960 if (!TEMPLATE_DECL_COMPLEX_ALIAS_P (TI_TEMPLATE (tinfo
)))
5963 tree args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
));
5964 if (!any_dependent_template_arguments_p (args
))
5970 /* Return the number of innermost template parameters in TMPL. */
5973 num_innermost_template_parms (tree tmpl
)
5975 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5976 return TREE_VEC_LENGTH (parms
);
5979 /* Return either TMPL or another template that it is equivalent to under DR
5980 1286: An alias that just changes the name of a template is equivalent to
5981 the other template. */
5984 get_underlying_template (tree tmpl
)
5986 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5987 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5989 /* Determine if the alias is equivalent to an underlying template. */
5990 tree orig_type
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5991 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (orig_type
);
5995 tree underlying
= TI_TEMPLATE (tinfo
);
5996 if (!PRIMARY_TEMPLATE_P (underlying
)
5997 || (num_innermost_template_parms (tmpl
)
5998 != num_innermost_template_parms (underlying
)))
6001 tree alias_args
= INNERMOST_TEMPLATE_ARGS
6002 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
6003 if (!comp_template_args (TI_ARGS (tinfo
), alias_args
))
6006 /* Alias is equivalent. Strip it and repeat. */
6013 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
6014 must be a reference-to-function or a pointer-to-function type, as specified
6015 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
6016 and check that the resulting function has external linkage. */
6019 convert_nontype_argument_function (tree type
, tree expr
,
6020 tsubst_flags_t complain
)
6024 linkage_kind linkage
;
6026 fn
= instantiate_type (type
, fns
, tf_none
);
6027 if (fn
== error_mark_node
)
6028 return error_mark_node
;
6030 if (value_dependent_expression_p (fn
))
6033 fn_no_ptr
= strip_fnptr_conv (fn
);
6034 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
6035 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
6036 if (BASELINK_P (fn_no_ptr
))
6037 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
6039 /* [temp.arg.nontype]/1
6041 A template-argument for a non-type, non-template template-parameter
6044 -- the address of an object or function with external [C++11: or
6045 internal] linkage. */
6047 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
6049 if (complain
& tf_error
)
6051 error ("%qE is not a valid template argument for type %qT",
6053 if (TYPE_PTR_P (type
))
6054 inform (input_location
, "it must be the address of a function "
6055 "with external linkage");
6057 inform (input_location
, "it must be the name of a function with "
6058 "external linkage");
6063 linkage
= decl_linkage (fn_no_ptr
);
6064 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
6066 if (complain
& tf_error
)
6068 if (cxx_dialect
>= cxx11
)
6069 error ("%qE is not a valid template argument for type %qT "
6070 "because %qD has no linkage",
6071 expr
, type
, fn_no_ptr
);
6073 error ("%qE is not a valid template argument for type %qT "
6074 "because %qD does not have external linkage",
6075 expr
, type
, fn_no_ptr
);
6081 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6082 fn
= build_address (fn
);
6083 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (fn
)))
6084 fn
= build_nop (type
, fn
);
6089 /* Subroutine of convert_nontype_argument.
6090 Check if EXPR of type TYPE is a valid pointer-to-member constant.
6091 Emit an error otherwise. */
6094 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
6095 tsubst_flags_t complain
)
6097 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6098 tree orig_expr
= expr
;
6100 if (null_ptr_cst_p (expr
))
6102 if (TREE_CODE (expr
) == PTRMEM_CST
6103 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
6104 PTRMEM_CST_CLASS (expr
)))
6106 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
6108 if (processing_template_decl
6109 && TREE_CODE (expr
) == ADDR_EXPR
6110 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
6112 if (complain
& tf_error
)
6114 error_at (loc
, "%qE is not a valid template argument for type %qT",
6116 if (TREE_CODE (expr
) != PTRMEM_CST
)
6117 inform (loc
, "it must be a pointer-to-member of the form %<&X::Y%>");
6119 inform (loc
, "because it is a member of %qT", PTRMEM_CST_CLASS (expr
));
6124 /* Returns TRUE iff the address of OP is value-dependent.
6126 14.6.2.4 [temp.dep.temp]:
6127 A non-integral non-type template-argument is dependent if its type is
6128 dependent or it has either of the following forms
6131 and contains a nested-name-specifier which specifies a class-name that
6132 names a dependent type.
6134 We generalize this to just say that the address of a member of a
6135 dependent class is value-dependent; the above doesn't cover the
6136 address of a static data member named with an unqualified-id. */
6139 has_value_dependent_address (tree op
)
6141 /* We could use get_inner_reference here, but there's no need;
6142 this is only relevant for template non-type arguments, which
6143 can only be expressed as &id-expression. */
6146 tree ctx
= CP_DECL_CONTEXT (op
);
6147 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
6154 /* The next set of functions are used for providing helpful explanatory
6155 diagnostics for failed overload resolution. Their messages should be
6156 indented by two spaces for consistency with the messages in
6160 unify_success (bool /*explain_p*/)
6165 /* Other failure functions should call this one, to provide a single function
6166 for setting a breakpoint on. */
6169 unify_invalid (bool /*explain_p*/)
6175 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
6178 inform (input_location
,
6179 " couldn't deduce template parameter %qD", parm
);
6180 return unify_invalid (explain_p
);
6184 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
6187 inform (input_location
,
6188 " types %qT and %qT have incompatible cv-qualifiers",
6190 return unify_invalid (explain_p
);
6194 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
6197 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
6198 return unify_invalid (explain_p
);
6202 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
6205 inform (input_location
,
6206 " template parameter %qD is not a parameter pack, but "
6209 return unify_invalid (explain_p
);
6213 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
6216 inform (input_location
,
6217 " template argument %qE does not match "
6218 "pointer-to-member constant %qE",
6220 return unify_invalid (explain_p
);
6224 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
6227 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
6228 return unify_invalid (explain_p
);
6232 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
6235 inform (input_location
,
6236 " inconsistent parameter pack deduction with %qT and %qT",
6238 return unify_invalid (explain_p
);
6242 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
6247 inform (input_location
,
6248 " deduced conflicting types for parameter %qT (%qT and %qT)",
6249 parm
, first
, second
);
6251 inform (input_location
,
6252 " deduced conflicting values for non-type parameter "
6253 "%qE (%qE and %qE)", parm
, first
, second
);
6255 return unify_invalid (explain_p
);
6259 unify_vla_arg (bool explain_p
, tree arg
)
6262 inform (input_location
,
6263 " variable-sized array type %qT is not "
6264 "a valid template argument",
6266 return unify_invalid (explain_p
);
6270 unify_method_type_error (bool explain_p
, tree arg
)
6273 inform (input_location
,
6274 " member function type %qT is not a valid template argument",
6276 return unify_invalid (explain_p
);
6280 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
6285 inform_n (input_location
, wanted
,
6286 " candidate expects at least %d argument, %d provided",
6287 " candidate expects at least %d arguments, %d provided",
6290 inform_n (input_location
, wanted
,
6291 " candidate expects %d argument, %d provided",
6292 " candidate expects %d arguments, %d provided",
6295 return unify_invalid (explain_p
);
6299 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
6301 return unify_arity (explain_p
, have
, wanted
);
6305 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
6306 bool least_p
= false)
6308 return unify_arity (explain_p
, have
, wanted
, least_p
);
6312 unify_arg_conversion (bool explain_p
, tree to_type
,
6313 tree from_type
, tree arg
)
6316 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
6317 " cannot convert %qE (type %qT) to type %qT",
6318 arg
, from_type
, to_type
);
6319 return unify_invalid (explain_p
);
6323 unify_no_common_base (bool explain_p
, enum template_base_result r
,
6324 tree parm
, tree arg
)
6329 case tbr_ambiguous_baseclass
:
6330 inform (input_location
, " %qT is an ambiguous base class of %qT",
6334 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
6337 return unify_invalid (explain_p
);
6341 unify_inconsistent_template_template_parameters (bool explain_p
)
6344 inform (input_location
,
6345 " template parameters of a template template argument are "
6346 "inconsistent with other deduced template arguments");
6347 return unify_invalid (explain_p
);
6351 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
6354 inform (input_location
,
6355 " can't deduce a template for %qT from non-template type %qT",
6357 return unify_invalid (explain_p
);
6361 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
6364 inform (input_location
,
6365 " template argument %qE does not match %qE", arg
, parm
);
6366 return unify_invalid (explain_p
);
6370 unify_overload_resolution_failure (bool explain_p
, tree arg
)
6373 inform (input_location
,
6374 " could not resolve address from overloaded function %qE",
6376 return unify_invalid (explain_p
);
6379 /* Attempt to convert the non-type template parameter EXPR to the
6380 indicated TYPE. If the conversion is successful, return the
6381 converted value. If the conversion is unsuccessful, return
6382 NULL_TREE if we issued an error message, or error_mark_node if we
6383 did not. We issue error messages for out-and-out bad template
6384 parameters, but not simply because the conversion failed, since we
6385 might be just trying to do argument deduction. Both TYPE and EXPR
6386 must be non-dependent.
6388 The conversion follows the special rules described in
6389 [temp.arg.nontype], and it is much more strict than an implicit
6392 This function is called twice for each template argument (see
6393 lookup_template_class for a more accurate description of this
6394 problem). This means that we need to handle expressions which
6395 are not valid in a C++ source, but can be created from the
6396 first call (for instance, casts to perform conversions). These
6397 hacks can go away after we fix the double coercion problem. */
6400 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
6403 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6404 tree orig_expr
= expr
;
6406 /* Detect immediately string literals as invalid non-type argument.
6407 This special-case is not needed for correctness (we would easily
6408 catch this later), but only to provide better diagnostic for this
6409 common user mistake. As suggested by DR 100, we do not mention
6410 linkage issues in the diagnostic as this is not the point. */
6411 /* FIXME we're making this OK. */
6412 if (TREE_CODE (expr
) == STRING_CST
)
6414 if (complain
& tf_error
)
6415 error ("%qE is not a valid template argument for type %qT "
6416 "because string literals can never be used in this context",
6421 /* Add the ADDR_EXPR now for the benefit of
6422 value_dependent_expression_p. */
6423 if (TYPE_PTROBV_P (type
)
6424 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
6426 expr
= decay_conversion (expr
, complain
);
6427 if (expr
== error_mark_node
)
6428 return error_mark_node
;
6431 /* If we are in a template, EXPR may be non-dependent, but still
6432 have a syntactic, rather than semantic, form. For example, EXPR
6433 might be a SCOPE_REF, rather than the VAR_DECL to which the
6434 SCOPE_REF refers. Preserving the qualifying scope is necessary
6435 so that access checking can be performed when the template is
6436 instantiated -- but here we need the resolved form so that we can
6437 convert the argument. */
6438 bool non_dep
= false;
6439 if (TYPE_REF_OBJ_P (type
)
6440 && has_value_dependent_address (expr
))
6441 /* If we want the address and it's value-dependent, don't fold. */;
6442 else if (processing_template_decl
6443 && potential_nondependent_constant_expression (expr
))
6445 if (error_operand_p (expr
))
6446 return error_mark_node
;
6447 expr_type
= TREE_TYPE (expr
);
6448 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6449 expr
= mark_lvalue_use (expr
);
6451 expr
= mark_rvalue_use (expr
);
6453 /* If the argument is non-dependent, perform any conversions in
6454 non-dependent context as well. */
6455 processing_template_decl_sentinel
s (non_dep
);
6457 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6459 if (value_dependent_expression_p (expr
))
6460 expr
= canonicalize_expr_argument (expr
, complain
);
6462 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
6463 to a non-type argument of "nullptr". */
6464 if (NULLPTR_TYPE_P (expr_type
) && TYPE_PTR_OR_PTRMEM_P (type
))
6465 expr
= fold_simple (convert (type
, expr
));
6467 /* In C++11, integral or enumeration non-type template arguments can be
6468 arbitrary constant expressions. Pointer and pointer to
6469 member arguments can be general constant expressions that evaluate
6470 to a null value, but otherwise still need to be of a specific form. */
6471 if (cxx_dialect
>= cxx11
)
6473 if (TREE_CODE (expr
) == PTRMEM_CST
)
6474 /* A PTRMEM_CST is already constant, and a valid template
6475 argument for a parameter of pointer to member type, we just want
6476 to leave it in that form rather than lower it to a
6478 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
6479 || cxx_dialect
>= cxx1z
)
6481 /* C++17: A template-argument for a non-type template-parameter shall
6482 be a converted constant expression (8.20) of the type of the
6483 template-parameter. */
6484 expr
= build_converted_constant_expr (type
, expr
, complain
);
6485 if (expr
== error_mark_node
)
6486 return error_mark_node
;
6487 expr
= maybe_constant_value (expr
);
6488 expr
= convert_from_reference (expr
);
6490 else if (TYPE_PTR_OR_PTRMEM_P (type
))
6492 tree folded
= maybe_constant_value (expr
);
6493 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
6494 : null_member_pointer_value_p (folded
))
6499 /* HACK: Due to double coercion, we can get a
6500 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
6501 which is the tree that we built on the first call (see
6502 below when coercing to reference to object or to reference to
6503 function). We just strip everything and get to the arg.
6504 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
6506 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
6508 tree probe_type
, probe
= expr
;
6509 if (REFERENCE_REF_P (probe
))
6510 probe
= TREE_OPERAND (probe
, 0);
6511 probe_type
= TREE_TYPE (probe
);
6512 if (TREE_CODE (probe
) == NOP_EXPR
)
6514 /* ??? Maybe we could use convert_from_reference here, but we
6515 would need to relax its constraints because the NOP_EXPR
6516 could actually change the type to something more cv-qualified,
6517 and this is not folded by convert_from_reference. */
6518 tree addr
= TREE_OPERAND (probe
, 0);
6519 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
6520 && TREE_CODE (addr
) == ADDR_EXPR
6521 && TYPE_PTR_P (TREE_TYPE (addr
))
6522 && (same_type_ignoring_top_level_qualifiers_p
6523 (TREE_TYPE (probe_type
),
6524 TREE_TYPE (TREE_TYPE (addr
)))))
6526 expr
= TREE_OPERAND (addr
, 0);
6527 expr_type
= TREE_TYPE (probe_type
);
6532 /* [temp.arg.nontype]/5, bullet 1
6534 For a non-type template-parameter of integral or enumeration type,
6535 integral promotions (_conv.prom_) and integral conversions
6536 (_conv.integral_) are applied. */
6537 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6539 if (cxx_dialect
< cxx11
)
6541 tree t
= build_converted_constant_expr (type
, expr
, complain
);
6542 t
= maybe_constant_value (t
);
6543 if (t
!= error_mark_node
)
6547 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
6548 return error_mark_node
;
6550 /* Notice that there are constant expressions like '4 % 0' which
6551 do not fold into integer constants. */
6552 if (TREE_CODE (expr
) != INTEGER_CST
6553 && !value_dependent_expression_p (expr
))
6555 if (complain
& tf_error
)
6557 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
6558 if (!require_potential_constant_expression (expr
))
6559 expr
= error_mark_node
;
6561 expr
= cxx_constant_value (expr
);
6562 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
6563 inform (loc
, "in template argument for type %qT ", type
);
6564 if (expr
== error_mark_node
)
6566 /* else cxx_constant_value complained but gave us
6567 a real constant, so go ahead. */
6568 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
6574 /* Avoid typedef problems. */
6575 if (TREE_TYPE (expr
) != type
)
6576 expr
= fold_convert (type
, expr
);
6578 /* [temp.arg.nontype]/5, bullet 2
6580 For a non-type template-parameter of type pointer to object,
6581 qualification conversions (_conv.qual_) and the array-to-pointer
6582 conversion (_conv.array_) are applied. */
6583 else if (TYPE_PTROBV_P (type
))
6585 tree decayed
= expr
;
6587 /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
6588 decay_conversion or an explicit cast. If it's a problematic cast,
6589 we'll complain about it below. */
6590 if (TREE_CODE (expr
) == NOP_EXPR
)
6594 if (TREE_CODE (probe
) == ADDR_EXPR
6595 && TYPE_PTR_P (TREE_TYPE (probe
)))
6598 expr_type
= TREE_TYPE (expr
);
6602 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6604 A template-argument for a non-type, non-template template-parameter
6605 shall be one of: [...]
6607 -- the name of a non-type template-parameter;
6608 -- the address of an object or function with external linkage, [...]
6609 expressed as "& id-expression" where the & is optional if the name
6610 refers to a function or array, or if the corresponding
6611 template-parameter is a reference.
6613 Here, we do not care about functions, as they are invalid anyway
6614 for a parameter of type pointer-to-object. */
6616 if (value_dependent_expression_p (expr
))
6617 /* Non-type template parameters are OK. */
6619 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6620 /* Null pointer values are OK in C++11. */;
6621 else if (TREE_CODE (expr
) != ADDR_EXPR
)
6625 if (complain
& tf_error
)
6626 error ("%qD is not a valid template argument "
6627 "because %qD is a variable, not the address of "
6628 "a variable", orig_expr
, expr
);
6631 if (POINTER_TYPE_P (expr_type
))
6633 if (complain
& tf_error
)
6634 error ("%qE is not a valid template argument for %qT "
6635 "because it is not the address of a variable",
6639 /* Other values, like integer constants, might be valid
6640 non-type arguments of some other type. */
6641 return error_mark_node
;
6645 tree decl
= TREE_OPERAND (expr
, 0);
6649 if (complain
& tf_error
)
6650 error ("%qE is not a valid template argument of type %qT "
6651 "because %qE is not a variable", orig_expr
, type
, decl
);
6654 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
6656 if (complain
& tf_error
)
6657 error ("%qE is not a valid template argument of type %qT "
6658 "because %qD does not have external linkage",
6659 orig_expr
, type
, decl
);
6662 else if ((cxx_dialect
>= cxx11
&& cxx_dialect
< cxx1z
)
6663 && decl_linkage (decl
) == lk_none
)
6665 if (complain
& tf_error
)
6666 error ("%qE is not a valid template argument of type %qT "
6667 "because %qD has no linkage", orig_expr
, type
, decl
);
6670 /* C++17: For a non-type template-parameter of reference or pointer
6671 type, the value of the constant expression shall not refer to (or
6672 for a pointer type, shall not be the address of):
6673 * a subobject (4.5),
6674 * a temporary object (15.2),
6675 * a string literal (5.13.5),
6676 * the result of a typeid expression (8.2.8), or
6677 * a predefined __func__ variable (11.4.1). */
6678 else if (DECL_ARTIFICIAL (decl
))
6680 if (complain
& tf_error
)
6681 error ("the address of %qD is not a valid template argument",
6685 else if (!same_type_ignoring_top_level_qualifiers_p
6686 (strip_array_types (TREE_TYPE (type
)),
6687 strip_array_types (TREE_TYPE (decl
))))
6689 if (complain
& tf_error
)
6690 error ("the address of the %qT subobject of %qD is not a "
6691 "valid template argument", TREE_TYPE (type
), decl
);
6694 else if (!TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
6696 if (complain
& tf_error
)
6697 error ("the address of %qD is not a valid template argument "
6698 "because it does not have static storage duration",
6706 expr
= perform_qualification_conversions (type
, expr
);
6707 if (expr
== error_mark_node
)
6708 return error_mark_node
;
6710 /* [temp.arg.nontype]/5, bullet 3
6712 For a non-type template-parameter of type reference to object, no
6713 conversions apply. The type referred to by the reference may be more
6714 cv-qualified than the (otherwise identical) type of the
6715 template-argument. The template-parameter is bound directly to the
6716 template-argument, which must be an lvalue. */
6717 else if (TYPE_REF_OBJ_P (type
))
6719 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
6721 return error_mark_node
;
6723 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
6725 if (complain
& tf_error
)
6726 error ("%qE is not a valid template argument for type %qT "
6727 "because of conflicts in cv-qualification", expr
, type
);
6731 if (!lvalue_p (expr
))
6733 if (complain
& tf_error
)
6734 error ("%qE is not a valid template argument for type %qT "
6735 "because it is not an lvalue", expr
, type
);
6739 /* [temp.arg.nontype]/1
6741 A template-argument for a non-type, non-template template-parameter
6742 shall be one of: [...]
6744 -- the address of an object or function with external linkage. */
6745 if (INDIRECT_REF_P (expr
)
6746 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
6748 expr
= TREE_OPERAND (expr
, 0);
6751 if (complain
& tf_error
)
6752 error ("%q#D is not a valid template argument for type %qT "
6753 "because a reference variable does not have a constant "
6754 "address", expr
, type
);
6759 if (TYPE_REF_OBJ_P (TREE_TYPE (expr
))
6760 && value_dependent_expression_p (expr
))
6761 /* OK, dependent reference. We don't want to ask whether a DECL is
6762 itself value-dependent, since what we want here is its address. */;
6767 if (complain
& tf_error
)
6768 error ("%qE is not a valid template argument for type %qT "
6769 "because it is not an object with linkage",
6774 /* DR 1155 allows internal linkage in C++11 and up. */
6775 linkage_kind linkage
= decl_linkage (expr
);
6776 if (linkage
< (cxx_dialect
>= cxx11
? lk_internal
: lk_external
))
6778 if (complain
& tf_error
)
6779 error ("%qE is not a valid template argument for type %qT "
6780 "because object %qD does not have linkage",
6785 expr
= build_address (expr
);
6788 if (!same_type_p (type
, TREE_TYPE (expr
)))
6789 expr
= build_nop (type
, expr
);
6791 /* [temp.arg.nontype]/5, bullet 4
6793 For a non-type template-parameter of type pointer to function, only
6794 the function-to-pointer conversion (_conv.func_) is applied. If the
6795 template-argument represents a set of overloaded functions (or a
6796 pointer to such), the matching function is selected from the set
6798 else if (TYPE_PTRFN_P (type
))
6800 /* If the argument is a template-id, we might not have enough
6801 context information to decay the pointer. */
6802 if (!type_unknown_p (expr_type
))
6804 expr
= decay_conversion (expr
, complain
);
6805 if (expr
== error_mark_node
)
6806 return error_mark_node
;
6809 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6810 /* Null pointer values are OK in C++11. */
6811 return perform_qualification_conversions (type
, expr
);
6813 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6814 if (!expr
|| expr
== error_mark_node
)
6817 /* [temp.arg.nontype]/5, bullet 5
6819 For a non-type template-parameter of type reference to function, no
6820 conversions apply. If the template-argument represents a set of
6821 overloaded functions, the matching function is selected from the set
6823 else if (TYPE_REFFN_P (type
))
6825 if (TREE_CODE (expr
) == ADDR_EXPR
)
6827 if (complain
& tf_error
)
6829 error ("%qE is not a valid template argument for type %qT "
6830 "because it is a pointer", expr
, type
);
6831 inform (input_location
, "try using %qE instead",
6832 TREE_OPERAND (expr
, 0));
6837 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6838 if (!expr
|| expr
== error_mark_node
)
6841 /* [temp.arg.nontype]/5, bullet 6
6843 For a non-type template-parameter of type pointer to member function,
6844 no conversions apply. If the template-argument represents a set of
6845 overloaded member functions, the matching member function is selected
6846 from the set (_over.over_). */
6847 else if (TYPE_PTRMEMFUNC_P (type
))
6849 expr
= instantiate_type (type
, expr
, tf_none
);
6850 if (expr
== error_mark_node
)
6851 return error_mark_node
;
6853 /* [temp.arg.nontype] bullet 1 says the pointer to member
6854 expression must be a pointer-to-member constant. */
6855 if (!value_dependent_expression_p (expr
)
6856 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6859 /* Repeated conversion can't deal with a conversion that turns PTRMEM_CST
6860 into a CONSTRUCTOR, so build up a new PTRMEM_CST instead. */
6861 if (fnptr_conv_p (type
, TREE_TYPE (expr
)))
6862 expr
= make_ptrmem_cst (type
, PTRMEM_CST_MEMBER (expr
));
6864 /* [temp.arg.nontype]/5, bullet 7
6866 For a non-type template-parameter of type pointer to data member,
6867 qualification conversions (_conv.qual_) are applied. */
6868 else if (TYPE_PTRDATAMEM_P (type
))
6870 /* [temp.arg.nontype] bullet 1 says the pointer to member
6871 expression must be a pointer-to-member constant. */
6872 if (!value_dependent_expression_p (expr
)
6873 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6876 expr
= perform_qualification_conversions (type
, expr
);
6877 if (expr
== error_mark_node
)
6880 else if (NULLPTR_TYPE_P (type
))
6882 if (!NULLPTR_TYPE_P (TREE_TYPE (expr
)))
6884 if (complain
& tf_error
)
6885 error ("%qE is not a valid template argument for type %qT "
6886 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6891 /* A template non-type parameter must be one of the above. */
6895 /* Sanity check: did we actually convert the argument to the
6897 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6898 (type
, TREE_TYPE (expr
)));
6899 return convert_from_reference (expr
);
6902 /* Subroutine of coerce_template_template_parms, which returns 1 if
6903 PARM_PARM and ARG_PARM match using the rule for the template
6904 parameters of template template parameters. Both PARM and ARG are
6905 template parameters; the rest of the arguments are the same as for
6906 coerce_template_template_parms.
6909 coerce_template_template_parm (tree parm
,
6911 tsubst_flags_t complain
,
6915 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6916 || parm
== NULL_TREE
|| error_operand_p (parm
))
6919 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6922 switch (TREE_CODE (parm
))
6925 /* We encounter instantiations of templates like
6926 template <template <template <class> class> class TT>
6929 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6930 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6932 if (!coerce_template_template_parms
6933 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6939 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6940 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6941 /* Argument is a parameter pack but parameter is not. */
6946 /* The tsubst call is used to handle cases such as
6948 template <int> class C {};
6949 template <class T, template <T> class TT> class D {};
6952 i.e. the parameter list of TT depends on earlier parameters. */
6953 if (!uses_template_parms (TREE_TYPE (arg
)))
6955 tree t
= tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
);
6956 if (!uses_template_parms (t
)
6957 && !same_type_p (t
, TREE_TYPE (arg
)))
6961 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6962 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6963 /* Argument is a parameter pack but parameter is not. */
6975 /* Coerce template argument list ARGLIST for use with template
6976 template-parameter TEMPL. */
6979 coerce_template_args_for_ttp (tree templ
, tree arglist
,
6980 tsubst_flags_t complain
)
6982 /* Consider an example where a template template parameter declared as
6984 template <class T, class U = std::allocator<T> > class TT
6986 The template parameter level of T and U are one level larger than
6987 of TT. To proper process the default argument of U, say when an
6988 instantiation `TT<int>' is seen, we need to build the full
6989 arguments containing {int} as the innermost level. Outer levels,
6990 available when not appearing as default template argument, can be
6991 obtained from the arguments of the enclosing template.
6993 Suppose that TT is later substituted with std::vector. The above
6994 instantiation is `TT<int, std::allocator<T> >' with TT at
6995 level 1, and T at level 2, while the template arguments at level 1
6996 becomes {std::vector} and the inner level 2 is {int}. */
6998 tree outer
= DECL_CONTEXT (templ
);
7001 if (DECL_TEMPLATE_SPECIALIZATION (outer
))
7002 /* We want arguments for the partial specialization, not arguments for
7003 the primary template. */
7004 outer
= template_parms_to_args (DECL_TEMPLATE_PARMS (outer
));
7006 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7008 else if (current_template_parms
)
7010 /* This is an argument of the current template, so we haven't set
7011 DECL_CONTEXT yet. */
7012 tree relevant_template_parms
;
7014 /* Parameter levels that are greater than the level of the given
7015 template template parm are irrelevant. */
7016 relevant_template_parms
= current_template_parms
;
7017 while (TMPL_PARMS_DEPTH (relevant_template_parms
)
7018 != TEMPLATE_TYPE_LEVEL (TREE_TYPE (templ
)))
7019 relevant_template_parms
= TREE_CHAIN (relevant_template_parms
);
7021 outer
= template_parms_to_args (relevant_template_parms
);
7025 arglist
= add_to_template_args (outer
, arglist
);
7027 tree parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7028 return coerce_template_parms (parmlist
, arglist
, templ
,
7030 /*require_all_args=*/true,
7031 /*use_default_args=*/true);
7034 /* A cache of template template parameters with match-all default
7036 static GTY((deletable
)) hash_map
<tree
,tree
> *defaulted_ttp_cache
;
7038 store_defaulted_ttp (tree v
, tree t
)
7040 if (!defaulted_ttp_cache
)
7041 defaulted_ttp_cache
= hash_map
<tree
,tree
>::create_ggc (13);
7042 defaulted_ttp_cache
->put (v
, t
);
7045 lookup_defaulted_ttp (tree v
)
7047 if (defaulted_ttp_cache
)
7048 if (tree
*p
= defaulted_ttp_cache
->get (v
))
7053 /* T is a bound template template-parameter. Copy its arguments into default
7054 arguments of the template template-parameter's template parameters. */
7057 add_defaults_to_ttp (tree otmpl
)
7059 if (tree c
= lookup_defaulted_ttp (otmpl
))
7062 tree ntmpl
= copy_node (otmpl
);
7064 tree ntype
= copy_node (TREE_TYPE (otmpl
));
7065 TYPE_STUB_DECL (ntype
) = TYPE_NAME (ntype
) = ntmpl
;
7066 TYPE_MAIN_VARIANT (ntype
) = ntype
;
7067 TYPE_POINTER_TO (ntype
) = TYPE_REFERENCE_TO (ntype
) = NULL_TREE
;
7068 TYPE_NAME (ntype
) = ntmpl
;
7069 SET_TYPE_STRUCTURAL_EQUALITY (ntype
);
7071 tree idx
= TEMPLATE_TYPE_PARM_INDEX (ntype
)
7072 = copy_node (TEMPLATE_TYPE_PARM_INDEX (ntype
));
7073 TEMPLATE_PARM_DECL (idx
) = ntmpl
;
7074 TREE_TYPE (ntmpl
) = TREE_TYPE (idx
) = ntype
;
7076 tree oparms
= DECL_TEMPLATE_PARMS (otmpl
);
7077 tree parms
= DECL_TEMPLATE_PARMS (ntmpl
) = copy_node (oparms
);
7078 TREE_CHAIN (parms
) = TREE_CHAIN (oparms
);
7079 tree vec
= TREE_VALUE (parms
) = copy_node (TREE_VALUE (parms
));
7080 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
7082 tree o
= TREE_VEC_ELT (vec
, i
);
7083 if (!template_parameter_pack_p (TREE_VALUE (o
)))
7085 tree n
= TREE_VEC_ELT (vec
, i
) = copy_node (o
);
7086 TREE_PURPOSE (n
) = any_targ_node
;
7090 store_defaulted_ttp (otmpl
, ntmpl
);
7094 /* ARG is a bound potential template template-argument, and PARGS is a list
7095 of arguments for the corresponding template template-parameter. Adjust
7096 PARGS as appropriate for application to ARG's template, and if ARG is a
7097 BOUND_TEMPLATE_TEMPLATE_PARM, possibly adjust it to add default template
7098 arguments to the template template parameter. */
7101 coerce_ttp_args_for_tta (tree
& arg
, tree pargs
, tsubst_flags_t complain
)
7103 ++processing_template_decl
;
7104 tree arg_tmpl
= TYPE_TI_TEMPLATE (arg
);
7105 if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg_tmpl
))
7107 /* When comparing two template template-parameters in partial ordering,
7108 rewrite the one currently being used as an argument to have default
7109 arguments for all parameters. */
7110 arg_tmpl
= add_defaults_to_ttp (arg_tmpl
);
7111 pargs
= coerce_template_args_for_ttp (arg_tmpl
, pargs
, complain
);
7112 if (pargs
!= error_mark_node
)
7113 arg
= bind_template_template_parm (TREE_TYPE (arg_tmpl
),
7114 TYPE_TI_ARGS (arg
));
7119 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (arg_tmpl
));
7120 pargs
= coerce_template_parms (aparms
, pargs
, arg_tmpl
, complain
,
7121 /*require_all*/true,
7122 /*use_default*/true);
7124 --processing_template_decl
;
7128 /* Subroutine of unify for the case when PARM is a
7129 BOUND_TEMPLATE_TEMPLATE_PARM. */
7132 unify_bound_ttp_args (tree tparms
, tree targs
, tree parm
, tree
& arg
,
7135 tree parmvec
= TYPE_TI_ARGS (parm
);
7136 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
7138 /* The template template parm might be variadic and the argument
7139 not, so flatten both argument lists. */
7140 parmvec
= expand_template_argument_pack (parmvec
);
7141 argvec
= expand_template_argument_pack (argvec
);
7145 /* In keeping with P0522R0, adjust P's template arguments
7146 to apply to A's template; then flatten it again. */
7147 tree nparmvec
= parmvec
;
7148 nparmvec
= coerce_ttp_args_for_tta (arg
, parmvec
, tf_none
);
7149 nparmvec
= expand_template_argument_pack (nparmvec
);
7151 if (unify (tparms
, targs
, nparmvec
, argvec
,
7152 UNIFY_ALLOW_NONE
, explain_p
))
7155 /* If the P0522 adjustment eliminated a pack expansion, deduce
7158 && TREE_VEC_LENGTH (nparmvec
) < TREE_VEC_LENGTH (parmvec
)
7159 && unify_pack_expansion (tparms
, targs
, parmvec
, argvec
,
7160 DEDUCE_EXACT
, /*sub*/true, explain_p
))
7165 /* Deduce arguments T, i from TT<T> or TT<i>.
7166 We check each element of PARMVEC and ARGVEC individually
7167 rather than the whole TREE_VEC since they can have
7168 different number of elements, which is allowed under N2555. */
7170 int len
= TREE_VEC_LENGTH (parmvec
);
7172 /* Check if the parameters end in a pack, making them
7174 int parm_variadic_p
= 0;
7176 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
7177 parm_variadic_p
= 1;
7179 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7180 /* If the template argument list of P contains a pack
7181 expansion that is not the last template argument, the
7182 entire template argument list is a non-deduced
7184 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
7185 return unify_success (explain_p
);
7187 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
7188 return unify_too_few_arguments (explain_p
,
7189 TREE_VEC_LENGTH (argvec
), len
);
7191 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7192 if (unify (tparms
, targs
,
7193 TREE_VEC_ELT (parmvec
, i
),
7194 TREE_VEC_ELT (argvec
, i
),
7195 UNIFY_ALLOW_NONE
, explain_p
))
7199 && unify_pack_expansion (tparms
, targs
,
7202 /*subr=*/true, explain_p
))
7209 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
7210 template template parameters. Both PARM_PARMS and ARG_PARMS are
7211 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
7214 Consider the example:
7215 template <class T> class A;
7216 template<template <class U> class TT> class B;
7218 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
7219 the parameters to A, and OUTER_ARGS contains A. */
7222 coerce_template_template_parms (tree parm_parms
,
7224 tsubst_flags_t complain
,
7228 int nparms
, nargs
, i
;
7232 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
7233 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
7235 nparms
= TREE_VEC_LENGTH (parm_parms
);
7236 nargs
= TREE_VEC_LENGTH (arg_parms
);
7240 /* P0522R0: A template template-parameter P is at least as specialized as
7241 a template template-argument A if, given the following rewrite to two
7242 function templates, the function template corresponding to P is at
7243 least as specialized as the function template corresponding to A
7244 according to the partial ordering rules for function templates
7245 ([temp.func.order]). Given an invented class template X with the
7246 template parameter list of A (including default arguments):
7248 * Each of the two function templates has the same template parameters,
7249 respectively, as P or A.
7251 * Each function template has a single function parameter whose type is
7252 a specialization of X with template arguments corresponding to the
7253 template parameters from the respective function template where, for
7254 each template parameter PP in the template parameter list of the
7255 function template, a corresponding template argument AA is formed. If
7256 PP declares a parameter pack, then AA is the pack expansion
7257 PP... ([temp.variadic]); otherwise, AA is the id-expression PP.
7259 If the rewrite produces an invalid type, then P is not at least as
7260 specialized as A. */
7262 /* So coerce P's args to apply to A's parms, and then deduce between A's
7263 args and the converted args. If that succeeds, A is at least as
7264 specialized as P, so they match.*/
7265 tree pargs
= template_parms_level_to_args (parm_parms
);
7266 ++processing_template_decl
;
7267 pargs
= coerce_template_parms (arg_parms
, pargs
, NULL_TREE
, tf_none
,
7268 /*require_all*/true, /*use_default*/true);
7269 --processing_template_decl
;
7270 if (pargs
!= error_mark_node
)
7272 tree targs
= make_tree_vec (nargs
);
7273 tree aargs
= template_parms_level_to_args (arg_parms
);
7274 if (!unify (arg_parms
, targs
, aargs
, pargs
, UNIFY_ALLOW_NONE
,
7280 /* Determine whether we have a parameter pack at the end of the
7281 template template parameter's template parameter list. */
7282 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
7284 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
7286 if (error_operand_p (parm
))
7289 switch (TREE_CODE (parm
))
7293 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
7298 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
7308 && !(variadic_p
&& nargs
>= nparms
- 1))
7311 /* Check all of the template parameters except the parameter pack at
7312 the end (if any). */
7313 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
7315 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
7316 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7319 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7320 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7322 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7330 /* Check each of the template parameters in the template
7331 argument against the template parameter pack at the end of
7332 the template template parameter. */
7333 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
7336 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7338 for (; i
< nargs
; ++i
)
7340 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7343 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7345 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7354 /* Verifies that the deduced template arguments (in TARGS) for the
7355 template template parameters (in TPARMS) represent valid bindings,
7356 by comparing the template parameter list of each template argument
7357 to the template parameter list of its corresponding template
7358 template parameter, in accordance with DR150. This
7359 routine can only be called after all template arguments have been
7360 deduced. It will return TRUE if all of the template template
7361 parameter bindings are okay, FALSE otherwise. */
7363 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
7365 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
7368 /* We're dealing with template parms in this process. */
7369 ++processing_template_decl
;
7371 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
7373 for (i
= 0; i
< ntparms
; ++i
)
7375 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
7376 tree targ
= TREE_VEC_ELT (targs
, i
);
7378 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
7380 tree packed_args
= NULL_TREE
;
7383 if (ARGUMENT_PACK_P (targ
))
7385 /* Look inside the argument pack. */
7386 packed_args
= ARGUMENT_PACK_ARGS (targ
);
7387 len
= TREE_VEC_LENGTH (packed_args
);
7390 for (idx
= 0; idx
< len
; ++idx
)
7392 tree targ_parms
= NULL_TREE
;
7395 /* Extract the next argument from the argument
7397 targ
= TREE_VEC_ELT (packed_args
, idx
);
7399 if (PACK_EXPANSION_P (targ
))
7400 /* Look at the pattern of the pack expansion. */
7401 targ
= PACK_EXPANSION_PATTERN (targ
);
7403 /* Extract the template parameters from the template
7405 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
7406 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
7407 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
7408 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
7410 /* Verify that we can coerce the template template
7411 parameters from the template argument to the template
7412 parameter. This requires an exact match. */
7414 && !coerce_template_template_parms
7415 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
7430 --processing_template_decl
;
7434 /* Since type attributes aren't mangled, we need to strip them from
7435 template type arguments. */
7438 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
7440 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
7442 bool removed_attributes
= false;
7443 tree canon
= strip_typedefs (arg
, &removed_attributes
);
7444 if (removed_attributes
7445 && (complain
& tf_warning
))
7446 warning (OPT_Wignored_attributes
,
7447 "ignoring attributes on template argument %qT", arg
);
7451 /* And from inside dependent non-type arguments like sizeof(Type). */
7454 canonicalize_expr_argument (tree arg
, tsubst_flags_t complain
)
7456 if (!arg
|| arg
== error_mark_node
)
7458 bool removed_attributes
= false;
7459 tree canon
= strip_typedefs_expr (arg
, &removed_attributes
);
7460 if (removed_attributes
7461 && (complain
& tf_warning
))
7462 warning (OPT_Wignored_attributes
,
7463 "ignoring attributes in template argument %qE", arg
);
7467 // A template declaration can be substituted for a constrained
7468 // template template parameter only when the argument is more
7469 // constrained than the parameter.
7471 is_compatible_template_arg (tree parm
, tree arg
)
7473 tree parm_cons
= get_constraints (parm
);
7475 /* For now, allow constrained template template arguments
7476 and unconstrained template template parameters. */
7477 if (parm_cons
== NULL_TREE
)
7480 tree arg_cons
= get_constraints (arg
);
7482 // If the template parameter is constrained, we need to rewrite its
7483 // constraints in terms of the ARG's template parameters. This ensures
7484 // that all of the template parameter types will have the same depth.
7486 // Note that this is only valid when coerce_template_template_parm is
7487 // true for the innermost template parameters of PARM and ARG. In other
7488 // words, because coercion is successful, this conversion will be valid.
7491 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (arg
));
7492 parm_cons
= tsubst_constraint_info (parm_cons
,
7493 INNERMOST_TEMPLATE_ARGS (args
),
7494 tf_none
, NULL_TREE
);
7495 if (parm_cons
== error_mark_node
)
7499 return subsumes (parm_cons
, arg_cons
);
7502 // Convert a placeholder argument into a binding to the original
7503 // parameter. The original parameter is saved as the TREE_TYPE of
7506 convert_wildcard_argument (tree parm
, tree arg
)
7508 TREE_TYPE (arg
) = parm
;
7512 /* Convert the indicated template ARG as necessary to match the
7513 indicated template PARM. Returns the converted ARG, or
7514 error_mark_node if the conversion was unsuccessful. Error and
7515 warning messages are issued under control of COMPLAIN. This
7516 conversion is for the Ith parameter in the parameter list. ARGS is
7517 the full set of template arguments deduced so far. */
7520 convert_template_argument (tree parm
,
7523 tsubst_flags_t complain
,
7529 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
7531 if (parm
== error_mark_node
)
7532 return error_mark_node
;
7534 /* Trivially convert placeholders. */
7535 if (TREE_CODE (arg
) == WILDCARD_DECL
)
7536 return convert_wildcard_argument (parm
, arg
);
7538 if (arg
== any_targ_node
)
7541 if (TREE_CODE (arg
) == TREE_LIST
7542 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
7544 /* The template argument was the name of some
7545 member function. That's usually
7546 invalid, but static members are OK. In any
7547 case, grab the underlying fields/functions
7548 and issue an error later if required. */
7549 orig_arg
= TREE_VALUE (arg
);
7550 TREE_TYPE (arg
) = unknown_type_node
;
7555 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
7556 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
7557 || requires_tmpl_type
);
7559 /* When determining whether an argument pack expansion is a template,
7560 look at the pattern. */
7561 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
7562 arg
= PACK_EXPANSION_PATTERN (arg
);
7564 /* Deal with an injected-class-name used as a template template arg. */
7565 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
7567 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
7568 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7570 if (cxx_dialect
>= cxx11
)
7571 /* OK under DR 1004. */;
7572 else if (complain
& tf_warning_or_error
)
7573 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
7574 " used as template template argument", TYPE_NAME (arg
));
7575 else if (flag_pedantic_errors
)
7583 ((TREE_CODE (arg
) == TEMPLATE_DECL
7584 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
7585 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
7586 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7587 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
7590 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7591 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
7592 arg
= TYPE_STUB_DECL (arg
);
7594 is_type
= TYPE_P (arg
) || is_tmpl_type
;
7596 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
7597 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
7599 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
7601 if (complain
& tf_error
)
7602 error ("invalid use of destructor %qE as a type", orig_arg
);
7603 return error_mark_node
;
7606 permerror (input_location
,
7607 "to refer to a type member of a template parameter, "
7608 "use %<typename %E%>", orig_arg
);
7610 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
7611 TREE_OPERAND (arg
, 1),
7617 if (is_type
!= requires_type
)
7621 if (complain
& tf_error
)
7623 error ("type/value mismatch at argument %d in template "
7624 "parameter list for %qD",
7627 inform (input_location
,
7628 " expected a constant of type %qT, got %qT",
7630 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
7631 else if (requires_tmpl_type
)
7632 inform (input_location
,
7633 " expected a class template, got %qE", orig_arg
);
7635 inform (input_location
,
7636 " expected a type, got %qE", orig_arg
);
7639 return error_mark_node
;
7641 if (is_tmpl_type
^ requires_tmpl_type
)
7643 if (in_decl
&& (complain
& tf_error
))
7645 error ("type/value mismatch at argument %d in template "
7646 "parameter list for %qD",
7649 inform (input_location
,
7650 " expected a type, got %qT", DECL_NAME (arg
));
7652 inform (input_location
,
7653 " expected a class template, got %qT", orig_arg
);
7655 return error_mark_node
;
7658 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
7659 /* We already did the appropriate conversion when packing args. */
7663 if (requires_tmpl_type
)
7665 if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
7666 /* The number of argument required is not known yet.
7667 Just accept it for now. */
7671 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
7674 /* Strip alias templates that are equivalent to another
7676 arg
= get_underlying_template (arg
);
7677 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
7679 if (coerce_template_template_parms (parmparm
, argparm
,
7685 /* TEMPLATE_TEMPLATE_PARM node is preferred over
7687 if (val
!= error_mark_node
)
7689 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
7690 val
= TREE_TYPE (val
);
7691 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
7692 val
= make_pack_expansion (val
);
7697 if (in_decl
&& (complain
& tf_error
))
7699 error ("type/value mismatch at argument %d in "
7700 "template parameter list for %qD",
7702 inform (input_location
,
7703 " expected a template of type %qD, got %qT",
7707 val
= error_mark_node
;
7710 // Check that the constraints are compatible before allowing the
7712 if (val
!= error_mark_node
)
7713 if (!is_compatible_template_arg (parm
, arg
))
7715 if (in_decl
&& (complain
& tf_error
))
7717 error ("constraint mismatch at argument %d in "
7718 "template parameter list for %qD",
7720 inform (input_location
, " expected %qD but got %qD",
7723 val
= error_mark_node
;
7729 /* We only form one instance of each template specialization.
7730 Therefore, if we use a non-canonical variant (i.e., a
7731 typedef), any future messages referring to the type will use
7732 the typedef, which is confusing if those future uses do not
7733 themselves also use the typedef. */
7735 val
= canonicalize_type_argument (val
, complain
);
7739 tree t
= TREE_TYPE (parm
);
7741 if (tree a
= type_uses_auto (t
))
7743 t
= do_auto_deduction (t
, arg
, a
, complain
, adc_unify
, args
);
7744 if (t
== error_mark_node
)
7745 return error_mark_node
;
7748 t
= tsubst (t
, args
, complain
, in_decl
);
7750 if (invalid_nontype_parm_type_p (t
, complain
))
7751 return error_mark_node
;
7753 if (!type_dependent_expression_p (orig_arg
)
7754 && !uses_template_parms (t
))
7755 /* We used to call digest_init here. However, digest_init
7756 will report errors, which we don't want when complain
7757 is zero. More importantly, digest_init will try too
7758 hard to convert things: for example, `0' should not be
7759 converted to pointer type at this point according to
7760 the standard. Accepting this is not merely an
7761 extension, since deciding whether or not these
7762 conversions can occur is part of determining which
7763 function template to call, or whether a given explicit
7764 argument specification is valid. */
7765 val
= convert_nontype_argument (t
, orig_arg
, complain
);
7767 val
= canonicalize_expr_argument (orig_arg
, complain
);
7769 if (val
== NULL_TREE
)
7770 val
= error_mark_node
;
7771 else if (val
== error_mark_node
&& (complain
& tf_error
))
7772 error ("could not convert template argument %qE from %qT to %qT",
7773 orig_arg
, TREE_TYPE (orig_arg
), t
);
7775 if (INDIRECT_REF_P (val
))
7777 /* Reject template arguments that are references to built-in
7778 functions with no library fallbacks. */
7779 const_tree inner
= TREE_OPERAND (val
, 0);
7780 const_tree innertype
= TREE_TYPE (inner
);
7782 && TREE_CODE (innertype
) == REFERENCE_TYPE
7783 && TREE_CODE (TREE_TYPE (innertype
)) == FUNCTION_TYPE
7784 && 0 < TREE_OPERAND_LENGTH (inner
)
7785 && reject_gcc_builtin (TREE_OPERAND (inner
, 0)))
7786 return error_mark_node
;
7789 if (TREE_CODE (val
) == SCOPE_REF
)
7791 /* Strip typedefs from the SCOPE_REF. */
7792 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
7793 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
7795 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
7796 QUALIFIED_NAME_IS_TEMPLATE (val
));
7803 /* Coerces the remaining template arguments in INNER_ARGS (from
7804 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
7805 Returns the coerced argument pack. PARM_IDX is the position of this
7806 parameter in the template parameter list. ARGS is the original
7807 template argument list. */
7809 coerce_template_parameter_pack (tree parms
,
7817 tsubst_flags_t complain
)
7819 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
7820 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
7823 tree packed_parms
= NULL_TREE
;
7825 if (arg_idx
> nargs
)
7828 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
7830 /* When the template parameter is a non-type template parameter pack
7831 or template template parameter pack whose type or template
7832 parameters use parameter packs, we know exactly how many arguments
7833 we are looking for. Build a vector of the instantiated decls for
7834 these template parameters in PACKED_PARMS. */
7835 /* We can't use make_pack_expansion here because it would interpret a
7836 _DECL as a use rather than a declaration. */
7837 tree decl
= TREE_VALUE (parm
);
7838 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
7839 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
7840 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
7841 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
7843 TREE_VEC_LENGTH (args
)--;
7844 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
7845 TREE_VEC_LENGTH (args
)++;
7847 if (packed_parms
== error_mark_node
)
7848 return error_mark_node
;
7850 /* If we're doing a partial instantiation of a member template,
7851 verify that all of the types used for the non-type
7852 template parameter pack are, in fact, valid for non-type
7853 template parameters. */
7855 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
7857 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
7858 for (j
= 0; j
< len
; ++j
)
7860 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
7861 if (invalid_nontype_parm_type_p (t
, complain
))
7862 return error_mark_node
;
7864 /* We don't know how many args we have yet, just
7865 use the unconverted ones for now. */
7869 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
7871 /* Check if we have a placeholder pack, which indicates we're
7872 in the context of a introduction list. In that case we want
7873 to match this pack to the single placeholder. */
7874 else if (arg_idx
< nargs
7875 && TREE_CODE (TREE_VEC_ELT (inner_args
, arg_idx
)) == WILDCARD_DECL
7876 && WILDCARD_PACK_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
7878 nargs
= arg_idx
+ 1;
7879 packed_args
= make_tree_vec (1);
7882 packed_args
= make_tree_vec (nargs
- arg_idx
);
7884 /* Convert the remaining arguments, which will be a part of the
7885 parameter pack "parm". */
7886 int first_pack_arg
= arg_idx
;
7887 for (; arg_idx
< nargs
; ++arg_idx
)
7889 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
7890 tree actual_parm
= TREE_VALUE (parm
);
7891 int pack_idx
= arg_idx
- first_pack_arg
;
7895 /* Once we've packed as many args as we have types, stop. */
7896 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
7898 else if (PACK_EXPANSION_P (arg
))
7899 /* We don't know how many args we have yet, just
7900 use the unconverted ones for now. */
7903 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
7906 if (arg
== error_mark_node
)
7908 if (complain
& tf_error
)
7909 error ("template argument %d is invalid", arg_idx
+ 1);
7912 arg
= convert_template_argument (actual_parm
,
7913 arg
, new_args
, complain
, parm_idx
,
7915 if (arg
== error_mark_node
)
7917 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
7920 if (arg_idx
- first_pack_arg
< TREE_VEC_LENGTH (packed_args
)
7921 && TREE_VEC_LENGTH (packed_args
) > 0)
7923 if (complain
& tf_error
)
7924 error ("wrong number of template arguments (%d, should be %d)",
7925 arg_idx
- first_pack_arg
, TREE_VEC_LENGTH (packed_args
));
7926 return error_mark_node
;
7929 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
7930 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
7931 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
7934 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
7935 TREE_CONSTANT (argument_pack
) = 1;
7938 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
7940 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
7941 TREE_VEC_LENGTH (packed_args
));
7942 return argument_pack
;
7945 /* Returns the number of pack expansions in the template argument vector
7949 pack_expansion_args_count (tree args
)
7954 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
7956 tree elt
= TREE_VEC_ELT (args
, i
);
7957 if (elt
&& PACK_EXPANSION_P (elt
))
7963 /* Convert all template arguments to their appropriate types, and
7964 return a vector containing the innermost resulting template
7965 arguments. If any error occurs, return error_mark_node. Error and
7966 warning messages are issued under control of COMPLAIN.
7968 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
7969 for arguments not specified in ARGS. Otherwise, if
7970 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
7971 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
7972 USE_DEFAULT_ARGS is false, then all arguments must be specified in
7976 coerce_template_parms (tree parms
,
7979 tsubst_flags_t complain
,
7980 bool require_all_args
,
7981 bool use_default_args
)
7983 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
7984 tree orig_inner_args
;
7987 tree new_inner_args
;
7988 int saved_unevaluated_operand
;
7989 int saved_inhibit_evaluation_warnings
;
7991 /* When used as a boolean value, indicates whether this is a
7992 variadic template parameter list. Since it's an int, we can also
7993 subtract it from nparms to get the number of non-variadic
7996 int variadic_args_p
= 0;
7997 int post_variadic_parms
= 0;
7999 /* Likewise for parameters with default arguments. */
8002 if (args
== error_mark_node
)
8003 return error_mark_node
;
8005 nparms
= TREE_VEC_LENGTH (parms
);
8007 /* Determine if there are any parameter packs or default arguments. */
8008 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
8010 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
8012 ++post_variadic_parms
;
8013 if (template_parameter_pack_p (TREE_VALUE (parm
)))
8015 if (TREE_PURPOSE (parm
))
8019 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
8020 /* If there are no parameters that follow a parameter pack, we need to
8021 expand any argument packs so that we can deduce a parameter pack from
8022 some non-packed args followed by an argument pack, as in variadic85.C.
8023 If there are such parameters, we need to leave argument packs intact
8024 so the arguments are assigned properly. This can happen when dealing
8025 with a nested class inside a partial specialization of a class
8026 template, as in variadic92.C, or when deducing a template parameter pack
8027 from a sub-declarator, as in variadic114.C. */
8028 if (!post_variadic_parms
)
8029 inner_args
= expand_template_argument_pack (inner_args
);
8031 /* Count any pack expansion args. */
8032 variadic_args_p
= pack_expansion_args_count (inner_args
);
8034 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
8035 if ((nargs
- variadic_args_p
> nparms
&& !variadic_p
)
8036 || (nargs
< nparms
- variadic_p
8039 && (!use_default_args
8040 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
8041 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
8043 if (complain
& tf_error
)
8045 if (variadic_p
|| default_p
)
8047 nparms
-= variadic_p
+ default_p
;
8048 error ("wrong number of template arguments "
8049 "(%d, should be at least %d)", nargs
, nparms
);
8052 error ("wrong number of template arguments "
8053 "(%d, should be %d)", nargs
, nparms
);
8056 inform (DECL_SOURCE_LOCATION (in_decl
),
8057 "provided for %qD", in_decl
);
8060 return error_mark_node
;
8062 /* We can't pass a pack expansion to a non-pack parameter of an alias
8063 template (DR 1430). */
8065 && (DECL_ALIAS_TEMPLATE_P (in_decl
)
8066 || concept_template_p (in_decl
))
8068 && nargs
- variadic_args_p
< nparms
- variadic_p
)
8070 if (complain
& tf_error
)
8072 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
8074 tree arg
= TREE_VEC_ELT (inner_args
, i
);
8075 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
8077 if (PACK_EXPANSION_P (arg
)
8078 && !template_parameter_pack_p (parm
))
8080 if (DECL_ALIAS_TEMPLATE_P (in_decl
))
8081 error_at (location_of (arg
),
8082 "pack expansion argument for non-pack parameter "
8083 "%qD of alias template %qD", parm
, in_decl
);
8085 error_at (location_of (arg
),
8086 "pack expansion argument for non-pack parameter "
8087 "%qD of concept %qD", parm
, in_decl
);
8088 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
8095 return error_mark_node
;
8098 /* We need to evaluate the template arguments, even though this
8099 template-id may be nested within a "sizeof". */
8100 saved_unevaluated_operand
= cp_unevaluated_operand
;
8101 cp_unevaluated_operand
= 0;
8102 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
8103 c_inhibit_evaluation_warnings
= 0;
8104 new_inner_args
= make_tree_vec (nparms
);
8105 new_args
= add_outermost_template_args (args
, new_inner_args
);
8106 int pack_adjust
= 0;
8107 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
8112 /* Get the Ith template parameter. */
8113 parm
= TREE_VEC_ELT (parms
, parm_idx
);
8115 if (parm
== error_mark_node
)
8117 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
8121 /* Calculate the next argument. */
8122 if (arg_idx
< nargs
)
8123 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
8127 if (template_parameter_pack_p (TREE_VALUE (parm
))
8128 && !(arg
&& ARGUMENT_PACK_P (arg
)))
8130 /* Some arguments will be placed in the
8131 template parameter pack PARM. */
8132 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
8133 inner_args
, arg_idx
,
8137 if (arg
== NULL_TREE
)
8139 /* We don't know how many args we have yet, just use the
8140 unconverted (and still packed) ones for now. */
8141 new_inner_args
= orig_inner_args
;
8146 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
8148 /* Store this argument. */
8149 if (arg
== error_mark_node
)
8152 /* We are done with all of the arguments. */
8157 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
8158 arg_idx
+= pack_adjust
;
8165 if (PACK_EXPANSION_P (arg
))
8167 /* "If every valid specialization of a variadic template
8168 requires an empty template parameter pack, the template is
8169 ill-formed, no diagnostic required." So check that the
8170 pattern works with this parameter. */
8171 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
8172 tree conv
= convert_template_argument (TREE_VALUE (parm
),
8176 if (conv
== error_mark_node
)
8178 if (complain
& tf_error
)
8179 inform (input_location
, "so any instantiation with a "
8180 "non-empty parameter pack would be ill-formed");
8183 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
8184 /* Recover from missing typename. */
8185 TREE_VEC_ELT (inner_args
, arg_idx
)
8186 = make_pack_expansion (conv
);
8188 /* We don't know how many args we have yet, just
8189 use the unconverted ones for now. */
8190 new_inner_args
= inner_args
;
8195 else if (require_all_args
)
8197 /* There must be a default arg in this case. */
8198 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
8200 /* The position of the first default template argument,
8201 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
8203 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8204 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8205 arg_idx
- pack_adjust
);
8210 if (arg
== error_mark_node
)
8212 if (complain
& tf_error
)
8213 error ("template argument %d is invalid", arg_idx
+ 1);
8216 /* This only occurs if there was an error in the template
8217 parameter list itself (which we would already have
8218 reported) that we are trying to recover from, e.g., a class
8219 template with a parameter list such as
8220 template<typename..., typename>. */
8223 arg
= convert_template_argument (TREE_VALUE (parm
),
8224 arg
, new_args
, complain
,
8227 if (arg
== error_mark_node
)
8229 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
8231 cp_unevaluated_operand
= saved_unevaluated_operand
;
8232 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
8234 if (variadic_p
&& arg_idx
< nargs
)
8236 if (complain
& tf_error
)
8238 error ("wrong number of template arguments "
8239 "(%d, should be %d)", nargs
, arg_idx
);
8241 error ("provided for %q+D", in_decl
);
8243 return error_mark_node
;
8247 return error_mark_node
;
8249 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8250 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8251 TREE_VEC_LENGTH (new_inner_args
));
8253 return new_inner_args
;
8256 /* Convert all template arguments to their appropriate types, and
8257 return a vector containing the innermost resulting template
8258 arguments. If any error occurs, return error_mark_node. Error and
8259 warning messages are not issued.
8261 Note that no function argument deduction is performed, and default
8262 arguments are used to fill in unspecified arguments. */
8264 coerce_template_parms (tree parms
, tree args
, tree in_decl
)
8266 return coerce_template_parms (parms
, args
, in_decl
, tf_none
, true, true);
8269 /* Convert all template arguments to their appropriate type, and
8270 instantiate default arguments as needed. This returns a vector
8271 containing the innermost resulting template arguments, or
8272 error_mark_node if unsuccessful. */
8274 coerce_template_parms (tree parms
, tree args
, tree in_decl
,
8275 tsubst_flags_t complain
)
8277 return coerce_template_parms (parms
, args
, in_decl
, complain
, true, true);
8280 /* Like coerce_template_parms. If PARMS represents all template
8281 parameters levels, this function returns a vector of vectors
8282 representing all the resulting argument levels. Note that in this
8283 case, only the innermost arguments are coerced because the
8284 outermost ones are supposed to have been coerced already.
8286 Otherwise, if PARMS represents only (the innermost) vector of
8287 parameters, this function returns a vector containing just the
8288 innermost resulting arguments. */
8291 coerce_innermost_template_parms (tree parms
,
8294 tsubst_flags_t complain
,
8295 bool require_all_args
,
8296 bool use_default_args
)
8298 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
8299 int args_depth
= TMPL_ARGS_DEPTH (args
);
8302 if (parms_depth
> 1)
8304 coerced_args
= make_tree_vec (parms_depth
);
8308 for (level
= parms
, cur_depth
= parms_depth
;
8309 parms_depth
> 0 && level
!= NULL_TREE
;
8310 level
= TREE_CHAIN (level
), --cur_depth
)
8313 if (cur_depth
== args_depth
)
8314 l
= coerce_template_parms (TREE_VALUE (level
),
8315 args
, in_decl
, complain
,
8319 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
8321 if (l
== error_mark_node
)
8322 return error_mark_node
;
8324 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
8328 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
8329 args
, in_decl
, complain
,
8332 return coerced_args
;
8335 /* Returns 1 if template args OT and NT are equivalent. */
8338 template_args_equal (tree ot
, tree nt
, bool partial_order
/* = false */)
8342 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
8344 if (nt
== any_targ_node
|| ot
== any_targ_node
)
8347 if (TREE_CODE (nt
) == TREE_VEC
)
8348 /* For member templates */
8349 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
8350 else if (PACK_EXPANSION_P (ot
))
8351 return (PACK_EXPANSION_P (nt
)
8352 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
8353 PACK_EXPANSION_PATTERN (nt
))
8354 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
8355 PACK_EXPANSION_EXTRA_ARGS (nt
)));
8356 else if (ARGUMENT_PACK_P (ot
))
8361 if (!ARGUMENT_PACK_P (nt
))
8364 opack
= ARGUMENT_PACK_ARGS (ot
);
8365 npack
= ARGUMENT_PACK_ARGS (nt
);
8366 len
= TREE_VEC_LENGTH (opack
);
8367 if (TREE_VEC_LENGTH (npack
) != len
)
8369 for (i
= 0; i
< len
; ++i
)
8370 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
8371 TREE_VEC_ELT (npack
, i
)))
8375 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
8377 else if (TYPE_P (nt
))
8381 /* Don't treat an alias template specialization with dependent
8382 arguments as equivalent to its underlying type when used as a
8383 template argument; we need them to be distinct so that we
8384 substitute into the specialization arguments at instantiation
8385 time. And aliases can't be equivalent without being ==, so
8386 we don't need to look any deeper.
8388 During partial ordering, however, we need to treat them normally so
8389 that we can order uses of the same alias with different
8390 cv-qualification (79960). */
8392 && (TYPE_ALIAS_P (nt
) || TYPE_ALIAS_P (ot
)))
8395 return same_type_p (ot
, nt
);
8397 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
8401 /* Try to treat a template non-type argument that has been converted
8402 to the parameter type as equivalent to one that hasn't yet. */
8403 for (enum tree_code code1
= TREE_CODE (ot
);
8404 CONVERT_EXPR_CODE_P (code1
)
8405 || code1
== NON_LVALUE_EXPR
;
8406 code1
= TREE_CODE (ot
))
8407 ot
= TREE_OPERAND (ot
, 0);
8408 for (enum tree_code code2
= TREE_CODE (nt
);
8409 CONVERT_EXPR_CODE_P (code2
)
8410 || code2
== NON_LVALUE_EXPR
;
8411 code2
= TREE_CODE (nt
))
8412 nt
= TREE_OPERAND (nt
, 0);
8414 return cp_tree_equal (ot
, nt
);
8418 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
8419 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
8420 NEWARG_PTR with the offending arguments if they are non-NULL. */
8423 comp_template_args (tree oldargs
, tree newargs
,
8424 tree
*oldarg_ptr
, tree
*newarg_ptr
,
8429 if (oldargs
== newargs
)
8432 if (!oldargs
|| !newargs
)
8435 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
8438 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
8440 tree nt
= TREE_VEC_ELT (newargs
, i
);
8441 tree ot
= TREE_VEC_ELT (oldargs
, i
);
8443 if (! template_args_equal (ot
, nt
, partial_order
))
8445 if (oldarg_ptr
!= NULL
)
8447 if (newarg_ptr
!= NULL
)
8456 comp_template_args_porder (tree oargs
, tree nargs
)
8458 return comp_template_args (oargs
, nargs
, NULL
, NULL
, true);
8462 add_pending_template (tree d
)
8464 tree ti
= (TYPE_P (d
)
8465 ? CLASSTYPE_TEMPLATE_INFO (d
)
8466 : DECL_TEMPLATE_INFO (d
));
8467 struct pending_template
*pt
;
8470 if (TI_PENDING_TEMPLATE_FLAG (ti
))
8473 /* We are called both from instantiate_decl, where we've already had a
8474 tinst_level pushed, and instantiate_template, where we haven't.
8476 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
8479 push_tinst_level (d
);
8481 pt
= ggc_alloc
<pending_template
> ();
8483 pt
->tinst
= current_tinst_level
;
8484 if (last_pending_template
)
8485 last_pending_template
->next
= pt
;
8487 pending_templates
= pt
;
8489 last_pending_template
= pt
;
8491 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
8498 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
8499 ARGLIST. Valid choices for FNS are given in the cp-tree.def
8500 documentation for TEMPLATE_ID_EXPR. */
8503 lookup_template_function (tree fns
, tree arglist
)
8507 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
8508 return error_mark_node
;
8510 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
8512 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
8514 error ("%q#D is not a function template", fns
);
8515 return error_mark_node
;
8518 if (BASELINK_P (fns
))
8520 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
8522 BASELINK_FUNCTIONS (fns
),
8527 type
= TREE_TYPE (fns
);
8528 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
8529 type
= unknown_type_node
;
8531 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
8534 /* Within the scope of a template class S<T>, the name S gets bound
8535 (in build_self_reference) to a TYPE_DECL for the class, not a
8536 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
8537 or one of its enclosing classes, and that type is a template,
8538 return the associated TEMPLATE_DECL. Otherwise, the original
8541 Also handle the case when DECL is a TREE_LIST of ambiguous
8542 injected-class-names from different bases. */
8545 maybe_get_template_decl_from_type_decl (tree decl
)
8547 if (decl
== NULL_TREE
)
8550 /* DR 176: A lookup that finds an injected-class-name (10.2
8551 [class.member.lookup]) can result in an ambiguity in certain cases
8552 (for example, if it is found in more than one base class). If all of
8553 the injected-class-names that are found refer to specializations of
8554 the same class template, and if the name is followed by a
8555 template-argument-list, the reference refers to the class template
8556 itself and not a specialization thereof, and is not ambiguous. */
8557 if (TREE_CODE (decl
) == TREE_LIST
)
8559 tree t
, tmpl
= NULL_TREE
;
8560 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
8562 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
8565 else if (tmpl
!= elt
)
8568 if (tmpl
&& t
== NULL_TREE
)
8574 return (decl
!= NULL_TREE
8575 && DECL_SELF_REFERENCE_P (decl
)
8576 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
8577 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
8580 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
8581 parameters, find the desired type.
8583 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
8585 IN_DECL, if non-NULL, is the template declaration we are trying to
8588 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
8589 the class we are looking up.
8591 Issue error and warning messages under control of COMPLAIN.
8593 If the template class is really a local class in a template
8594 function, then the FUNCTION_CONTEXT is the function in which it is
8597 ??? Note that this function is currently called *twice* for each
8598 template-id: the first time from the parser, while creating the
8599 incomplete type (finish_template_type), and the second type during the
8600 real instantiation (instantiate_template_class). This is surely something
8601 that we want to avoid. It also causes some problems with argument
8602 coercion (see convert_nontype_argument for more information on this). */
8605 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
8606 int entering_scope
, tsubst_flags_t complain
)
8608 tree templ
= NULL_TREE
, parmlist
;
8615 if (identifier_p (d1
))
8617 tree value
= innermost_non_namespace_value (d1
);
8618 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
8623 push_decl_namespace (context
);
8624 templ
= lookup_name (d1
);
8625 templ
= maybe_get_template_decl_from_type_decl (templ
);
8627 pop_decl_namespace ();
8630 context
= DECL_CONTEXT (templ
);
8632 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
8634 tree type
= TREE_TYPE (d1
);
8636 /* If we are declaring a constructor, say A<T>::A<T>, we will get
8637 an implicit typename for the second A. Deal with it. */
8638 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
8639 type
= TREE_TYPE (type
);
8641 if (CLASSTYPE_TEMPLATE_INFO (type
))
8643 templ
= CLASSTYPE_TI_TEMPLATE (type
);
8644 d1
= DECL_NAME (templ
);
8647 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
8648 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
8650 templ
= TYPE_TI_TEMPLATE (d1
);
8651 d1
= DECL_NAME (templ
);
8653 else if (DECL_TYPE_TEMPLATE_P (d1
))
8656 d1
= DECL_NAME (templ
);
8657 context
= DECL_CONTEXT (templ
);
8659 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
8662 d1
= DECL_NAME (templ
);
8665 /* Issue an error message if we didn't find a template. */
8668 if (complain
& tf_error
)
8669 error ("%qT is not a template", d1
);
8670 return error_mark_node
;
8673 if (TREE_CODE (templ
) != TEMPLATE_DECL
8674 /* Make sure it's a user visible template, if it was named by
8676 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
8677 && !PRIMARY_TEMPLATE_P (templ
)))
8679 if (complain
& tf_error
)
8681 error ("non-template type %qT used as a template", d1
);
8683 error ("for template declaration %q+D", in_decl
);
8685 return error_mark_node
;
8688 complain
&= ~tf_user
;
8690 /* An alias that just changes the name of a template is equivalent to the
8691 other template, so if any of the arguments are pack expansions, strip
8692 the alias to avoid problems with a pack expansion passed to a non-pack
8693 alias template parameter (DR 1430). */
8694 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
8695 templ
= get_underlying_template (templ
);
8697 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
8700 tree arglist2
= coerce_template_args_for_ttp (templ
, arglist
, complain
);
8701 if (arglist2
== error_mark_node
8702 || (!uses_template_parms (arglist2
)
8703 && check_instantiated_args (templ
, arglist2
, complain
)))
8704 return error_mark_node
;
8706 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
8711 tree template_type
= TREE_TYPE (templ
);
8714 tree found
= NULL_TREE
;
8717 int is_dependent_type
;
8718 int use_partial_inst_tmpl
= false;
8720 if (template_type
== error_mark_node
)
8721 /* An error occurred while building the template TEMPL, and a
8722 diagnostic has most certainly been emitted for that
8723 already. Let's propagate that error. */
8724 return error_mark_node
;
8726 gen_tmpl
= most_general_template (templ
);
8727 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
8728 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
8729 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
8731 if (arg_depth
== 1 && parm_depth
> 1)
8733 /* We've been given an incomplete set of template arguments.
8736 template <class T> struct S1 {
8737 template <class U> struct S2 {};
8738 template <class U> struct S2<U*> {};
8741 we will be called with an ARGLIST of `U*', but the
8742 TEMPLATE will be `template <class T> template
8743 <class U> struct S1<T>::S2'. We must fill in the missing
8745 tree ti
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (templ
));
8746 arglist
= add_outermost_template_args (TI_ARGS (ti
), arglist
);
8747 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
8750 /* Now we should have enough arguments. */
8751 gcc_assert (parm_depth
== arg_depth
);
8753 /* From here on, we're only interested in the most general
8756 /* Calculate the BOUND_ARGS. These will be the args that are
8757 actually tsubst'd into the definition to create the
8759 arglist
= coerce_innermost_template_parms (parmlist
, arglist
, gen_tmpl
,
8761 /*require_all_args=*/true,
8762 /*use_default_args=*/true);
8764 if (arglist
== error_mark_node
)
8765 /* We were unable to bind the arguments. */
8766 return error_mark_node
;
8768 /* In the scope of a template class, explicit references to the
8769 template class refer to the type of the template, not any
8770 instantiation of it. For example, in:
8772 template <class T> class C { void f(C<T>); }
8774 the `C<T>' is just the same as `C'. Outside of the
8775 class, however, such a reference is an instantiation. */
8777 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
8778 || currently_open_class (template_type
))
8780 tree tinfo
= TYPE_TEMPLATE_INFO (template_type
);
8782 if (tinfo
&& comp_template_args (TI_ARGS (tinfo
), arglist
))
8783 return template_type
;
8786 /* If we already have this specialization, return it. */
8787 elt
.tmpl
= gen_tmpl
;
8789 elt
.spec
= NULL_TREE
;
8790 hash
= spec_hasher::hash (&elt
);
8791 entry
= type_specializations
->find_with_hash (&elt
, hash
);
8796 /* If the the template's constraints are not satisfied,
8797 then we cannot form a valid type.
8799 Note that the check is deferred until after the hash
8800 lookup. This prevents redundant checks on previously
8801 instantiated specializations. */
8802 if (flag_concepts
&& !constraints_satisfied_p (gen_tmpl
, arglist
))
8804 if (complain
& tf_error
)
8806 error ("template constraint failure");
8807 diagnose_constraints (input_location
, gen_tmpl
, arglist
);
8809 return error_mark_node
;
8812 is_dependent_type
= uses_template_parms (arglist
);
8814 /* If the deduced arguments are invalid, then the binding
8816 if (!is_dependent_type
8817 && check_instantiated_args (gen_tmpl
,
8818 INNERMOST_TEMPLATE_ARGS (arglist
),
8820 return error_mark_node
;
8822 if (!is_dependent_type
8823 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
8824 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
8825 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
8827 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
8828 DECL_NAME (gen_tmpl
),
8829 /*tag_scope=*/ts_global
);
8833 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
8835 if (context
== error_mark_node
)
8836 return error_mark_node
;
8839 context
= global_namespace
;
8841 /* Create the type. */
8842 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8844 /* The user referred to a specialization of an alias
8845 template represented by GEN_TMPL.
8847 [temp.alias]/2 says:
8849 When a template-id refers to the specialization of an
8850 alias template, it is equivalent to the associated
8851 type obtained by substitution of its
8852 template-arguments for the template-parameters in the
8853 type-id of the alias template. */
8855 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
8856 /* Note that the call above (by indirectly calling
8857 register_specialization in tsubst_decl) registers the
8858 TYPE_DECL representing the specialization of the alias
8859 template. So next time someone substitutes ARGLIST for
8860 the template parms into the alias template (GEN_TMPL),
8861 she'll get that TYPE_DECL back. */
8863 if (t
== error_mark_node
)
8866 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
8868 if (!is_dependent_type
)
8870 set_current_access_from_decl (TYPE_NAME (template_type
));
8871 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
8872 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
8873 arglist
, complain
, in_decl
),
8874 tsubst_attributes (TYPE_ATTRIBUTES (template_type
),
8875 arglist
, complain
, in_decl
),
8876 SCOPED_ENUM_P (template_type
), NULL
);
8878 if (t
== error_mark_node
)
8883 /* We don't want to call start_enum for this type, since
8884 the values for the enumeration constants may involve
8885 template parameters. And, no one should be interested
8886 in the enumeration constants for such a type. */
8887 t
= cxx_make_type (ENUMERAL_TYPE
);
8888 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
8890 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
8891 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
8892 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
8894 else if (CLASS_TYPE_P (template_type
))
8896 t
= make_class_type (TREE_CODE (template_type
));
8897 CLASSTYPE_DECLARED_CLASS (t
)
8898 = CLASSTYPE_DECLARED_CLASS (template_type
);
8899 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
8901 /* A local class. Make sure the decl gets registered properly. */
8902 if (context
== current_function_decl
)
8903 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
8905 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
8906 /* This instantiation is another name for the primary
8907 template type. Set the TYPE_CANONICAL field
8909 TYPE_CANONICAL (t
) = template_type
;
8910 else if (any_template_arguments_need_structural_equality_p (arglist
))
8911 /* Some of the template arguments require structural
8912 equality testing, so this template class requires
8913 structural equality testing. */
8914 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8919 /* If we called start_enum or pushtag above, this information
8920 will already be set up. */
8923 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
8925 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
8926 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
8927 DECL_SOURCE_LOCATION (type_decl
)
8928 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
8931 type_decl
= TYPE_NAME (t
);
8933 if (CLASS_TYPE_P (template_type
))
8935 TREE_PRIVATE (type_decl
)
8936 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
8937 TREE_PROTECTED (type_decl
)
8938 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
8939 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
8941 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
8942 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
8946 if (OVERLOAD_TYPE_P (t
)
8947 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8949 static const char *tags
[] = {"abi_tag", "may_alias"};
8951 for (unsigned ix
= 0; ix
!= 2; ix
++)
8954 = lookup_attribute (tags
[ix
], TYPE_ATTRIBUTES (template_type
));
8958 = tree_cons (TREE_PURPOSE (attributes
),
8959 TREE_VALUE (attributes
),
8960 TYPE_ATTRIBUTES (t
));
8964 /* Let's consider the explicit specialization of a member
8965 of a class template specialization that is implicitly instantiated,
8970 template<class U> struct M {}; //#0
8975 struct S<int>::M<char> //#1
8979 [temp.expl.spec]/4 says this is valid.
8981 In this case, when we write:
8984 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
8987 When we encounter #1, we want to store the partial instantiation
8988 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
8990 For all cases other than this "explicit specialization of member of a
8991 class template", we just want to store the most general template into
8992 the CLASSTYPE_TI_TEMPLATE of M.
8994 This case of "explicit specialization of member of a class template"
8996 1/ the enclosing class is an instantiation of, and therefore not
8997 the same as, the context of the most general template, and
8998 2/ we aren't looking at the partial instantiation itself, i.e.
8999 the innermost arguments are not the same as the innermost parms of
9000 the most general template.
9002 So it's only when 1/ and 2/ happens that we want to use the partial
9003 instantiation of the member template in lieu of its most general
9006 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
9007 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
9008 /* the enclosing class must be an instantiation... */
9009 && CLASS_TYPE_P (context
)
9010 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
9012 TREE_VEC_LENGTH (arglist
)--;
9013 ++processing_template_decl
;
9014 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (gen_tmpl
));
9015 tree partial_inst_args
=
9016 tsubst (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
)),
9017 arglist
, complain
, NULL_TREE
);
9018 --processing_template_decl
;
9019 TREE_VEC_LENGTH (arglist
)++;
9020 if (partial_inst_args
== error_mark_node
)
9021 return error_mark_node
;
9022 use_partial_inst_tmpl
=
9023 /*...and we must not be looking at the partial instantiation
9025 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
9029 if (!use_partial_inst_tmpl
)
9030 /* This case is easy; there are no member templates involved. */
9034 /* This is a full instantiation of a member template. Find
9035 the partial instantiation of which this is an instance. */
9037 /* Temporarily reduce by one the number of levels in the ARGLIST
9038 so as to avoid comparing the last set of arguments. */
9039 TREE_VEC_LENGTH (arglist
)--;
9040 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
9041 TREE_VEC_LENGTH (arglist
)++;
9042 /* FOUND is either a proper class type, or an alias
9043 template specialization. In the later case, it's a
9044 TYPE_DECL, resulting from the substituting of arguments
9045 for parameters in the TYPE_DECL of the alias template
9046 done earlier. So be careful while getting the template
9048 found
= (TREE_CODE (found
) == TEMPLATE_DECL
9050 : (TREE_CODE (found
) == TYPE_DECL
9051 ? DECL_TI_TEMPLATE (found
)
9052 : CLASSTYPE_TI_TEMPLATE (found
)));
9055 // Build template info for the new specialization.
9056 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
9059 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
9060 entry
= ggc_alloc
<spec_entry
> ();
9064 /* Note this use of the partial instantiation so we can check it
9065 later in maybe_process_partial_specialization. */
9066 DECL_TEMPLATE_INSTANTIATIONS (found
)
9067 = tree_cons (arglist
, t
,
9068 DECL_TEMPLATE_INSTANTIATIONS (found
));
9070 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
9071 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9072 /* Now that the type has been registered on the instantiations
9073 list, we set up the enumerators. Because the enumeration
9074 constants may involve the enumeration type itself, we make
9075 sure to register the type first, and then create the
9076 constants. That way, doing tsubst_expr for the enumeration
9077 constants won't result in recursive calls here; we'll find
9078 the instantiation and exit above. */
9079 tsubst_enum (template_type
, t
, arglist
);
9081 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
9082 /* If the type makes use of template parameters, the
9083 code that generates debugging information will crash. */
9084 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
9086 /* Possibly limit visibility based on template args. */
9087 TREE_PUBLIC (type_decl
) = 1;
9088 determine_visibility (type_decl
);
9090 inherit_targ_abi_tags (t
);
9096 /* Wrapper for lookup_template_class_1. */
9099 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
9100 int entering_scope
, tsubst_flags_t complain
)
9103 timevar_push (TV_TEMPLATE_INST
);
9104 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
9105 entering_scope
, complain
);
9106 timevar_pop (TV_TEMPLATE_INST
);
9110 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
9113 lookup_template_variable (tree templ
, tree arglist
)
9115 /* The type of the expression is NULL_TREE since the template-id could refer
9116 to an explicit or partial specialization. */
9117 tree type
= NULL_TREE
;
9118 if (flag_concepts
&& variable_concept_p (templ
))
9119 /* Except that concepts are always bool. */
9120 type
= boolean_type_node
;
9121 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
9124 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
9127 finish_template_variable (tree var
, tsubst_flags_t complain
)
9129 tree templ
= TREE_OPERAND (var
, 0);
9130 tree arglist
= TREE_OPERAND (var
, 1);
9132 /* We never want to return a VAR_DECL for a variable concept, since they
9133 aren't instantiated. In a template, leave the TEMPLATE_ID_EXPR alone. */
9134 bool concept_p
= flag_concepts
&& variable_concept_p (templ
);
9135 if (concept_p
&& processing_template_decl
)
9138 tree tmpl_args
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ
));
9139 arglist
= add_outermost_template_args (tmpl_args
, arglist
);
9141 templ
= most_general_template (templ
);
9142 tree parms
= DECL_TEMPLATE_PARMS (templ
);
9143 arglist
= coerce_innermost_template_parms (parms
, arglist
, templ
, complain
,
9145 /*use_default*/true);
9147 if (flag_concepts
&& !constraints_satisfied_p (templ
, arglist
))
9149 if (complain
& tf_error
)
9151 error ("use of invalid variable template %qE", var
);
9152 diagnose_constraints (location_of (var
), templ
, arglist
);
9154 return error_mark_node
;
9157 /* If a template-id refers to a specialization of a variable
9158 concept, then the expression is true if and only if the
9159 concept's constraints are satisfied by the given template
9162 NOTE: This is an extension of Concepts Lite TS that
9163 allows constraints to be used in expressions. */
9166 tree decl
= DECL_TEMPLATE_RESULT (templ
);
9167 return evaluate_variable_concept (decl
, arglist
);
9170 return instantiate_template (templ
, arglist
, complain
);
9173 /* Construct a TEMPLATE_ID_EXPR for the given variable template TEMPL having
9174 TARGS template args, and instantiate it if it's not dependent. */
9177 lookup_and_finish_template_variable (tree templ
, tree targs
,
9178 tsubst_flags_t complain
)
9180 templ
= lookup_template_variable (templ
, targs
);
9181 if (!any_dependent_template_arguments_p (targs
))
9183 templ
= finish_template_variable (templ
, complain
);
9187 return convert_from_reference (templ
);
9196 /* True when we should also visit template parameters that occur in
9197 non-deduced contexts. */
9198 bool include_nondeduced_p
;
9199 hash_set
<tree
> *visited
;
9202 /* Called from for_each_template_parm via walk_tree. */
9205 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
9208 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
9209 tree_fn_t fn
= pfd
->fn
;
9210 void *data
= pfd
->data
;
9211 tree result
= NULL_TREE
;
9213 #define WALK_SUBTREE(NODE) \
9216 result = for_each_template_parm (NODE, fn, data, pfd->visited, \
9217 pfd->include_nondeduced_p, \
9219 if (result) goto out; \
9223 if (pfd
->any_fn
&& (*pfd
->any_fn
)(t
, data
))
9227 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
))
9228 WALK_SUBTREE (TYPE_CONTEXT (t
));
9230 switch (TREE_CODE (t
))
9233 if (TYPE_PTRMEMFUNC_P (t
))
9239 if (!TYPE_TEMPLATE_INFO (t
))
9242 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9246 WALK_SUBTREE (TYPE_MIN_VALUE (t
));
9247 WALK_SUBTREE (TYPE_MAX_VALUE (t
));
9251 /* Since we're not going to walk subtrees, we have to do this
9253 WALK_SUBTREE (TYPE_METHOD_BASETYPE (t
));
9257 /* Check the return type. */
9258 WALK_SUBTREE (TREE_TYPE (t
));
9260 /* Check the parameter types. Since default arguments are not
9261 instantiated until they are needed, the TYPE_ARG_TYPES may
9262 contain expressions that involve template parameters. But,
9263 no-one should be looking at them yet. And, once they're
9264 instantiated, they don't contain template parameters, so
9265 there's no point in looking at them then, either. */
9269 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
9270 WALK_SUBTREE (TREE_VALUE (parm
));
9272 /* Since we've already handled the TYPE_ARG_TYPES, we don't
9273 want walk_tree walking into them itself. */
9277 if (flag_noexcept_type
)
9279 tree spec
= TYPE_RAISES_EXCEPTIONS (t
);
9281 WALK_SUBTREE (TREE_PURPOSE (spec
));
9286 case UNDERLYING_TYPE
:
9287 if (pfd
->include_nondeduced_p
9288 && for_each_template_parm (TYPE_VALUES_RAW (t
), fn
, data
,
9290 pfd
->include_nondeduced_p
,
9292 return error_mark_node
;
9297 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
9298 WALK_SUBTREE (DECL_TI_ARGS (t
));
9303 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
))
9304 WALK_SUBTREE (DECL_INITIAL (t
));
9305 if (DECL_CONTEXT (t
)
9306 && pfd
->include_nondeduced_p
)
9307 WALK_SUBTREE (DECL_CONTEXT (t
));
9310 case BOUND_TEMPLATE_TEMPLATE_PARM
:
9311 /* Record template parameters such as `T' inside `TT<T>'. */
9312 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9315 case TEMPLATE_TEMPLATE_PARM
:
9316 case TEMPLATE_TYPE_PARM
:
9317 case TEMPLATE_PARM_INDEX
:
9318 if (fn
&& (*fn
)(t
, data
))
9325 /* A template template parameter is encountered. */
9326 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9327 WALK_SUBTREE (TREE_TYPE (t
));
9329 /* Already substituted template template parameter */
9334 /* A template-id in a TYPENAME_TYPE might be a deduced context after
9335 partial instantiation. */
9336 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t
));
9340 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
9341 && pfd
->include_nondeduced_p
)
9342 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
9347 /* If there's no type, then this thing must be some expression
9348 involving template parameters. */
9349 if (!fn
&& !TREE_TYPE (t
))
9350 return error_mark_node
;
9355 case IMPLICIT_CONV_EXPR
:
9356 case REINTERPRET_CAST_EXPR
:
9357 case CONST_CAST_EXPR
:
9358 case STATIC_CAST_EXPR
:
9359 case DYNAMIC_CAST_EXPR
:
9363 case PSEUDO_DTOR_EXPR
:
9365 return error_mark_node
;
9374 /* We didn't find any template parameters we liked. */
9379 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
9380 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
9381 call FN with the parameter and the DATA.
9382 If FN returns nonzero, the iteration is terminated, and
9383 for_each_template_parm returns 1. Otherwise, the iteration
9384 continues. If FN never returns a nonzero value, the value
9385 returned by for_each_template_parm is 0. If FN is NULL, it is
9386 considered to be the function which always returns 1.
9388 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
9389 parameters that occur in non-deduced contexts. When false, only
9390 visits those template parameters that can be deduced. */
9393 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
9394 hash_set
<tree
> *visited
,
9395 bool include_nondeduced_p
,
9398 struct pair_fn_data pfd
;
9403 pfd
.any_fn
= any_fn
;
9405 pfd
.include_nondeduced_p
= include_nondeduced_p
;
9407 /* Walk the tree. (Conceptually, we would like to walk without
9408 duplicates, but for_each_template_parm_r recursively calls
9409 for_each_template_parm, so we would need to reorganize a fair
9410 bit to use walk_tree_without_duplicates, so we keep our own
9413 pfd
.visited
= visited
;
9415 pfd
.visited
= new hash_set
<tree
>;
9416 result
= cp_walk_tree (&t
,
9417 for_each_template_parm_r
,
9431 /* Returns true if T depends on any template parameter. */
9434 uses_template_parms (tree t
)
9440 int saved_processing_template_decl
;
9442 saved_processing_template_decl
= processing_template_decl
;
9443 if (!saved_processing_template_decl
)
9444 processing_template_decl
= 1;
9446 dependent_p
= dependent_type_p (t
);
9447 else if (TREE_CODE (t
) == TREE_VEC
)
9448 dependent_p
= any_dependent_template_arguments_p (t
);
9449 else if (TREE_CODE (t
) == TREE_LIST
)
9450 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
9451 || uses_template_parms (TREE_CHAIN (t
)));
9452 else if (TREE_CODE (t
) == TYPE_DECL
)
9453 dependent_p
= dependent_type_p (TREE_TYPE (t
));
9456 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
9457 || TREE_CODE (t
) == OVERLOAD
9460 || TREE_CODE (t
) == TRAIT_EXPR
9461 || TREE_CODE (t
) == CONSTRUCTOR
9462 || CONSTANT_CLASS_P (t
))
9463 dependent_p
= (type_dependent_expression_p (t
)
9464 || value_dependent_expression_p (t
));
9467 gcc_assert (t
== error_mark_node
);
9468 dependent_p
= false;
9471 processing_template_decl
= saved_processing_template_decl
;
9476 /* Returns true iff current_function_decl is an incompletely instantiated
9477 template. Useful instead of processing_template_decl because the latter
9478 is set to 0 during instantiate_non_dependent_expr. */
9481 in_template_function (void)
9483 tree fn
= current_function_decl
;
9485 ++processing_template_decl
;
9486 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
9487 && DECL_TEMPLATE_INFO (fn
)
9488 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
9489 --processing_template_decl
;
9493 /* Returns true if T depends on any template parameter with level LEVEL. */
9496 uses_template_parms_level (tree t
, int level
)
9498 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
9499 /*include_nondeduced_p=*/true);
9502 /* Returns true if the signature of DECL depends on any template parameter from
9503 its enclosing class. */
9506 uses_outer_template_parms (tree decl
)
9508 int depth
= template_class_depth (CP_DECL_CONTEXT (decl
));
9511 if (for_each_template_parm (TREE_TYPE (decl
), template_parm_outer_level
,
9512 &depth
, NULL
, /*include_nondeduced_p=*/true))
9514 if (PRIMARY_TEMPLATE_P (decl
)
9515 && for_each_template_parm (INNERMOST_TEMPLATE_PARMS
9516 (DECL_TEMPLATE_PARMS (decl
)),
9517 template_parm_outer_level
,
9518 &depth
, NULL
, /*include_nondeduced_p=*/true))
9520 tree ci
= get_constraints (decl
);
9522 ci
= CI_ASSOCIATED_CONSTRAINTS (ci
);
9523 if (ci
&& for_each_template_parm (ci
, template_parm_outer_level
,
9524 &depth
, NULL
, /*nondeduced*/true))
9529 /* Returns TRUE iff INST is an instantiation we don't need to do in an
9530 ill-formed translation unit, i.e. a variable or function that isn't
9531 usable in a constant expression. */
9534 neglectable_inst_p (tree d
)
9537 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
9538 : decl_maybe_constant_var_p (d
)));
9541 /* Returns TRUE iff we should refuse to instantiate DECL because it's
9542 neglectable and instantiated from within an erroneous instantiation. */
9545 limit_bad_template_recursion (tree decl
)
9547 struct tinst_level
*lev
= current_tinst_level
;
9548 int errs
= errorcount
+ sorrycount
;
9549 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
9552 for (; lev
; lev
= lev
->next
)
9553 if (neglectable_inst_p (lev
->decl
))
9556 return (lev
&& errs
> lev
->errors
);
9559 static int tinst_depth
;
9560 extern int max_tinst_depth
;
9563 static GTY(()) struct tinst_level
*last_error_tinst_level
;
9565 /* We're starting to instantiate D; record the template instantiation context
9566 for diagnostics and to restore it later. */
9569 push_tinst_level (tree d
)
9571 return push_tinst_level_loc (d
, input_location
);
9574 /* We're starting to instantiate D; record the template instantiation context
9575 at LOC for diagnostics and to restore it later. */
9578 push_tinst_level_loc (tree d
, location_t loc
)
9580 struct tinst_level
*new_level
;
9582 if (tinst_depth
>= max_tinst_depth
)
9584 /* Tell error.c not to try to instantiate any templates. */
9586 fatal_error (input_location
,
9587 "template instantiation depth exceeds maximum of %d"
9588 " (use -ftemplate-depth= to increase the maximum)",
9593 /* If the current instantiation caused problems, don't let it instantiate
9594 anything else. Do allow deduction substitution and decls usable in
9595 constant expressions. */
9596 if (limit_bad_template_recursion (d
))
9599 /* When not -quiet, dump template instantiations other than functions, since
9600 announce_function will take care of those. */
9602 && TREE_CODE (d
) != TREE_LIST
9603 && TREE_CODE (d
) != FUNCTION_DECL
)
9604 fprintf (stderr
, " %s", decl_as_string (d
, TFF_DECL_SPECIFIERS
));
9606 new_level
= ggc_alloc
<tinst_level
> ();
9607 new_level
->decl
= d
;
9608 new_level
->locus
= loc
;
9609 new_level
->errors
= errorcount
+sorrycount
;
9610 new_level
->in_system_header_p
= in_system_header_at (input_location
);
9611 new_level
->next
= current_tinst_level
;
9612 current_tinst_level
= new_level
;
9615 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
9616 depth_reached
= tinst_depth
;
9621 /* We're done instantiating this template; return to the instantiation
9625 pop_tinst_level (void)
9627 /* Restore the filename and line number stashed away when we started
9628 this instantiation. */
9629 input_location
= current_tinst_level
->locus
;
9630 current_tinst_level
= current_tinst_level
->next
;
9634 /* We're instantiating a deferred template; restore the template
9635 instantiation context in which the instantiation was requested, which
9636 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
9639 reopen_tinst_level (struct tinst_level
*level
)
9641 struct tinst_level
*t
;
9644 for (t
= level
; t
; t
= t
->next
)
9647 current_tinst_level
= level
;
9649 if (current_tinst_level
)
9650 current_tinst_level
->errors
= errorcount
+sorrycount
;
9654 /* Returns the TINST_LEVEL which gives the original instantiation
9657 struct tinst_level
*
9658 outermost_tinst_level (void)
9660 struct tinst_level
*level
= current_tinst_level
;
9663 level
= level
->next
;
9667 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
9668 vector of template arguments, as for tsubst.
9670 Returns an appropriate tsubst'd friend declaration. */
9673 tsubst_friend_function (tree decl
, tree args
)
9677 if (TREE_CODE (decl
) == FUNCTION_DECL
9678 && DECL_TEMPLATE_INSTANTIATION (decl
)
9679 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
9680 /* This was a friend declared with an explicit template
9681 argument list, e.g.:
9685 to indicate that f was a template instantiation, not a new
9686 function declaration. Now, we have to figure out what
9687 instantiation of what template. */
9689 tree template_id
, arglist
, fns
;
9692 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
9694 /* Friend functions are looked up in the containing namespace scope.
9695 We must enter that scope, to avoid finding member functions of the
9696 current class with same name. */
9697 push_nested_namespace (ns
);
9698 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
9699 tf_warning_or_error
, NULL_TREE
,
9700 /*integral_constant_expression_p=*/false);
9701 pop_nested_namespace (ns
);
9702 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
9703 tf_warning_or_error
, NULL_TREE
);
9704 template_id
= lookup_template_function (fns
, arglist
);
9706 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
9707 tmpl
= determine_specialization (template_id
, new_friend
,
9709 /*need_member_template=*/0,
9710 TREE_VEC_LENGTH (args
),
9712 return instantiate_template (tmpl
, new_args
, tf_error
);
9715 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
9717 /* The NEW_FRIEND will look like an instantiation, to the
9718 compiler, but is not an instantiation from the point of view of
9719 the language. For example, we might have had:
9721 template <class T> struct S {
9722 template <class U> friend void f(T, U);
9725 Then, in S<int>, template <class U> void f(int, U) is not an
9726 instantiation of anything. */
9727 if (new_friend
== error_mark_node
)
9728 return error_mark_node
;
9730 DECL_USE_TEMPLATE (new_friend
) = 0;
9731 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
9733 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
9734 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
9735 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
9738 /* The mangled name for the NEW_FRIEND is incorrect. The function
9739 is not a template instantiation and should not be mangled like
9740 one. Therefore, we forget the mangling here; we'll recompute it
9741 later if we need it. */
9742 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
9744 SET_DECL_RTL (new_friend
, NULL
);
9745 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
9748 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
9751 tree new_friend_template_info
;
9752 tree new_friend_result_template_info
;
9754 int new_friend_is_defn
;
9756 /* We must save some information from NEW_FRIEND before calling
9757 duplicate decls since that function will free NEW_FRIEND if
9759 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
9760 new_friend_is_defn
=
9761 (DECL_INITIAL (DECL_TEMPLATE_RESULT
9762 (template_for_substitution (new_friend
)))
9764 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
9766 /* This declaration is a `primary' template. */
9767 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
9769 new_friend_result_template_info
9770 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
9773 new_friend_result_template_info
= NULL_TREE
;
9775 /* Inside pushdecl_namespace_level, we will push into the
9776 current namespace. However, the friend function should go
9777 into the namespace of the template. */
9778 ns
= decl_namespace_context (new_friend
);
9779 push_nested_namespace (ns
);
9780 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
9781 pop_nested_namespace (ns
);
9783 if (old_decl
== error_mark_node
)
9784 return error_mark_node
;
9786 if (old_decl
!= new_friend
)
9788 /* This new friend declaration matched an existing
9789 declaration. For example, given:
9791 template <class T> void f(T);
9792 template <class U> class C {
9793 template <class T> friend void f(T) {}
9796 the friend declaration actually provides the definition
9797 of `f', once C has been instantiated for some type. So,
9798 old_decl will be the out-of-class template declaration,
9799 while new_friend is the in-class definition.
9801 But, if `f' was called before this point, the
9802 instantiation of `f' will have DECL_TI_ARGS corresponding
9803 to `T' but not to `U', references to which might appear
9804 in the definition of `f'. Previously, the most general
9805 template for an instantiation of `f' was the out-of-class
9806 version; now it is the in-class version. Therefore, we
9807 run through all specialization of `f', adding to their
9808 DECL_TI_ARGS appropriately. In particular, they need a
9809 new set of outer arguments, corresponding to the
9810 arguments for this class instantiation.
9812 The same situation can arise with something like this:
9815 template <class T> class C {
9819 when `C<int>' is instantiated. Now, `f(int)' is defined
9822 if (!new_friend_is_defn
)
9823 /* On the other hand, if the in-class declaration does
9824 *not* provide a definition, then we don't want to alter
9825 existing definitions. We can just leave everything
9830 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
9831 tree new_args
= TI_ARGS (new_friend_template_info
);
9833 /* Overwrite whatever template info was there before, if
9834 any, with the new template information pertaining to
9836 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
9838 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
9840 /* We should have called reregister_specialization in
9842 gcc_assert (retrieve_specialization (new_template
,
9846 /* Instantiate it if the global has already been used. */
9847 if (DECL_ODR_USED (old_decl
))
9848 instantiate_decl (old_decl
, /*defer_ok=*/true,
9849 /*expl_inst_class_mem_p=*/false);
9855 /* Indicate that the old function template is a partial
9857 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
9858 = new_friend_result_template_info
;
9860 gcc_assert (new_template
9861 == most_general_template (new_template
));
9862 gcc_assert (new_template
!= old_decl
);
9864 /* Reassign any specializations already in the hash table
9865 to the new more general template, and add the
9866 additional template args. */
9867 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
9871 tree spec
= TREE_VALUE (t
);
9874 elt
.tmpl
= old_decl
;
9875 elt
.args
= DECL_TI_ARGS (spec
);
9876 elt
.spec
= NULL_TREE
;
9878 decl_specializations
->remove_elt (&elt
);
9881 = add_outermost_template_args (new_args
,
9882 DECL_TI_ARGS (spec
));
9884 register_specialization
9885 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
9888 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
9892 /* The information from NEW_FRIEND has been merged into OLD_DECL
9893 by duplicate_decls. */
9894 new_friend
= old_decl
;
9899 tree context
= DECL_CONTEXT (new_friend
);
9903 template <class T> class C {
9904 template <class U> friend void C1<U>::f (); // case 1
9905 friend void C2<T>::f (); // case 2
9907 we only need to make sure CONTEXT is a complete type for
9908 case 2. To distinguish between the two cases, we note that
9909 CONTEXT of case 1 remains dependent type after tsubst while
9910 this isn't true for case 2. */
9911 ++processing_template_decl
;
9912 dependent_p
= dependent_type_p (context
);
9913 --processing_template_decl
;
9916 && !complete_type_or_else (context
, NULL_TREE
))
9917 return error_mark_node
;
9919 if (COMPLETE_TYPE_P (context
))
9921 tree fn
= new_friend
;
9922 /* do_friend adds the TEMPLATE_DECL for any member friend
9923 template even if it isn't a member template, i.e.
9924 template <class T> friend A<T>::f();
9925 Look through it in that case. */
9926 if (TREE_CODE (fn
) == TEMPLATE_DECL
9927 && !PRIMARY_TEMPLATE_P (fn
))
9928 fn
= DECL_TEMPLATE_RESULT (fn
);
9929 /* Check to see that the declaration is really present, and,
9930 possibly obtain an improved declaration. */
9931 fn
= check_classfn (context
, fn
, NULL_TREE
);
9941 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
9942 template arguments, as for tsubst.
9944 Returns an appropriate tsubst'd friend type or error_mark_node on
9948 tsubst_friend_class (tree friend_tmpl
, tree args
)
9954 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
9956 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
9957 return TREE_TYPE (t
);
9960 context
= CP_DECL_CONTEXT (friend_tmpl
);
9962 if (context
!= global_namespace
)
9964 if (TREE_CODE (context
) == NAMESPACE_DECL
)
9965 push_nested_namespace (context
);
9967 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
9970 /* Look for a class template declaration. We look for hidden names
9971 because two friend declarations of the same template are the
9972 same. For example, in:
9975 template <typename> friend class F;
9977 template <typename> struct B {
9978 template <typename> friend class F;
9981 both F templates are the same. */
9982 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
9983 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
9985 /* But, if we don't find one, it might be because we're in a
9986 situation like this:
9994 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
9995 for `S<int>', not the TEMPLATE_DECL. */
9996 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
9998 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
9999 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
10002 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
10004 /* The friend template has already been declared. Just
10005 check to see that the declarations match, and install any new
10006 default parameters. We must tsubst the default parameters,
10007 of course. We only need the innermost template parameters
10008 because that is all that redeclare_class_template will look
10010 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
10011 > TMPL_ARGS_DEPTH (args
))
10014 location_t saved_input_location
;
10015 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
10016 args
, tf_warning_or_error
);
10018 saved_input_location
= input_location
;
10019 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
10020 tree cons
= get_constraints (tmpl
);
10021 redeclare_class_template (TREE_TYPE (tmpl
), parms
, cons
);
10022 input_location
= saved_input_location
;
10026 friend_type
= TREE_TYPE (tmpl
);
10030 /* The friend template has not already been declared. In this
10031 case, the instantiation of the template class will cause the
10032 injection of this template into the global scope. */
10033 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
10034 if (tmpl
== error_mark_node
)
10035 return error_mark_node
;
10037 /* The new TMPL is not an instantiation of anything, so we
10038 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
10039 the new type because that is supposed to be the corresponding
10040 template decl, i.e., TMPL. */
10041 DECL_USE_TEMPLATE (tmpl
) = 0;
10042 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
10043 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
10044 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
10045 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
10047 /* Inject this template into the global scope. */
10048 friend_type
= TREE_TYPE (pushdecl_top_level (tmpl
, true));
10051 if (context
!= global_namespace
)
10053 if (TREE_CODE (context
) == NAMESPACE_DECL
)
10054 pop_nested_namespace (context
);
10056 pop_nested_class ();
10059 return friend_type
;
10062 /* Returns zero if TYPE cannot be completed later due to circularity.
10063 Otherwise returns one. */
10066 can_complete_type_without_circularity (tree type
)
10068 if (type
== NULL_TREE
|| type
== error_mark_node
)
10070 else if (COMPLETE_TYPE_P (type
))
10072 else if (TREE_CODE (type
) == ARRAY_TYPE
)
10073 return can_complete_type_without_circularity (TREE_TYPE (type
));
10074 else if (CLASS_TYPE_P (type
)
10075 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
10081 static tree
tsubst_omp_clauses (tree
, enum c_omp_region_type
, tree
,
10082 tsubst_flags_t
, tree
);
10084 /* Instantiate a single dependent attribute T (a TREE_LIST), and return either
10085 T or a new TREE_LIST, possibly a chain in the case of a pack expansion. */
10088 tsubst_attribute (tree t
, tree
*decl_p
, tree args
,
10089 tsubst_flags_t complain
, tree in_decl
)
10091 gcc_assert (ATTR_IS_DEPENDENT (t
));
10093 tree val
= TREE_VALUE (t
);
10094 if (val
== NULL_TREE
)
10095 /* Nothing to do. */;
10096 else if ((flag_openmp
|| flag_openmp_simd
|| flag_cilkplus
)
10097 && is_attribute_p ("omp declare simd",
10098 get_attribute_name (t
)))
10100 tree clauses
= TREE_VALUE (val
);
10101 clauses
= tsubst_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
, args
,
10102 complain
, in_decl
);
10103 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
10104 clauses
= finish_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
);
10105 tree parms
= DECL_ARGUMENTS (*decl_p
);
10107 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
10109 val
= build_tree_list (NULL_TREE
, clauses
);
10113 /* If the first attribute argument is an identifier, don't
10114 pass it through tsubst. Attributes like mode, format,
10115 cleanup and several target specific attributes expect it
10117 else if (attribute_takes_identifier_p (get_attribute_name (t
)))
10120 = tsubst_expr (TREE_CHAIN (val
), args
, complain
, in_decl
,
10121 /*integral_constant_expression_p=*/false);
10122 if (chain
!= TREE_CHAIN (val
))
10123 val
= tree_cons (NULL_TREE
, TREE_VALUE (val
), chain
);
10125 else if (PACK_EXPANSION_P (val
))
10127 /* An attribute pack expansion. */
10128 tree purp
= TREE_PURPOSE (t
);
10129 tree pack
= tsubst_pack_expansion (val
, args
, complain
, in_decl
);
10130 if (pack
== error_mark_node
)
10131 return error_mark_node
;
10132 int len
= TREE_VEC_LENGTH (pack
);
10133 tree list
= NULL_TREE
;
10135 for (int i
= 0; i
< len
; ++i
)
10137 tree elt
= TREE_VEC_ELT (pack
, i
);
10138 *q
= build_tree_list (purp
, elt
);
10139 q
= &TREE_CHAIN (*q
);
10144 val
= tsubst_expr (val
, args
, complain
, in_decl
,
10145 /*integral_constant_expression_p=*/false);
10147 if (val
!= TREE_VALUE (t
))
10148 return build_tree_list (TREE_PURPOSE (t
), val
);
10152 /* Instantiate any dependent attributes in ATTRIBUTES, returning either it
10153 unchanged or a new TREE_LIST chain. */
10156 tsubst_attributes (tree attributes
, tree args
,
10157 tsubst_flags_t complain
, tree in_decl
)
10159 tree last_dep
= NULL_TREE
;
10161 for (tree t
= attributes
; t
; t
= TREE_CHAIN (t
))
10162 if (ATTR_IS_DEPENDENT (t
))
10165 attributes
= copy_list (attributes
);
10170 for (tree
*p
= &attributes
; *p
; )
10173 if (ATTR_IS_DEPENDENT (t
))
10175 tree subst
= tsubst_attribute (t
, NULL
, args
, complain
, in_decl
);
10180 p
= &TREE_CHAIN (*p
);
10182 *p
= TREE_CHAIN (t
);
10186 p
= &TREE_CHAIN (*p
);
10192 /* Apply any attributes which had to be deferred until instantiation
10193 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
10194 ARGS, COMPLAIN, IN_DECL are as tsubst. */
10197 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
10198 tree args
, tsubst_flags_t complain
, tree in_decl
)
10200 tree last_dep
= NULL_TREE
;
10204 if (attributes
== NULL_TREE
)
10207 if (DECL_P (*decl_p
))
10209 if (TREE_TYPE (*decl_p
) == error_mark_node
)
10211 p
= &DECL_ATTRIBUTES (*decl_p
);
10212 /* DECL_ATTRIBUTES comes from copy_node in tsubst_decl, and is identical
10213 to our attributes parameter. */
10214 gcc_assert (*p
== attributes
);
10218 p
= &TYPE_ATTRIBUTES (*decl_p
);
10219 /* TYPE_ATTRIBUTES was set up (with abi_tag and may_alias) in
10220 lookup_template_class_1, and should be preserved. */
10221 gcc_assert (*p
!= attributes
);
10223 p
= &TREE_CHAIN (*p
);
10226 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
10227 if (ATTR_IS_DEPENDENT (t
))
10230 attributes
= copy_list (attributes
);
10237 tree late_attrs
= NULL_TREE
;
10238 tree
*q
= &late_attrs
;
10243 if (ATTR_IS_DEPENDENT (t
))
10245 *p
= TREE_CHAIN (t
);
10246 TREE_CHAIN (t
) = NULL_TREE
;
10247 *q
= tsubst_attribute (t
, decl_p
, args
, complain
, in_decl
);
10249 q
= &TREE_CHAIN (*q
);
10253 p
= &TREE_CHAIN (t
);
10256 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
10260 /* Perform (or defer) access check for typedefs that were referenced
10261 from within the template TMPL code.
10262 This is a subroutine of instantiate_decl and instantiate_class_template.
10263 TMPL is the template to consider and TARGS is the list of arguments of
10267 perform_typedefs_access_check (tree tmpl
, tree targs
)
10269 location_t saved_location
;
10271 qualified_typedef_usage_t
*iter
;
10274 || (!CLASS_TYPE_P (tmpl
)
10275 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
10278 saved_location
= input_location
;
10279 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
10281 tree type_decl
= iter
->typedef_decl
;
10282 tree type_scope
= iter
->context
;
10284 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
10287 if (uses_template_parms (type_decl
))
10288 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
10289 if (uses_template_parms (type_scope
))
10290 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
10292 /* Make access check error messages point to the location
10293 of the use of the typedef. */
10294 input_location
= iter
->locus
;
10295 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
10296 type_decl
, type_decl
,
10297 tf_warning_or_error
);
10299 input_location
= saved_location
;
10303 instantiate_class_template_1 (tree type
)
10305 tree templ
, args
, pattern
, t
, member
;
10309 unsigned int saved_maximum_field_alignment
;
10312 if (type
== error_mark_node
)
10313 return error_mark_node
;
10315 if (COMPLETE_OR_OPEN_TYPE_P (type
)
10316 || uses_template_parms (type
))
10319 /* Figure out which template is being instantiated. */
10320 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
10321 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
10323 /* Determine what specialization of the original template to
10325 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
10326 if (t
== error_mark_node
)
10328 TYPE_BEING_DEFINED (type
) = 1;
10329 return error_mark_node
;
10333 /* This TYPE is actually an instantiation of a partial
10334 specialization. We replace the innermost set of ARGS with
10335 the arguments appropriate for substitution. For example,
10338 template <class T> struct S {};
10339 template <class T> struct S<T*> {};
10341 and supposing that we are instantiating S<int*>, ARGS will
10342 presently be {int*} -- but we need {int}. */
10343 pattern
= TREE_TYPE (t
);
10344 args
= TREE_PURPOSE (t
);
10348 pattern
= TREE_TYPE (templ
);
10349 args
= CLASSTYPE_TI_ARGS (type
);
10352 /* If the template we're instantiating is incomplete, then clearly
10353 there's nothing we can do. */
10354 if (!COMPLETE_TYPE_P (pattern
))
10357 /* If we've recursively instantiated too many templates, stop. */
10358 if (! push_tinst_level (type
))
10361 /* Now we're really doing the instantiation. Mark the type as in
10362 the process of being defined. */
10363 TYPE_BEING_DEFINED (type
) = 1;
10365 /* We may be in the middle of deferred access check. Disable
10367 push_deferring_access_checks (dk_no_deferred
);
10369 int saved_unevaluated_operand
= cp_unevaluated_operand
;
10370 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10372 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
10373 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
10374 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
10375 fn_context
= error_mark_node
;
10377 push_to_top_level ();
10380 cp_unevaluated_operand
= 0;
10381 c_inhibit_evaluation_warnings
= 0;
10383 /* Use #pragma pack from the template context. */
10384 saved_maximum_field_alignment
= maximum_field_alignment
;
10385 maximum_field_alignment
= TYPE_PRECISION (pattern
);
10387 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
10389 /* Set the input location to the most specialized template definition.
10390 This is needed if tsubsting causes an error. */
10391 typedecl
= TYPE_MAIN_DECL (pattern
);
10392 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
10393 DECL_SOURCE_LOCATION (typedecl
);
10395 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
10396 SET_TYPE_ALIGN (type
, TYPE_ALIGN (pattern
));
10397 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
10398 CLASSTYPE_NON_AGGREGATE (type
) = CLASSTYPE_NON_AGGREGATE (pattern
);
10399 if (ANON_AGGR_TYPE_P (pattern
))
10400 SET_ANON_AGGR_TYPE_P (type
);
10401 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
10403 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
10404 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
10405 /* Adjust visibility for template arguments. */
10406 determine_visibility (TYPE_MAIN_DECL (type
));
10408 if (CLASS_TYPE_P (type
))
10409 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
10411 pbinfo
= TYPE_BINFO (pattern
);
10413 /* We should never instantiate a nested class before its enclosing
10414 class; we need to look up the nested class by name before we can
10415 instantiate it, and that lookup should instantiate the enclosing
10417 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
10418 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
10420 base_list
= NULL_TREE
;
10421 if (BINFO_N_BASE_BINFOS (pbinfo
))
10427 /* We must enter the scope containing the type, as that is where
10428 the accessibility of types named in dependent bases are
10430 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
10432 /* Substitute into each of the bases to determine the actual
10434 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
10437 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
10438 tree expanded_bases
= NULL_TREE
;
10441 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
10444 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
10445 args
, tf_error
, NULL_TREE
);
10446 if (expanded_bases
== error_mark_node
)
10449 len
= TREE_VEC_LENGTH (expanded_bases
);
10452 for (idx
= 0; idx
< len
; idx
++)
10454 if (expanded_bases
)
10455 /* Extract the already-expanded base class. */
10456 base
= TREE_VEC_ELT (expanded_bases
, idx
);
10458 /* Substitute to figure out the base class. */
10459 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
10462 if (base
== error_mark_node
)
10465 base_list
= tree_cons (access
, base
, base_list
);
10466 if (BINFO_VIRTUAL_P (pbase_binfo
))
10467 TREE_TYPE (base_list
) = integer_type_node
;
10471 /* The list is now in reverse order; correct that. */
10472 base_list
= nreverse (base_list
);
10475 pop_scope (pushed_scope
);
10477 /* Now call xref_basetypes to set up all the base-class
10479 xref_basetypes (type
, base_list
);
10481 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
10482 (int) ATTR_FLAG_TYPE_IN_PLACE
,
10483 args
, tf_error
, NULL_TREE
);
10484 fixup_attribute_variants (type
);
10486 /* Now that our base classes are set up, enter the scope of the
10487 class, so that name lookups into base classes, etc. will work
10488 correctly. This is precisely analogous to what we do in
10489 begin_class_definition when defining an ordinary non-template
10490 class, except we also need to push the enclosing classes. */
10491 push_nested_class (type
);
10493 /* Now members are processed in the order of declaration. */
10494 for (member
= CLASSTYPE_DECL_LIST (pattern
);
10495 member
; member
= TREE_CHAIN (member
))
10497 tree t
= TREE_VALUE (member
);
10499 if (TREE_PURPOSE (member
))
10503 /* Build new CLASSTYPE_NESTED_UTDS. */
10506 bool class_template_p
;
10508 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
10509 && TYPE_LANG_SPECIFIC (t
)
10510 && CLASSTYPE_IS_TEMPLATE (t
));
10511 /* If the member is a class template, then -- even after
10512 substitution -- there may be dependent types in the
10513 template argument list for the class. We increment
10514 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
10515 that function will assume that no types are dependent
10516 when outside of a template. */
10517 if (class_template_p
)
10518 ++processing_template_decl
;
10519 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
10520 if (class_template_p
)
10521 --processing_template_decl
;
10522 if (newtag
== error_mark_node
)
10525 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
10527 tree name
= TYPE_IDENTIFIER (t
);
10529 if (class_template_p
)
10530 /* Unfortunately, lookup_template_class sets
10531 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
10532 instantiation (i.e., for the type of a member
10533 template class nested within a template class.)
10534 This behavior is required for
10535 maybe_process_partial_specialization to work
10536 correctly, but is not accurate in this case;
10537 the TAG is not an instantiation of anything.
10538 (The corresponding TEMPLATE_DECL is an
10539 instantiation, but the TYPE is not.) */
10540 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
10542 /* Now, we call pushtag to put this NEWTAG into the scope of
10543 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
10544 pushtag calling push_template_decl. We don't have to do
10545 this for enums because it will already have been done in
10548 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
10549 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
10552 else if (DECL_DECLARES_FUNCTION_P (t
))
10556 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10557 ++processing_template_decl
;
10558 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
10559 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10560 --processing_template_decl
;
10561 set_current_access_from_decl (r
);
10562 finish_member_declaration (r
);
10563 /* Instantiate members marked with attribute used. */
10564 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
10566 if (TREE_CODE (r
) == FUNCTION_DECL
10567 && DECL_OMP_DECLARE_REDUCTION_P (r
))
10568 cp_check_omp_declare_reduction (r
);
10570 else if (DECL_CLASS_TEMPLATE_P (t
)
10571 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
10572 /* A closure type for a lambda in a default argument for a
10573 member template. Ignore it; it will be instantiated with
10574 the default argument. */;
10577 /* Build new TYPE_FIELDS. */
10578 if (TREE_CODE (t
) == STATIC_ASSERT
)
10582 ++c_inhibit_evaluation_warnings
;
10584 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
10585 tf_warning_or_error
, NULL_TREE
,
10586 /*integral_constant_expression_p=*/true);
10587 --c_inhibit_evaluation_warnings
;
10589 finish_static_assert (condition
,
10590 STATIC_ASSERT_MESSAGE (t
),
10591 STATIC_ASSERT_SOURCE_LOCATION (t
),
10592 /*member_p=*/true);
10594 else if (TREE_CODE (t
) != CONST_DECL
)
10597 tree vec
= NULL_TREE
;
10600 /* The file and line for this declaration, to
10601 assist in error message reporting. Since we
10602 called push_tinst_level above, we don't need to
10604 input_location
= DECL_SOURCE_LOCATION (t
);
10606 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10607 ++processing_template_decl
;
10608 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
10609 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10610 --processing_template_decl
;
10612 if (TREE_CODE (r
) == TREE_VEC
)
10614 /* A capture pack became multiple fields. */
10616 len
= TREE_VEC_LENGTH (vec
);
10619 for (int i
= 0; i
< len
; ++i
)
10622 r
= TREE_VEC_ELT (vec
, i
);
10627 [t]he initialization (and any associated
10628 side-effects) of a static data member does
10629 not occur unless the static data member is
10630 itself used in a way that requires the
10631 definition of the static data member to
10634 Therefore, we do not substitute into the
10635 initialized for the static data member here. */
10636 finish_static_data_member_decl
10638 /*init=*/NULL_TREE
,
10639 /*init_const_expr_p=*/false,
10640 /*asmspec_tree=*/NULL_TREE
,
10642 /* Instantiate members marked with attribute used. */
10643 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
10646 else if (TREE_CODE (r
) == FIELD_DECL
)
10648 /* Determine whether R has a valid type and can be
10649 completed later. If R is invalid, then its type
10650 is replaced by error_mark_node. */
10651 tree rtype
= TREE_TYPE (r
);
10652 if (can_complete_type_without_circularity (rtype
))
10653 complete_type (rtype
);
10655 if (!complete_or_array_type_p (rtype
))
10657 /* If R's type couldn't be completed and
10658 it isn't a flexible array member (whose
10659 type is incomplete by definition) give
10661 cxx_incomplete_type_error (r
, rtype
);
10662 TREE_TYPE (r
) = error_mark_node
;
10666 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
10667 such a thing will already have been added to the field
10668 list by tsubst_enum in finish_member_declaration in the
10669 CLASSTYPE_NESTED_UTDS case above. */
10670 if (!(TREE_CODE (r
) == TYPE_DECL
10671 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
10672 && DECL_ARTIFICIAL (r
)))
10674 set_current_access_from_decl (r
);
10675 finish_member_declaration (r
);
10683 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
10684 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10686 /* Build new CLASSTYPE_FRIEND_CLASSES. */
10688 tree friend_type
= t
;
10689 bool adjust_processing_template_decl
= false;
10691 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
10693 /* template <class T> friend class C; */
10694 friend_type
= tsubst_friend_class (friend_type
, args
);
10695 adjust_processing_template_decl
= true;
10697 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
10699 /* template <class T> friend class C::D; */
10700 friend_type
= tsubst (friend_type
, args
,
10701 tf_warning_or_error
, NULL_TREE
);
10702 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
10703 friend_type
= TREE_TYPE (friend_type
);
10704 adjust_processing_template_decl
= true;
10706 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
10707 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
10709 /* This could be either
10713 when dependent_type_p is false or
10715 template <class U> friend class T::C;
10718 /* Bump processing_template_decl in case this is something like
10719 template <class T> friend struct A<T>::B. */
10720 ++processing_template_decl
;
10721 friend_type
= tsubst (friend_type
, args
,
10722 tf_warning_or_error
, NULL_TREE
);
10723 if (dependent_type_p (friend_type
))
10724 adjust_processing_template_decl
= true;
10725 --processing_template_decl
;
10727 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
10728 && TYPE_HIDDEN_P (friend_type
))
10732 where C hasn't been declared yet. Let's lookup name
10733 from namespace scope directly, bypassing any name that
10734 come from dependent base class. */
10735 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
10737 /* The call to xref_tag_from_type does injection for friend
10739 push_nested_namespace (ns
);
10741 xref_tag_from_type (friend_type
, NULL_TREE
,
10742 /*tag_scope=*/ts_current
);
10743 pop_nested_namespace (ns
);
10745 else if (uses_template_parms (friend_type
))
10746 /* friend class C<T>; */
10747 friend_type
= tsubst (friend_type
, args
,
10748 tf_warning_or_error
, NULL_TREE
);
10753 where C is already declared or
10755 friend class C<int>;
10757 We don't have to do anything in these cases. */
10759 if (adjust_processing_template_decl
)
10760 /* Trick make_friend_class into realizing that the friend
10761 we're adding is a template, not an ordinary class. It's
10762 important that we use make_friend_class since it will
10763 perform some error-checking and output cross-reference
10765 ++processing_template_decl
;
10767 if (friend_type
!= error_mark_node
)
10768 make_friend_class (type
, friend_type
, /*complain=*/false);
10770 if (adjust_processing_template_decl
)
10771 --processing_template_decl
;
10775 /* Build new DECL_FRIENDLIST. */
10778 /* The file and line for this declaration, to
10779 assist in error message reporting. Since we
10780 called push_tinst_level above, we don't need to
10782 input_location
= DECL_SOURCE_LOCATION (t
);
10784 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10786 ++processing_template_decl
;
10787 push_deferring_access_checks (dk_no_check
);
10790 r
= tsubst_friend_function (t
, args
);
10791 add_friend (type
, r
, /*complain=*/false);
10792 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10794 pop_deferring_access_checks ();
10795 --processing_template_decl
;
10803 /* Restore these before substituting into the lambda capture
10805 cp_unevaluated_operand
= saved_unevaluated_operand
;
10806 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10809 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
10811 tree decl
= lambda_function (type
);
10814 if (cxx_dialect
>= cxx1z
)
10815 CLASSTYPE_LITERAL_P (type
) = true;
10817 if (!DECL_TEMPLATE_INFO (decl
)
10818 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
10820 /* Set function_depth to avoid garbage collection. */
10822 instantiate_decl (decl
, /*defer_ok=*/false, false);
10826 /* We need to instantiate the capture list from the template
10827 after we've instantiated the closure members, but before we
10828 consider adding the conversion op. Also keep any captures
10829 that may have been added during instantiation of the op(). */
10830 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
10832 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
10833 args
, tf_warning_or_error
, NULL_TREE
,
10836 LAMBDA_EXPR_CAPTURE_LIST (expr
)
10837 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
10839 maybe_add_lambda_conv_op (type
);
10842 gcc_assert (errorcount
);
10845 /* Set the file and line number information to whatever is given for
10846 the class itself. This puts error messages involving generated
10847 implicit functions at a predictable point, and the same point
10848 that would be used for non-template classes. */
10849 input_location
= DECL_SOURCE_LOCATION (typedecl
);
10851 unreverse_member_declarations (type
);
10852 finish_struct_1 (type
);
10853 TYPE_BEING_DEFINED (type
) = 0;
10855 /* We don't instantiate default arguments for member functions. 14.7.1:
10857 The implicit instantiation of a class template specialization causes
10858 the implicit instantiation of the declarations, but not of the
10859 definitions or default arguments, of the class member functions,
10860 member classes, static data members and member templates.... */
10862 /* Some typedefs referenced from within the template code need to be access
10863 checked at template instantiation time, i.e now. These types were
10864 added to the template at parsing time. Let's get those and perform
10865 the access checks then. */
10866 perform_typedefs_access_check (pattern
, args
);
10867 perform_deferred_access_checks (tf_warning_or_error
);
10868 pop_nested_class ();
10869 maximum_field_alignment
= saved_maximum_field_alignment
;
10871 pop_from_top_level ();
10872 pop_deferring_access_checks ();
10873 pop_tinst_level ();
10875 /* The vtable for a template class can be emitted in any translation
10876 unit in which the class is instantiated. When there is no key
10877 method, however, finish_struct_1 will already have added TYPE to
10878 the keyed_classes. */
10879 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
10880 vec_safe_push (keyed_classes
, type
);
10885 /* Wrapper for instantiate_class_template_1. */
10888 instantiate_class_template (tree type
)
10891 timevar_push (TV_TEMPLATE_INST
);
10892 ret
= instantiate_class_template_1 (type
);
10893 timevar_pop (TV_TEMPLATE_INST
);
10898 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10904 else if (TYPE_P (t
))
10905 r
= tsubst (t
, args
, complain
, in_decl
);
10908 if (!(complain
& tf_warning
))
10909 ++c_inhibit_evaluation_warnings
;
10910 r
= tsubst_expr (t
, args
, complain
, in_decl
,
10911 /*integral_constant_expression_p=*/true);
10912 if (!(complain
& tf_warning
))
10913 --c_inhibit_evaluation_warnings
;
10918 /* Given a function parameter pack TMPL_PARM and some function parameters
10919 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
10920 and set *SPEC_P to point at the next point in the list. */
10923 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
10925 /* Collect all of the extra "packed" parameters into an
10928 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
10929 tree spec_parm
= *spec_p
;
10932 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
10934 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
10937 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
10938 parmvec
= make_tree_vec (len
);
10939 spec_parm
= *spec_p
;
10940 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
10941 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
10943 /* Build the argument packs. */
10944 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
10945 *spec_p
= spec_parm
;
10950 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
10951 NONTYPE_ARGUMENT_PACK. */
10954 make_fnparm_pack (tree spec_parm
)
10956 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
10959 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
10960 pack expansion with no extra args, 2 if it has extra args, or 0
10961 if it is not a pack expansion. */
10964 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
10966 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
10967 if (i
>= TREE_VEC_LENGTH (vec
))
10969 tree elt
= TREE_VEC_ELT (vec
, i
);
10971 /* A decl pack is itself an expansion. */
10972 elt
= TREE_TYPE (elt
);
10973 if (!PACK_EXPANSION_P (elt
))
10975 if (PACK_EXPANSION_EXTRA_ARGS (elt
))
10981 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
10984 make_argument_pack_select (tree arg_pack
, unsigned index
)
10986 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
10988 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
10989 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
10994 /* This is a subroutine of tsubst_pack_expansion.
10996 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
10997 mechanism to store the (non complete list of) arguments of the
10998 substitution and return a non substituted pack expansion, in order
10999 to wait for when we have enough arguments to really perform the
11003 use_pack_expansion_extra_args_p (tree parm_packs
,
11005 bool has_empty_arg
)
11007 /* If one pack has an expansion and another pack has a normal
11008 argument or if one pack has an empty argument and an another
11009 one hasn't then tsubst_pack_expansion cannot perform the
11010 substitution and need to fall back on the
11011 PACK_EXPANSION_EXTRA mechanism. */
11012 if (parm_packs
== NULL_TREE
)
11014 else if (has_empty_arg
)
11017 bool has_expansion_arg
= false;
11018 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
11020 bool has_non_expansion_arg
= false;
11021 for (tree parm_pack
= parm_packs
;
11023 parm_pack
= TREE_CHAIN (parm_pack
))
11025 tree arg
= TREE_VALUE (parm_pack
);
11027 int exp
= argument_pack_element_is_expansion_p (arg
, i
);
11029 /* We can't substitute a pack expansion with extra args into
11033 has_expansion_arg
= true;
11035 has_non_expansion_arg
= true;
11038 if (has_expansion_arg
&& has_non_expansion_arg
)
11044 /* [temp.variadic]/6 says that:
11046 The instantiation of a pack expansion [...]
11047 produces a list E1,E2, ..., En, where N is the number of elements
11048 in the pack expansion parameters.
11050 This subroutine of tsubst_pack_expansion produces one of these Ei.
11052 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
11053 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
11054 PATTERN, and each TREE_VALUE is its corresponding argument pack.
11055 INDEX is the index 'i' of the element Ei to produce. ARGS,
11056 COMPLAIN, and IN_DECL are the same parameters as for the
11057 tsubst_pack_expansion function.
11059 The function returns the resulting Ei upon successful completion,
11060 or error_mark_node.
11062 Note that this function possibly modifies the ARGS parameter, so
11063 it's the responsibility of the caller to restore it. */
11066 gen_elem_of_pack_expansion_instantiation (tree pattern
,
11069 tree args
/* This parm gets
11071 tsubst_flags_t complain
,
11075 bool ith_elem_is_expansion
= false;
11077 /* For each parameter pack, change the substitution of the parameter
11078 pack to the ith argument in its argument pack, then expand the
11080 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
11082 tree parm
= TREE_PURPOSE (pack
);
11083 tree arg_pack
= TREE_VALUE (pack
);
11084 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
11086 ith_elem_is_expansion
|=
11087 argument_pack_element_is_expansion_p (arg_pack
, index
);
11089 /* Select the Ith argument from the pack. */
11090 if (TREE_CODE (parm
) == PARM_DECL
11091 || TREE_CODE (parm
) == FIELD_DECL
)
11095 aps
= make_argument_pack_select (arg_pack
, index
);
11096 if (!mark_used (parm
, complain
) && !(complain
& tf_error
))
11097 return error_mark_node
;
11098 register_local_specialization (aps
, parm
);
11101 aps
= retrieve_local_specialization (parm
);
11106 template_parm_level_and_index (parm
, &level
, &idx
);
11110 aps
= make_argument_pack_select (arg_pack
, index
);
11111 /* Update the corresponding argument. */
11112 TMPL_ARG (args
, level
, idx
) = aps
;
11115 /* Re-use the ARGUMENT_PACK_SELECT. */
11116 aps
= TMPL_ARG (args
, level
, idx
);
11118 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
11121 /* Substitute into the PATTERN with the (possibly altered)
11123 if (pattern
== in_decl
)
11124 /* Expanding a fixed parameter pack from
11125 coerce_template_parameter_pack. */
11126 t
= tsubst_decl (pattern
, args
, complain
);
11127 else if (pattern
== error_mark_node
)
11128 t
= error_mark_node
;
11129 else if (constraint_p (pattern
))
11131 if (processing_template_decl
)
11132 t
= tsubst_constraint (pattern
, args
, complain
, in_decl
);
11134 t
= (constraints_satisfied_p (pattern
, args
)
11135 ? boolean_true_node
: boolean_false_node
);
11137 else if (!TYPE_P (pattern
))
11138 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
11139 /*integral_constant_expression_p=*/false);
11141 t
= tsubst (pattern
, args
, complain
, in_decl
);
11143 /* If the Ith argument pack element is a pack expansion, then
11144 the Ith element resulting from the substituting is going to
11145 be a pack expansion as well. */
11146 if (ith_elem_is_expansion
)
11147 t
= make_pack_expansion (t
);
11152 /* When the unexpanded parameter pack in a fold expression expands to an empty
11153 sequence, the value of the expression is as follows; the program is
11154 ill-formed if the operator is not listed in this table.
11161 expand_empty_fold (tree t
, tsubst_flags_t complain
)
11163 tree_code code
= (tree_code
)TREE_INT_CST_LOW (TREE_OPERAND (t
, 0));
11164 if (!FOLD_EXPR_MODIFY_P (t
))
11167 case TRUTH_ANDIF_EXPR
:
11168 return boolean_true_node
;
11169 case TRUTH_ORIF_EXPR
:
11170 return boolean_false_node
;
11171 case COMPOUND_EXPR
:
11177 if (complain
& tf_error
)
11178 error_at (location_of (t
),
11179 "fold of empty expansion over %O", code
);
11180 return error_mark_node
;
11183 /* Given a fold-expression T and a current LEFT and RIGHT operand,
11184 form an expression that combines the two terms using the
11188 fold_expression (tree t
, tree left
, tree right
, tsubst_flags_t complain
)
11190 tree op
= FOLD_EXPR_OP (t
);
11191 tree_code code
= (tree_code
)TREE_INT_CST_LOW (op
);
11193 // Handle compound assignment operators.
11194 if (FOLD_EXPR_MODIFY_P (t
))
11195 return build_x_modify_expr (input_location
, left
, code
, right
, complain
);
11199 case COMPOUND_EXPR
:
11200 return build_x_compound_expr (input_location
, left
, right
, complain
);
11202 return build_m_component_ref (left
, right
, complain
);
11204 return build_x_binary_op (input_location
, code
,
11205 left
, TREE_CODE (left
),
11206 right
, TREE_CODE (right
),
11212 /* Substitute ARGS into the pack of a fold expression T. */
11215 tsubst_fold_expr_pack (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11217 return tsubst_pack_expansion (FOLD_EXPR_PACK (t
), args
, complain
, in_decl
);
11220 /* Substitute ARGS into the pack of a fold expression T. */
11223 tsubst_fold_expr_init (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11225 return tsubst_expr (FOLD_EXPR_INIT (t
), args
, complain
, in_decl
, false);
11228 /* Expand a PACK of arguments into a grouped as left fold.
11229 Given a pack containing elements A0, A1, ..., An and an
11230 operator @, this builds the expression:
11232 ((A0 @ A1) @ A2) ... @ An
11234 Note that PACK must not be empty.
11236 The operator is defined by the original fold expression T. */
11239 expand_left_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11241 tree left
= TREE_VEC_ELT (pack
, 0);
11242 for (int i
= 1; i
< TREE_VEC_LENGTH (pack
); ++i
)
11244 tree right
= TREE_VEC_ELT (pack
, i
);
11245 left
= fold_expression (t
, left
, right
, complain
);
11250 /* Substitute into a unary left fold expression. */
11253 tsubst_unary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11256 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11257 if (pack
== error_mark_node
)
11258 return error_mark_node
;
11259 if (PACK_EXPANSION_P (pack
))
11261 tree r
= copy_node (t
);
11262 FOLD_EXPR_PACK (r
) = pack
;
11265 if (TREE_VEC_LENGTH (pack
) == 0)
11266 return expand_empty_fold (t
, complain
);
11268 return expand_left_fold (t
, pack
, complain
);
11271 /* Substitute into a binary left fold expression.
11273 Do ths by building a single (non-empty) vector of argumnts and
11274 building the expression from those elements. */
11277 tsubst_binary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11280 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11281 if (pack
== error_mark_node
)
11282 return error_mark_node
;
11283 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
11284 if (init
== error_mark_node
)
11285 return error_mark_node
;
11287 if (PACK_EXPANSION_P (pack
))
11289 tree r
= copy_node (t
);
11290 FOLD_EXPR_PACK (r
) = pack
;
11291 FOLD_EXPR_INIT (r
) = init
;
11295 tree vec
= make_tree_vec (TREE_VEC_LENGTH (pack
) + 1);
11296 TREE_VEC_ELT (vec
, 0) = init
;
11297 for (int i
= 0; i
< TREE_VEC_LENGTH (pack
); ++i
)
11298 TREE_VEC_ELT (vec
, i
+ 1) = TREE_VEC_ELT (pack
, i
);
11300 return expand_left_fold (t
, vec
, complain
);
11303 /* Expand a PACK of arguments into a grouped as right fold.
11304 Given a pack containing elementns A0, A1, ..., and an
11305 operator @, this builds the expression:
11307 A0@ ... (An-2 @ (An-1 @ An))
11309 Note that PACK must not be empty.
11311 The operator is defined by the original fold expression T. */
11314 expand_right_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11316 // Build the expression.
11317 int n
= TREE_VEC_LENGTH (pack
);
11318 tree right
= TREE_VEC_ELT (pack
, n
- 1);
11319 for (--n
; n
!= 0; --n
)
11321 tree left
= TREE_VEC_ELT (pack
, n
- 1);
11322 right
= fold_expression (t
, left
, right
, complain
);
11327 /* Substitute into a unary right fold expression. */
11330 tsubst_unary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
11333 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11334 if (pack
== error_mark_node
)
11335 return error_mark_node
;
11336 if (PACK_EXPANSION_P (pack
))
11338 tree r
= copy_node (t
);
11339 FOLD_EXPR_PACK (r
) = pack
;
11342 if (TREE_VEC_LENGTH (pack
) == 0)
11343 return expand_empty_fold (t
, complain
);
11345 return expand_right_fold (t
, pack
, complain
);
11348 /* Substitute into a binary right fold expression.
11350 Do ths by building a single (non-empty) vector of arguments and
11351 building the expression from those elements. */
11354 tsubst_binary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
11357 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11358 if (pack
== error_mark_node
)
11359 return error_mark_node
;
11360 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
11361 if (init
== error_mark_node
)
11362 return error_mark_node
;
11364 if (PACK_EXPANSION_P (pack
))
11366 tree r
= copy_node (t
);
11367 FOLD_EXPR_PACK (r
) = pack
;
11368 FOLD_EXPR_INIT (r
) = init
;
11372 int n
= TREE_VEC_LENGTH (pack
);
11373 tree vec
= make_tree_vec (n
+ 1);
11374 for (int i
= 0; i
< n
; ++i
)
11375 TREE_VEC_ELT (vec
, i
) = TREE_VEC_ELT (pack
, i
);
11376 TREE_VEC_ELT (vec
, n
) = init
;
11378 return expand_right_fold (t
, vec
, complain
);
11382 /* Substitute ARGS into T, which is an pack expansion
11383 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
11384 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
11385 (if only a partial substitution could be performed) or
11386 ERROR_MARK_NODE if there was an error. */
11388 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
11392 tree pack
, packs
= NULL_TREE
;
11393 bool unsubstituted_packs
= false;
11396 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
11397 bool need_local_specializations
= false;
11400 gcc_assert (PACK_EXPANSION_P (t
));
11401 pattern
= PACK_EXPANSION_PATTERN (t
);
11403 /* Add in any args remembered from an earlier partial instantiation. */
11404 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
11406 levels
= TMPL_ARGS_DEPTH (args
);
11408 /* Determine the argument packs that will instantiate the parameter
11409 packs used in the expansion expression. While we're at it,
11410 compute the number of arguments to be expanded and make sure it
11412 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
11413 pack
= TREE_CHAIN (pack
))
11415 tree parm_pack
= TREE_VALUE (pack
);
11416 tree arg_pack
= NULL_TREE
;
11417 tree orig_arg
= NULL_TREE
;
11420 if (TREE_CODE (parm_pack
) == BASES
)
11422 gcc_assert (parm_pack
== pattern
);
11423 if (BASES_DIRECT (parm_pack
))
11424 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
11425 args
, complain
, in_decl
, false));
11427 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
11428 args
, complain
, in_decl
, false));
11430 else if (builtin_pack_call_p (parm_pack
))
11432 /* ??? Support use in other patterns. */
11433 gcc_assert (parm_pack
== pattern
);
11434 return expand_builtin_pack_call (parm_pack
, args
,
11435 complain
, in_decl
);
11437 else if (TREE_CODE (parm_pack
) == PARM_DECL
)
11439 /* We know we have correct local_specializations if this
11440 expansion is at function scope, or if we're dealing with a
11441 local parameter in a requires expression; for the latter,
11442 tsubst_requires_expr set it up appropriately. */
11443 if (PACK_EXPANSION_LOCAL_P (t
) || CONSTRAINT_VAR_P (parm_pack
))
11444 arg_pack
= retrieve_local_specialization (parm_pack
);
11446 /* We can't rely on local_specializations for a parameter
11447 name used later in a function declaration (such as in a
11448 late-specified return type). Even if it exists, it might
11449 have the wrong value for a recursive call. */
11450 need_local_specializations
= true;
11454 /* This parameter pack was used in an unevaluated context. Just
11455 make a dummy decl, since it's only used for its type. */
11456 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
11457 if (arg_pack
&& DECL_PACK_P (arg_pack
))
11458 /* Partial instantiation of the parm_pack, we can't build
11459 up an argument pack yet. */
11460 arg_pack
= NULL_TREE
;
11462 arg_pack
= make_fnparm_pack (arg_pack
);
11465 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
11466 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
11470 template_parm_level_and_index (parm_pack
, &level
, &idx
);
11472 if (level
<= levels
)
11473 arg_pack
= TMPL_ARG (args
, level
, idx
);
11476 orig_arg
= arg_pack
;
11477 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
11478 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
11480 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
11481 /* This can only happen if we forget to expand an argument
11482 pack somewhere else. Just return an error, silently. */
11484 result
= make_tree_vec (1);
11485 TREE_VEC_ELT (result
, 0) = error_mark_node
;
11492 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
11494 /* Don't bother trying to do a partial substitution with
11495 incomplete packs; we'll try again after deduction. */
11496 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
11501 else if (len
!= my_len
)
11503 if (!(complain
& tf_error
))
11504 /* Fail quietly. */;
11505 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
11506 error ("mismatched argument pack lengths while expanding %qT",
11509 error ("mismatched argument pack lengths while expanding %qE",
11511 return error_mark_node
;
11514 /* Keep track of the parameter packs and their corresponding
11516 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
11517 TREE_TYPE (packs
) = orig_arg
;
11521 /* We can't substitute for this parameter pack. We use a flag as
11522 well as the missing_level counter because function parameter
11523 packs don't have a level. */
11524 gcc_assert (processing_template_decl
);
11525 unsubstituted_packs
= true;
11529 /* If the expansion is just T..., return the matching argument pack, unless
11530 we need to call convert_from_reference on all the elements. This is an
11531 important optimization; see c++/68422. */
11532 if (!unsubstituted_packs
11533 && TREE_PURPOSE (packs
) == pattern
)
11535 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
11536 /* Types need no adjustment, nor does sizeof..., and if we still have
11537 some pack expansion args we won't do anything yet. */
11538 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
11539 || PACK_EXPANSION_SIZEOF_P (t
)
11540 || pack_expansion_args_count (args
))
11542 /* Also optimize expression pack expansions if we can tell that the
11543 elements won't have reference type. */
11544 tree type
= TREE_TYPE (pattern
);
11545 if (type
&& TREE_CODE (type
) != REFERENCE_TYPE
11546 && !PACK_EXPANSION_P (type
)
11547 && !WILDCARD_TYPE_P (type
))
11549 /* Otherwise use the normal path so we get convert_from_reference. */
11552 /* We cannot expand this expansion expression, because we don't have
11553 all of the argument packs we need. */
11554 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
11556 /* We got some full packs, but we can't substitute them in until we
11557 have values for all the packs. So remember these until then. */
11559 t
= make_pack_expansion (pattern
);
11560 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
11563 else if (unsubstituted_packs
)
11565 /* There were no real arguments, we're just replacing a parameter
11566 pack with another version of itself. Substitute into the
11567 pattern and return a PACK_EXPANSION_*. The caller will need to
11569 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
11570 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
11571 /*integral_constant_expression_p=*/false);
11573 t
= tsubst (pattern
, args
, complain
, in_decl
);
11574 t
= make_pack_expansion (t
);
11578 gcc_assert (len
>= 0);
11580 if (need_local_specializations
)
11582 /* We're in a late-specified return type, so create our own local
11583 specializations map; the current map is either NULL or (in the
11584 case of recursive unification) might have bindings that we don't
11585 want to use or alter. */
11586 saved_local_specializations
= local_specializations
;
11587 local_specializations
= new hash_map
<tree
, tree
>;
11590 /* For each argument in each argument pack, substitute into the
11592 result
= make_tree_vec (len
);
11593 tree elem_args
= copy_template_args (args
);
11594 for (i
= 0; i
< len
; ++i
)
11596 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
11598 elem_args
, complain
,
11600 TREE_VEC_ELT (result
, i
) = t
;
11601 if (t
== error_mark_node
)
11603 result
= error_mark_node
;
11608 /* Update ARGS to restore the substitution from parameter packs to
11609 their argument packs. */
11610 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
11612 tree parm
= TREE_PURPOSE (pack
);
11614 if (TREE_CODE (parm
) == PARM_DECL
11615 || TREE_CODE (parm
) == FIELD_DECL
)
11616 register_local_specialization (TREE_TYPE (pack
), parm
);
11621 if (TREE_VALUE (pack
) == NULL_TREE
)
11624 template_parm_level_and_index (parm
, &level
, &idx
);
11626 /* Update the corresponding argument. */
11627 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
11628 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
11631 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
11635 if (need_local_specializations
)
11637 delete local_specializations
;
11638 local_specializations
= saved_local_specializations
;
11641 /* If the dependent pack arguments were such that we end up with only a
11642 single pack expansion again, there's no need to keep it in a TREE_VEC. */
11643 if (len
== 1 && TREE_CODE (result
) == TREE_VEC
11644 && PACK_EXPANSION_P (TREE_VEC_ELT (result
, 0)))
11645 return TREE_VEC_ELT (result
, 0);
11650 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
11651 TMPL. We do this using DECL_PARM_INDEX, which should work even with
11652 parameter packs; all parms generated from a function parameter pack will
11653 have the same DECL_PARM_INDEX. */
11656 get_pattern_parm (tree parm
, tree tmpl
)
11658 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
11661 if (DECL_ARTIFICIAL (parm
))
11663 for (patparm
= DECL_ARGUMENTS (pattern
);
11664 patparm
; patparm
= DECL_CHAIN (patparm
))
11665 if (DECL_ARTIFICIAL (patparm
)
11666 && DECL_NAME (parm
) == DECL_NAME (patparm
))
11671 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
11672 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
11673 gcc_assert (DECL_PARM_INDEX (patparm
)
11674 == DECL_PARM_INDEX (parm
));
11680 /* Make an argument pack out of the TREE_VEC VEC. */
11683 make_argument_pack (tree vec
)
11686 tree elt
= TREE_VEC_ELT (vec
, 0);
11688 pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
11691 pack
= make_node (NONTYPE_ARGUMENT_PACK
);
11692 TREE_CONSTANT (pack
) = 1;
11694 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
11698 /* Return an exact copy of template args T that can be modified
11702 copy_template_args (tree t
)
11704 if (t
== error_mark_node
)
11707 int len
= TREE_VEC_LENGTH (t
);
11708 tree new_vec
= make_tree_vec (len
);
11710 for (int i
= 0; i
< len
; ++i
)
11712 tree elt
= TREE_VEC_ELT (t
, i
);
11713 if (elt
&& TREE_CODE (elt
) == TREE_VEC
)
11714 elt
= copy_template_args (elt
);
11715 TREE_VEC_ELT (new_vec
, i
) = elt
;
11718 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_vec
)
11719 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
11724 /* Substitute ARGS into the vector or list of template arguments T. */
11727 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11730 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
11733 if (t
== error_mark_node
)
11734 return error_mark_node
;
11736 len
= TREE_VEC_LENGTH (t
);
11737 elts
= XALLOCAVEC (tree
, len
);
11739 for (i
= 0; i
< len
; i
++)
11741 tree orig_arg
= TREE_VEC_ELT (t
, i
);
11744 if (TREE_CODE (orig_arg
) == TREE_VEC
)
11745 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
11746 else if (PACK_EXPANSION_P (orig_arg
))
11748 /* Substitute into an expansion expression. */
11749 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
11751 if (TREE_CODE (new_arg
) == TREE_VEC
)
11752 /* Add to the expanded length adjustment the number of
11753 expanded arguments. We subtract one from this
11754 measurement, because the argument pack expression
11755 itself is already counted as 1 in
11756 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
11757 the argument pack is empty. */
11758 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
11760 else if (ARGUMENT_PACK_P (orig_arg
))
11762 /* Substitute into each of the arguments. */
11763 new_arg
= TYPE_P (orig_arg
)
11764 ? cxx_make_type (TREE_CODE (orig_arg
))
11765 : make_node (TREE_CODE (orig_arg
));
11767 tree pack_args
= tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
11768 args
, complain
, in_decl
);
11769 if (pack_args
== error_mark_node
)
11770 new_arg
= error_mark_node
;
11772 SET_ARGUMENT_PACK_ARGS (new_arg
, pack_args
);
11774 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
)
11775 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
11778 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
11780 if (new_arg
== error_mark_node
)
11781 return error_mark_node
;
11784 if (new_arg
!= orig_arg
)
11791 /* Make space for the expanded arguments coming from template
11793 t
= make_tree_vec (len
+ expanded_len_adjust
);
11794 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
11795 arguments for a member template.
11796 In that case each TREE_VEC in ORIG_T represents a level of template
11797 arguments, and ORIG_T won't carry any non defaulted argument count.
11798 It will rather be the nested TREE_VECs that will carry one.
11799 In other words, ORIG_T carries a non defaulted argument count only
11800 if it doesn't contain any nested TREE_VEC. */
11801 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
11803 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
11804 count
+= expanded_len_adjust
;
11805 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
11807 for (i
= 0, out
= 0; i
< len
; i
++)
11809 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
11810 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
11811 && TREE_CODE (elts
[i
]) == TREE_VEC
)
11815 /* Now expand the template argument pack "in place". */
11816 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
11817 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
11821 TREE_VEC_ELT (t
, out
) = elts
[i
];
11829 /* Substitute ARGS into one level PARMS of template parameters. */
11832 tsubst_template_parms_level (tree parms
, tree args
, tsubst_flags_t complain
)
11834 if (parms
== error_mark_node
)
11835 return error_mark_node
;
11837 tree new_vec
= make_tree_vec (TREE_VEC_LENGTH (parms
));
11839 for (int i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
11841 tree tuple
= TREE_VEC_ELT (parms
, i
);
11843 if (tuple
== error_mark_node
)
11846 TREE_VEC_ELT (new_vec
, i
) =
11847 tsubst_template_parm (tuple
, args
, complain
);
11853 /* Return the result of substituting ARGS into the template parameters
11854 given by PARMS. If there are m levels of ARGS and m + n levels of
11855 PARMS, then the result will contain n levels of PARMS. For
11856 example, if PARMS is `template <class T> template <class U>
11857 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
11858 result will be `template <int*, double, class V>'. */
11861 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
11863 tree r
= NULL_TREE
;
11866 /* When substituting into a template, we must set
11867 PROCESSING_TEMPLATE_DECL as the template parameters may be
11868 dependent if they are based on one-another, and the dependency
11869 predicates are short-circuit outside of templates. */
11870 ++processing_template_decl
;
11872 for (new_parms
= &r
;
11873 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
11874 new_parms
= &(TREE_CHAIN (*new_parms
)),
11875 parms
= TREE_CHAIN (parms
))
11877 tree new_vec
= tsubst_template_parms_level (TREE_VALUE (parms
),
11880 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
11881 - TMPL_ARGS_DEPTH (args
)),
11882 new_vec
, NULL_TREE
);
11885 --processing_template_decl
;
11890 /* Return the result of substituting ARGS into one template parameter
11891 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
11892 parameter and which TREE_PURPOSE is the default argument of the
11893 template parameter. */
11896 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
11898 tree default_value
, parm_decl
;
11900 if (args
== NULL_TREE
11902 || t
== error_mark_node
)
11905 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
11907 default_value
= TREE_PURPOSE (t
);
11908 parm_decl
= TREE_VALUE (t
);
11910 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
11911 if (TREE_CODE (parm_decl
) == PARM_DECL
11912 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
11913 parm_decl
= error_mark_node
;
11914 default_value
= tsubst_template_arg (default_value
, args
,
11915 complain
, NULL_TREE
);
11917 return build_tree_list (default_value
, parm_decl
);
11920 /* Substitute the ARGS into the indicated aggregate (or enumeration)
11921 type T. If T is not an aggregate or enumeration type, it is
11922 handled as if by tsubst. IN_DECL is as for tsubst. If
11923 ENTERING_SCOPE is nonzero, T is the context for a template which
11924 we are presently tsubst'ing. Return the substituted value. */
11927 tsubst_aggr_type (tree t
,
11929 tsubst_flags_t complain
,
11931 int entering_scope
)
11933 if (t
== NULL_TREE
)
11936 switch (TREE_CODE (t
))
11939 if (TYPE_PTRMEMFUNC_P (t
))
11940 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
11942 /* Fall through. */
11943 case ENUMERAL_TYPE
:
11945 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
11950 int saved_unevaluated_operand
;
11951 int saved_inhibit_evaluation_warnings
;
11953 /* In "sizeof(X<I>)" we need to evaluate "I". */
11954 saved_unevaluated_operand
= cp_unevaluated_operand
;
11955 cp_unevaluated_operand
= 0;
11956 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
11957 c_inhibit_evaluation_warnings
= 0;
11959 /* First, determine the context for the type we are looking
11961 context
= TYPE_CONTEXT (t
);
11962 if (context
&& TYPE_P (context
))
11964 context
= tsubst_aggr_type (context
, args
, complain
,
11965 in_decl
, /*entering_scope=*/1);
11966 /* If context is a nested class inside a class template,
11967 it may still need to be instantiated (c++/33959). */
11968 context
= complete_type (context
);
11971 /* Then, figure out what arguments are appropriate for the
11972 type we are trying to find. For example, given:
11974 template <class T> struct S;
11975 template <class T, class U> void f(T, U) { S<U> su; }
11977 and supposing that we are instantiating f<int, double>,
11978 then our ARGS will be {int, double}, but, when looking up
11979 S we only want {double}. */
11980 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
11981 complain
, in_decl
);
11982 if (argvec
== error_mark_node
)
11983 r
= error_mark_node
;
11986 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
11987 entering_scope
, complain
);
11988 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
11991 cp_unevaluated_operand
= saved_unevaluated_operand
;
11992 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
11997 /* This is not a template type, so there's nothing to do. */
12001 return tsubst (t
, args
, complain
, in_decl
);
12005 /* Substitute into the default argument ARG (a default argument for
12006 FN), which has the indicated TYPE. */
12009 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
12011 tree saved_class_ptr
= NULL_TREE
;
12012 tree saved_class_ref
= NULL_TREE
;
12013 int errs
= errorcount
+ sorrycount
;
12015 /* This can happen in invalid code. */
12016 if (TREE_CODE (arg
) == DEFAULT_ARG
)
12019 /* This default argument came from a template. Instantiate the
12020 default argument here, not in tsubst. In the case of
12029 we must be careful to do name lookup in the scope of S<T>,
12030 rather than in the current class. */
12031 push_access_scope (fn
);
12032 /* The "this" pointer is not valid in a default argument. */
12035 saved_class_ptr
= current_class_ptr
;
12036 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
12037 saved_class_ref
= current_class_ref
;
12038 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
12041 push_deferring_access_checks(dk_no_deferred
);
12042 /* The default argument expression may cause implicitly defined
12043 member functions to be synthesized, which will result in garbage
12044 collection. We must treat this situation as if we were within
12045 the body of function so as to avoid collecting live data on the
12048 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
12049 complain
, NULL_TREE
,
12050 /*integral_constant_expression_p=*/false);
12052 pop_deferring_access_checks();
12054 /* Restore the "this" pointer. */
12057 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
12058 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
12061 if (errorcount
+sorrycount
> errs
12062 && (complain
& tf_warning_or_error
))
12063 inform (input_location
,
12064 " when instantiating default argument for call to %qD", fn
);
12066 /* Make sure the default argument is reasonable. */
12067 arg
= check_default_argument (type
, arg
, complain
);
12069 pop_access_scope (fn
);
12074 /* Substitute into all the default arguments for FN. */
12077 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
12082 tmpl_args
= DECL_TI_ARGS (fn
);
12084 /* If this function is not yet instantiated, we certainly don't need
12085 its default arguments. */
12086 if (uses_template_parms (tmpl_args
))
12088 /* Don't do this again for clones. */
12089 if (DECL_CLONED_FUNCTION_P (fn
))
12092 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
12094 arg
= TREE_CHAIN (arg
))
12095 if (TREE_PURPOSE (arg
))
12096 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
12098 TREE_PURPOSE (arg
),
12102 /* Substitute the ARGS into the T, which is a _DECL. Return the
12103 result of the substitution. Issue error and warning messages under
12104 control of COMPLAIN. */
12107 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
12109 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
12110 location_t saved_loc
;
12111 tree r
= NULL_TREE
;
12113 hashval_t hash
= 0;
12115 /* Set the filename and linenumber to improve error-reporting. */
12116 saved_loc
= input_location
;
12117 input_location
= DECL_SOURCE_LOCATION (t
);
12119 switch (TREE_CODE (t
))
12121 case TEMPLATE_DECL
:
12123 /* We can get here when processing a member function template,
12124 member class template, or template template parameter. */
12125 tree decl
= DECL_TEMPLATE_RESULT (t
);
12130 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
12132 /* Template template parameter is treated here. */
12133 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12134 if (new_type
== error_mark_node
)
12135 r
= error_mark_node
;
12136 /* If we get a real template back, return it. This can happen in
12137 the context of most_specialized_partial_spec. */
12138 else if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
12141 /* The new TEMPLATE_DECL was built in
12142 reduce_template_parm_level. */
12143 r
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (new_type
);
12147 /* We might already have an instance of this template.
12148 The ARGS are for the surrounding class type, so the
12149 full args contain the tsubst'd args for the context,
12150 plus the innermost args from the template decl. */
12151 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
12152 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
12153 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
12154 /* Because this is a template, the arguments will still be
12155 dependent, even after substitution. If
12156 PROCESSING_TEMPLATE_DECL is not set, the dependency
12157 predicates will short-circuit. */
12158 ++processing_template_decl
;
12159 full_args
= tsubst_template_args (tmpl_args
, args
,
12160 complain
, in_decl
);
12161 --processing_template_decl
;
12162 if (full_args
== error_mark_node
)
12163 RETURN (error_mark_node
);
12165 /* If this is a default template template argument,
12166 tsubst might not have changed anything. */
12167 if (full_args
== tmpl_args
)
12170 hash
= hash_tmpl_and_args (t
, full_args
);
12171 spec
= retrieve_specialization (t
, full_args
, hash
);
12172 if (spec
!= NULL_TREE
)
12178 /* Make a new template decl. It will be similar to the
12179 original, but will record the current template arguments.
12180 We also create a new function declaration, which is just
12181 like the old one, but points to this new template, rather
12182 than the old one. */
12184 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
12185 DECL_CHAIN (r
) = NULL_TREE
;
12187 // Build new template info linking to the original template decl.
12188 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
12190 if (TREE_CODE (decl
) == TYPE_DECL
12191 && !TYPE_DECL_ALIAS_P (decl
))
12194 ++processing_template_decl
;
12195 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12196 --processing_template_decl
;
12197 if (new_type
== error_mark_node
)
12198 RETURN (error_mark_node
);
12200 TREE_TYPE (r
) = new_type
;
12201 /* For a partial specialization, we need to keep pointing to
12202 the primary template. */
12203 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
12204 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
12205 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
12206 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
12207 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
12212 ++processing_template_decl
;
12213 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
12214 --processing_template_decl
;
12215 if (new_decl
== error_mark_node
)
12216 RETURN (error_mark_node
);
12218 DECL_TEMPLATE_RESULT (r
) = new_decl
;
12219 DECL_TI_TEMPLATE (new_decl
) = r
;
12220 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
12221 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
12222 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
12225 SET_DECL_IMPLICIT_INSTANTIATION (r
);
12226 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
12227 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
12229 /* The template parameters for this new template are all the
12230 template parameters for the old template, except the
12231 outermost level of parameters. */
12232 DECL_TEMPLATE_PARMS (r
)
12233 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
12236 if (PRIMARY_TEMPLATE_P (t
))
12237 DECL_PRIMARY_TEMPLATE (r
) = r
;
12239 if (TREE_CODE (decl
) != TYPE_DECL
&& !VAR_P (decl
))
12240 /* Record this non-type partial instantiation. */
12241 register_specialization (r
, t
,
12242 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
12247 case FUNCTION_DECL
:
12249 tree gen_tmpl
, argvec
;
12251 /* Nobody should be tsubst'ing into non-template functions. */
12252 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
12254 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
12256 /* If T is not dependent, just return it. */
12257 if (!uses_template_parms (DECL_TI_ARGS (t
)))
12260 /* Calculate the most general template of which R is a
12261 specialization, and the complete set of arguments used to
12263 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
12264 argvec
= tsubst_template_args (DECL_TI_ARGS
12265 (DECL_TEMPLATE_RESULT
12266 (DECL_TI_TEMPLATE (t
))),
12267 args
, complain
, in_decl
);
12268 if (argvec
== error_mark_node
)
12269 RETURN (error_mark_node
);
12271 /* Check to see if we already have this specialization. */
12272 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
12273 if (tree spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
))
12279 /* We can see more levels of arguments than parameters if
12280 there was a specialization of a member template, like
12283 template <class T> struct S { template <class U> void f(); }
12284 template <> template <class U> void S<int>::f(U);
12286 Here, we'll be substituting into the specialization,
12287 because that's where we can find the code we actually
12288 want to generate, but we'll have enough arguments for
12289 the most general template.
12291 We also deal with the peculiar case:
12293 template <class T> struct S {
12294 template <class U> friend void f();
12296 template <class U> void f() {}
12298 template void f<double>();
12300 Here, the ARGS for the instantiation of will be {int,
12301 double}. But, we only need as many ARGS as there are
12302 levels of template parameters in CODE_PATTERN. We are
12303 careful not to get fooled into reducing the ARGS in
12306 template <class T> struct S { template <class U> void f(U); }
12307 template <class T> template <> void S<T>::f(int) {}
12309 which we can spot because the pattern will be a
12310 specialization in this case. */
12311 int args_depth
= TMPL_ARGS_DEPTH (args
);
12313 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
12315 if (args_depth
> parms_depth
&& !DECL_TEMPLATE_SPECIALIZATION (t
))
12316 args
= get_innermost_template_args (args
, parms_depth
);
12320 /* This special case arises when we have something like this:
12322 template <class T> struct S {
12323 friend void f<int>(int, double);
12326 Here, the DECL_TI_TEMPLATE for the friend declaration
12327 will be an IDENTIFIER_NODE. We are being called from
12328 tsubst_friend_function, and we want only to create a
12329 new decl (R) with appropriate types so that we can call
12330 determine_specialization. */
12331 gen_tmpl
= NULL_TREE
;
12332 argvec
= NULL_TREE
;
12335 tree ctx
= DECL_CONTEXT (t
);
12336 bool member
= ctx
&& TYPE_P (ctx
);
12339 ctx
= tsubst_aggr_type (ctx
, args
,
12340 complain
, t
, /*entering_scope=*/1);
12342 tree type
= tsubst (TREE_TYPE (t
), args
,
12343 complain
| tf_fndecl_type
, in_decl
);
12344 if (type
== error_mark_node
)
12345 RETURN (error_mark_node
);
12347 /* If we hit excessive deduction depth, the type is bogus even if
12348 it isn't error_mark_node, so don't build a decl. */
12349 if (excessive_deduction_depth
)
12350 RETURN (error_mark_node
);
12352 /* We do NOT check for matching decls pushed separately at this
12353 point, as they may not represent instantiations of this
12354 template, and in any case are considered separate under the
12357 DECL_USE_TEMPLATE (r
) = 0;
12358 TREE_TYPE (r
) = type
;
12359 /* Clear out the mangled name and RTL for the instantiation. */
12360 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
12361 SET_DECL_RTL (r
, NULL
);
12362 /* Leave DECL_INITIAL set on deleted instantiations. */
12363 if (!DECL_DELETED_FN (r
))
12364 DECL_INITIAL (r
) = NULL_TREE
;
12365 DECL_CONTEXT (r
) = ctx
;
12367 /* OpenMP UDRs have the only argument a reference to the declared
12368 type. We want to diagnose if the declared type is a reference,
12369 which is invalid, but as references to references are usually
12370 quietly merged, diagnose it here. */
12371 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
12374 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
12375 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
12376 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
12377 error_at (DECL_SOURCE_LOCATION (t
),
12378 "reference type %qT in "
12379 "%<#pragma omp declare reduction%>", argtype
);
12380 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
12381 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
12385 if (member
&& DECL_CONV_FN_P (r
))
12386 /* Type-conversion operator. Reconstruct the name, in
12387 case it's the name of one of the template's parameters. */
12388 DECL_NAME (r
) = make_conv_op_name (TREE_TYPE (type
));
12390 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
12392 DECL_RESULT (r
) = NULL_TREE
;
12394 TREE_STATIC (r
) = 0;
12395 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
12396 DECL_EXTERNAL (r
) = 1;
12397 /* If this is an instantiation of a function with internal
12398 linkage, we already know what object file linkage will be
12399 assigned to the instantiation. */
12400 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
12401 DECL_DEFER_OUTPUT (r
) = 0;
12402 DECL_CHAIN (r
) = NULL_TREE
;
12403 DECL_PENDING_INLINE_INFO (r
) = 0;
12404 DECL_PENDING_INLINE_P (r
) = 0;
12405 DECL_SAVED_TREE (r
) = NULL_TREE
;
12406 DECL_STRUCT_FUNCTION (r
) = NULL
;
12408 /* We'll re-clone as appropriate in instantiate_template. */
12409 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
12411 /* If we aren't complaining now, return on error before we register
12412 the specialization so that we'll complain eventually. */
12413 if ((complain
& tf_error
) == 0
12414 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
12415 && !grok_op_properties (r
, /*complain=*/false))
12416 RETURN (error_mark_node
);
12418 /* When instantiating a constrained member, substitute
12419 into the constraints to create a new constraint. */
12420 if (tree ci
= get_constraints (t
))
12423 ci
= tsubst_constraint_info (ci
, argvec
, complain
, NULL_TREE
);
12424 set_constraints (r
, ci
);
12427 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
12428 this in the special friend case mentioned above where
12429 GEN_TMPL is NULL. */
12432 DECL_TEMPLATE_INFO (r
)
12433 = build_template_info (gen_tmpl
, argvec
);
12434 SET_DECL_IMPLICIT_INSTANTIATION (r
);
12437 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
12439 /* We instantiated this while substituting into
12440 the type earlier (template/friend54.C). */
12443 /* We're not supposed to instantiate default arguments
12444 until they are called, for a template. But, for a
12447 template <class T> void f ()
12448 { extern void g(int i = T()); }
12450 we should do the substitution when the template is
12451 instantiated. We handle the member function case in
12452 instantiate_class_template since the default arguments
12453 might refer to other members of the class. */
12455 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
12456 && !uses_template_parms (argvec
))
12457 tsubst_default_arguments (r
, complain
);
12460 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
12462 /* Copy the list of befriending classes. */
12463 for (tree
*friends
= &DECL_BEFRIENDING_CLASSES (r
);
12465 friends
= &TREE_CHAIN (*friends
))
12467 *friends
= copy_node (*friends
);
12468 TREE_VALUE (*friends
)
12469 = tsubst (TREE_VALUE (*friends
), args
, complain
, in_decl
);
12472 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
12474 maybe_retrofit_in_chrg (r
);
12475 if (DECL_CONSTRUCTOR_P (r
) && !grok_ctor_properties (ctx
, r
))
12476 RETURN (error_mark_node
);
12477 /* If this is an instantiation of a member template, clone it.
12478 If it isn't, that'll be handled by
12479 clone_constructors_and_destructors. */
12480 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
12481 clone_function_decl (r
, /*update_methods=*/false);
12483 else if ((complain
& tf_error
) != 0
12484 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
12485 && !grok_op_properties (r
, /*complain=*/true))
12486 RETURN (error_mark_node
);
12488 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
12489 SET_DECL_FRIEND_CONTEXT (r
,
12490 tsubst (DECL_FRIEND_CONTEXT (t
),
12491 args
, complain
, in_decl
));
12493 /* Possibly limit visibility based on template args. */
12494 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
12495 if (DECL_VISIBILITY_SPECIFIED (t
))
12497 DECL_VISIBILITY_SPECIFIED (r
) = 0;
12498 DECL_ATTRIBUTES (r
)
12499 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
12501 determine_visibility (r
);
12502 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
12503 && !processing_template_decl
)
12504 defaulted_late_check (r
);
12506 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
12507 args
, complain
, in_decl
);
12513 tree type
= NULL_TREE
;
12515 tree expanded_types
= NULL_TREE
;
12516 tree prev_r
= NULL_TREE
;
12517 tree first_r
= NULL_TREE
;
12519 if (DECL_PACK_P (t
))
12521 /* If there is a local specialization that isn't a
12522 parameter pack, it means that we're doing a "simple"
12523 substitution from inside tsubst_pack_expansion. Just
12524 return the local specialization (which will be a single
12526 tree spec
= retrieve_local_specialization (t
);
12528 && TREE_CODE (spec
) == PARM_DECL
12529 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
12532 /* Expand the TYPE_PACK_EXPANSION that provides the types for
12533 the parameters in this function parameter pack. */
12534 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
12535 complain
, in_decl
);
12536 if (TREE_CODE (expanded_types
) == TREE_VEC
)
12538 len
= TREE_VEC_LENGTH (expanded_types
);
12540 /* Zero-length parameter packs are boring. Just substitute
12543 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
12548 /* All we did was update the type. Make a note of that. */
12549 type
= expanded_types
;
12550 expanded_types
= NULL_TREE
;
12554 /* Loop through all of the parameters we'll build. When T is
12555 a function parameter pack, LEN is the number of expanded
12556 types in EXPANDED_TYPES; otherwise, LEN is 1. */
12558 for (i
= 0; i
< len
; ++i
)
12562 if (DECL_TEMPLATE_PARM_P (t
))
12563 SET_DECL_TEMPLATE_PARM_P (r
);
12565 if (expanded_types
)
12566 /* We're on the Ith parameter of the function parameter
12569 /* Get the Ith type. */
12570 type
= TREE_VEC_ELT (expanded_types
, i
);
12572 /* Rename the parameter to include the index. */
12574 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
12577 /* We're dealing with a normal parameter. */
12578 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12580 type
= type_decays_to (type
);
12581 TREE_TYPE (r
) = type
;
12582 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
12584 if (DECL_INITIAL (r
))
12586 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
12587 DECL_INITIAL (r
) = TREE_TYPE (r
);
12589 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
12590 complain
, in_decl
);
12593 DECL_CONTEXT (r
) = NULL_TREE
;
12595 if (!DECL_TEMPLATE_PARM_P (r
))
12596 DECL_ARG_TYPE (r
) = type_passed_as (type
);
12598 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
12599 args
, complain
, in_decl
);
12601 /* Keep track of the first new parameter we
12602 generate. That's what will be returned to the
12607 /* Build a proper chain of parameters when substituting
12608 into a function parameter pack. */
12610 DECL_CHAIN (prev_r
) = r
;
12613 /* If cp_unevaluated_operand is set, we're just looking for a
12614 single dummy parameter, so don't keep going. */
12615 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
12616 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
12617 complain
, DECL_CHAIN (t
));
12619 /* FIRST_R contains the start of the chain we've built. */
12626 tree type
= NULL_TREE
;
12627 tree vec
= NULL_TREE
;
12628 tree expanded_types
= NULL_TREE
;
12631 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12633 /* This field is a lambda capture pack. Return a TREE_VEC of
12634 the expanded fields to instantiate_class_template_1 and
12635 store them in the specializations hash table as a
12636 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
12637 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
12638 complain
, in_decl
);
12639 if (TREE_CODE (expanded_types
) == TREE_VEC
)
12641 len
= TREE_VEC_LENGTH (expanded_types
);
12642 vec
= make_tree_vec (len
);
12646 /* All we did was update the type. Make a note of that. */
12647 type
= expanded_types
;
12648 expanded_types
= NULL_TREE
;
12652 for (int i
= 0; i
< len
; ++i
)
12655 if (expanded_types
)
12657 type
= TREE_VEC_ELT (expanded_types
, i
);
12659 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
12662 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12664 if (type
== error_mark_node
)
12665 RETURN (error_mark_node
);
12666 TREE_TYPE (r
) = type
;
12667 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
12669 if (DECL_C_BIT_FIELD (r
))
12670 /* For bit-fields, DECL_INITIAL gives the number of bits. For
12671 non-bit-fields DECL_INITIAL is a non-static data member
12672 initializer, which gets deferred instantiation. */
12674 = tsubst_expr (DECL_INITIAL (t
), args
,
12676 /*integral_constant_expression_p=*/true);
12677 else if (DECL_INITIAL (t
))
12679 /* Set up DECL_TEMPLATE_INFO so that we can get at the
12680 NSDMI in perform_member_init. Still set DECL_INITIAL
12681 so that we know there is one. */
12682 DECL_INITIAL (r
) = void_node
;
12683 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
12684 retrofit_lang_decl (r
);
12685 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
12687 /* We don't have to set DECL_CONTEXT here; it is set by
12688 finish_member_declaration. */
12689 DECL_CHAIN (r
) = NULL_TREE
;
12691 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
12692 args
, complain
, in_decl
);
12695 TREE_VEC_ELT (vec
, i
) = r
;
12701 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
12702 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
12703 register_specialization (pack
, t
, args
, false, 0);
12709 /* We reach here only for member using decls. We also need to check
12710 uses_template_parms because DECL_DEPENDENT_P is not set for a
12711 using-declaration that designates a member of the current
12712 instantiation (c++/53549). */
12713 if (DECL_DEPENDENT_P (t
)
12714 || uses_template_parms (USING_DECL_SCOPE (t
)))
12716 tree scope
= USING_DECL_SCOPE (t
);
12717 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
12718 if (PACK_EXPANSION_P (scope
))
12720 tree vec
= tsubst_pack_expansion (scope
, args
, complain
, in_decl
);
12721 int len
= TREE_VEC_LENGTH (vec
);
12722 r
= make_tree_vec (len
);
12723 for (int i
= 0; i
< len
; ++i
)
12725 tree escope
= TREE_VEC_ELT (vec
, i
);
12726 tree elt
= do_class_using_decl (escope
, name
);
12729 r
= error_mark_node
;
12734 TREE_PROTECTED (elt
) = TREE_PROTECTED (t
);
12735 TREE_PRIVATE (elt
) = TREE_PRIVATE (t
);
12737 TREE_VEC_ELT (r
, i
) = elt
;
12742 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
12743 complain
, in_decl
);
12744 r
= do_class_using_decl (inst_scope
, name
);
12746 r
= error_mark_node
;
12749 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
12750 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
12757 DECL_CHAIN (r
) = NULL_TREE
;
12764 tree argvec
= NULL_TREE
;
12765 tree gen_tmpl
= NULL_TREE
;
12767 tree tmpl
= NULL_TREE
;
12769 tree type
= NULL_TREE
;
12772 if (TREE_TYPE (t
) == error_mark_node
)
12773 RETURN (error_mark_node
);
12775 if (TREE_CODE (t
) == TYPE_DECL
12776 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
12778 /* If this is the canonical decl, we don't have to
12779 mess with instantiations, and often we can't (for
12780 typename, template type parms and such). Note that
12781 TYPE_NAME is not correct for the above test if
12782 we've copied the type for a typedef. */
12783 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12784 if (type
== error_mark_node
)
12785 RETURN (error_mark_node
);
12786 r
= TYPE_NAME (type
);
12790 /* Check to see if we already have the specialization we
12793 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
12795 /* T is a static data member or namespace-scope entity.
12796 We have to substitute into namespace-scope variables
12797 (not just variable templates) because of cases like:
12799 template <class T> void f() { extern T t; }
12801 where the entity referenced is not known until
12802 instantiation time. */
12804 ctx
= DECL_CONTEXT (t
);
12805 if (DECL_CLASS_SCOPE_P (t
))
12807 ctx
= tsubst_aggr_type (ctx
, args
,
12809 in_decl
, /*entering_scope=*/1);
12810 /* If CTX is unchanged, then T is in fact the
12811 specialization we want. That situation occurs when
12812 referencing a static data member within in its own
12813 class. We can use pointer equality, rather than
12814 same_type_p, because DECL_CONTEXT is always
12816 if (ctx
== DECL_CONTEXT (t
)
12817 /* ... unless T is a member template; in which
12818 case our caller can be willing to create a
12819 specialization of that template represented
12821 && !(DECL_TI_TEMPLATE (t
)
12822 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
12828 tmpl
= DECL_TI_TEMPLATE (t
);
12829 gen_tmpl
= most_general_template (tmpl
);
12830 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
12831 if (argvec
!= error_mark_node
)
12832 argvec
= (coerce_innermost_template_parms
12833 (DECL_TEMPLATE_PARMS (gen_tmpl
),
12834 argvec
, t
, complain
,
12835 /*all*/true, /*defarg*/true));
12836 if (argvec
== error_mark_node
)
12837 RETURN (error_mark_node
);
12838 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
12839 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
12844 /* A local variable. */
12846 /* Subsequent calls to pushdecl will fill this in. */
12848 /* Unless this is a reference to a static variable from an
12849 enclosing function, in which case we need to fill it in now. */
12850 if (TREE_STATIC (t
))
12852 tree fn
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
12853 if (fn
!= current_function_decl
)
12856 spec
= retrieve_local_specialization (t
);
12858 /* If we already have the specialization we need, there is
12859 nothing more to do. */
12866 /* Create a new node for the specialization we need. */
12868 if (type
== NULL_TREE
)
12870 if (is_typedef_decl (t
))
12871 type
= DECL_ORIGINAL_TYPE (t
);
12873 type
= TREE_TYPE (t
);
12875 && VAR_HAD_UNKNOWN_BOUND (t
)
12876 && type
!= error_mark_node
)
12877 type
= strip_array_domain (type
);
12878 tree auto_node
= type_uses_auto (type
);
12879 int len
= TREE_VEC_LENGTH (args
);
12881 /* Mask off any template args past the variable's context so we
12882 don't replace the auto with an unrelated argument. */
12883 TREE_VEC_LENGTH (args
) = TEMPLATE_TYPE_LEVEL (auto_node
) - 1;
12884 type
= tsubst (type
, args
, complain
, in_decl
);
12886 TREE_VEC_LENGTH (args
) = len
;
12890 /* Even if the original location is out of scope, the
12891 newly substituted one is not. */
12892 DECL_DEAD_FOR_LOCAL (r
) = 0;
12893 DECL_INITIALIZED_P (r
) = 0;
12894 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
12895 if (type
== error_mark_node
)
12896 RETURN (error_mark_node
);
12897 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12899 /* It may seem that this case cannot occur, since:
12904 declares a function, not a variable. However:
12907 template <typename T> void g() { T t; }
12908 template void g<f>();
12910 is an attempt to declare a variable with function
12912 error ("variable %qD has function type",
12913 /* R is not yet sufficiently initialized, so we
12914 just use its name. */
12916 RETURN (error_mark_node
);
12918 type
= complete_type (type
);
12919 /* Wait until cp_finish_decl to set this again, to handle
12920 circular dependency (template/instantiate6.C). */
12921 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
12922 type
= check_var_type (DECL_NAME (r
), type
);
12924 if (DECL_HAS_VALUE_EXPR_P (t
))
12926 tree ve
= DECL_VALUE_EXPR (t
);
12927 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
12928 /*constant_expression_p=*/false);
12929 if (REFERENCE_REF_P (ve
))
12931 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
12932 ve
= TREE_OPERAND (ve
, 0);
12934 SET_DECL_VALUE_EXPR (r
, ve
);
12936 if (CP_DECL_THREAD_LOCAL_P (r
)
12937 && !processing_template_decl
)
12938 set_decl_tls_model (r
, decl_default_tls_model (r
));
12940 else if (DECL_SELF_REFERENCE_P (t
))
12941 SET_DECL_SELF_REFERENCE_P (r
);
12942 TREE_TYPE (r
) = type
;
12943 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
12944 DECL_CONTEXT (r
) = ctx
;
12945 /* Clear out the mangled name and RTL for the instantiation. */
12946 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
12947 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
12948 SET_DECL_RTL (r
, NULL
);
12949 /* The initializer must not be expanded until it is required;
12950 see [temp.inst]. */
12951 DECL_INITIAL (r
) = NULL_TREE
;
12952 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
12955 SET_DECL_MODE (r
, VOIDmode
);
12957 /* Possibly limit visibility based on template args. */
12958 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
12959 if (DECL_VISIBILITY_SPECIFIED (t
))
12961 DECL_VISIBILITY_SPECIFIED (r
) = 0;
12962 DECL_ATTRIBUTES (r
)
12963 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
12965 determine_visibility (r
);
12970 /* A static data member declaration is always marked
12971 external when it is declared in-class, even if an
12972 initializer is present. We mimic the non-template
12973 processing here. */
12974 DECL_EXTERNAL (r
) = 1;
12975 if (DECL_NAMESPACE_SCOPE_P (t
))
12976 DECL_NOT_REALLY_EXTERN (r
) = 1;
12978 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
12979 SET_DECL_IMPLICIT_INSTANTIATION (r
);
12980 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
12984 if (DECL_LANG_SPECIFIC (r
))
12985 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
12986 if (!cp_unevaluated_operand
)
12987 register_local_specialization (r
, t
);
12990 DECL_CHAIN (r
) = NULL_TREE
;
12992 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
12994 args
, complain
, in_decl
);
12996 /* Preserve a typedef that names a type. */
12997 if (is_typedef_decl (r
) && type
!= error_mark_node
)
12999 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
13000 set_underlying_type (r
);
13001 if (TYPE_DECL_ALIAS_P (r
))
13002 /* An alias template specialization can be dependent
13003 even if its underlying type is not. */
13004 TYPE_DEPENDENT_P_VALID (TREE_TYPE (r
)) = false;
13007 layout_decl (r
, 0);
13012 gcc_unreachable ();
13017 /* Restore the file and line information. */
13018 input_location
= saved_loc
;
13023 /* Substitute into the ARG_TYPES of a function type.
13024 If END is a TREE_CHAIN, leave it and any following types
13028 tsubst_arg_types (tree arg_types
,
13031 tsubst_flags_t complain
,
13034 tree remaining_arg_types
;
13035 tree type
= NULL_TREE
;
13037 tree expanded_args
= NULL_TREE
;
13040 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
13043 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
13044 args
, end
, complain
, in_decl
);
13045 if (remaining_arg_types
== error_mark_node
)
13046 return error_mark_node
;
13048 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
13050 /* For a pack expansion, perform substitution on the
13051 entire expression. Later on, we'll handle the arguments
13053 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
13054 args
, complain
, in_decl
);
13056 if (TREE_CODE (expanded_args
) == TREE_VEC
)
13057 /* So that we'll spin through the parameters, one by one. */
13058 i
= TREE_VEC_LENGTH (expanded_args
);
13061 /* We only partially substituted into the parameter
13062 pack. Our type is TYPE_PACK_EXPANSION. */
13063 type
= expanded_args
;
13064 expanded_args
= NULL_TREE
;
13072 type
= TREE_VEC_ELT (expanded_args
, i
);
13074 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
13076 if (type
== error_mark_node
)
13077 return error_mark_node
;
13078 if (VOID_TYPE_P (type
))
13080 if (complain
& tf_error
)
13082 error ("invalid parameter type %qT", type
);
13084 error ("in declaration %q+D", in_decl
);
13086 return error_mark_node
;
13089 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
13090 return error_mark_node
;
13092 /* Do array-to-pointer, function-to-pointer conversion, and ignore
13093 top-level qualifiers as required. */
13094 type
= cv_unqualified (type_decays_to (type
));
13096 /* We do not substitute into default arguments here. The standard
13097 mandates that they be instantiated only when needed, which is
13098 done in build_over_call. */
13099 default_arg
= TREE_PURPOSE (arg_types
);
13101 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
13103 /* We've instantiated a template before its default arguments
13104 have been parsed. This can happen for a nested template
13105 class, and is not an error unless we require the default
13106 argument in a call of this function. */
13107 remaining_arg_types
=
13108 tree_cons (default_arg
, type
, remaining_arg_types
);
13109 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
13112 remaining_arg_types
=
13113 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
13116 return remaining_arg_types
;
13119 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
13120 *not* handle the exception-specification for FNTYPE, because the
13121 initial substitution of explicitly provided template parameters
13122 during argument deduction forbids substitution into the
13123 exception-specification:
13127 All references in the function type of the function template to the
13128 corresponding template parameters are replaced by the specified tem-
13129 plate argument values. If a substitution in a template parameter or
13130 in the function type of the function template results in an invalid
13131 type, type deduction fails. [Note: The equivalent substitution in
13132 exception specifications is done only when the function is instanti-
13133 ated, at which point a program is ill-formed if the substitution
13134 results in an invalid type.] */
13137 tsubst_function_type (tree t
,
13139 tsubst_flags_t complain
,
13143 tree arg_types
= NULL_TREE
;
13146 /* The TYPE_CONTEXT is not used for function/method types. */
13147 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
13149 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
13151 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
13153 if (late_return_type_p
)
13155 /* Substitute the argument types. */
13156 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
13157 complain
, in_decl
);
13158 if (arg_types
== error_mark_node
)
13159 return error_mark_node
;
13161 tree save_ccp
= current_class_ptr
;
13162 tree save_ccr
= current_class_ref
;
13163 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
13164 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
13165 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
13168 /* DR 1207: 'this' is in scope in the trailing return type. */
13169 inject_this_parameter (this_type
, cp_type_quals (this_type
));
13172 /* Substitute the return type. */
13173 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13177 current_class_ptr
= save_ccp
;
13178 current_class_ref
= save_ccr
;
13182 /* Substitute the return type. */
13183 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13185 if (return_type
== error_mark_node
)
13186 return error_mark_node
;
13187 /* DR 486 clarifies that creation of a function type with an
13188 invalid return type is a deduction failure. */
13189 if (TREE_CODE (return_type
) == ARRAY_TYPE
13190 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
13192 if (complain
& tf_error
)
13194 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
13195 error ("function returning an array");
13197 error ("function returning a function");
13199 return error_mark_node
;
13202 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
13203 return error_mark_node
;
13205 if (!late_return_type_p
)
13207 /* Substitute the argument types. */
13208 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
13209 complain
, in_decl
);
13210 if (arg_types
== error_mark_node
)
13211 return error_mark_node
;
13214 /* Construct a new type node and return it. */
13215 if (TREE_CODE (t
) == FUNCTION_TYPE
)
13217 fntype
= build_function_type (return_type
, arg_types
);
13218 fntype
= apply_memfn_quals (fntype
,
13219 type_memfn_quals (t
),
13220 type_memfn_rqual (t
));
13224 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
13225 /* Don't pick up extra function qualifiers from the basetype. */
13226 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
13227 if (! MAYBE_CLASS_TYPE_P (r
))
13231 Type deduction may fail for any of the following
13234 -- Attempting to create "pointer to member of T" when T
13235 is not a class type. */
13236 if (complain
& tf_error
)
13237 error ("creating pointer to member function of non-class type %qT",
13239 return error_mark_node
;
13242 fntype
= build_method_type_directly (r
, return_type
,
13243 TREE_CHAIN (arg_types
));
13244 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
13246 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
13248 if (late_return_type_p
)
13249 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
13254 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
13255 ARGS into that specification, and return the substituted
13256 specification. If there is no specification, return NULL_TREE. */
13259 tsubst_exception_specification (tree fntype
,
13261 tsubst_flags_t complain
,
13268 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
13269 new_specs
= NULL_TREE
;
13270 if (specs
&& TREE_PURPOSE (specs
))
13272 /* A noexcept-specifier. */
13273 tree expr
= TREE_PURPOSE (specs
);
13274 if (TREE_CODE (expr
) == INTEGER_CST
)
13278 /* Defer instantiation of noexcept-specifiers to avoid
13279 excessive instantiations (c++/49107). */
13280 new_specs
= make_node (DEFERRED_NOEXCEPT
);
13281 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
13283 /* We already partially instantiated this member template,
13284 so combine the new args with the old. */
13285 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
13286 = DEFERRED_NOEXCEPT_PATTERN (expr
);
13287 DEFERRED_NOEXCEPT_ARGS (new_specs
)
13288 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
13292 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
13293 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
13297 new_specs
= tsubst_copy_and_build
13298 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
13299 /*integral_constant_expression_p=*/true);
13300 new_specs
= build_noexcept_spec (new_specs
, complain
);
13304 if (! TREE_VALUE (specs
))
13311 tree expanded_specs
= NULL_TREE
;
13313 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
13315 /* Expand the pack expansion type. */
13316 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
13320 if (expanded_specs
== error_mark_node
)
13321 return error_mark_node
;
13322 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
13323 len
= TREE_VEC_LENGTH (expanded_specs
);
13326 /* We're substituting into a member template, so
13327 we got a TYPE_PACK_EXPANSION back. Add that
13328 expansion and move on. */
13329 gcc_assert (TREE_CODE (expanded_specs
)
13330 == TYPE_PACK_EXPANSION
);
13331 new_specs
= add_exception_specifier (new_specs
,
13334 specs
= TREE_CHAIN (specs
);
13339 for (i
= 0; i
< len
; ++i
)
13341 if (expanded_specs
)
13342 spec
= TREE_VEC_ELT (expanded_specs
, i
);
13344 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
13345 if (spec
== error_mark_node
)
13347 new_specs
= add_exception_specifier (new_specs
, spec
,
13351 specs
= TREE_CHAIN (specs
);
13357 /* Take the tree structure T and replace template parameters used
13358 therein with the argument vector ARGS. IN_DECL is an associated
13359 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
13360 Issue error and warning messages under control of COMPLAIN. Note
13361 that we must be relatively non-tolerant of extensions here, in
13362 order to preserve conformance; if we allow substitutions that
13363 should not be allowed, we may allow argument deductions that should
13364 not succeed, and therefore report ambiguous overload situations
13365 where there are none. In theory, we could allow the substitution,
13366 but indicate that it should have failed, and allow our caller to
13367 make sure that the right thing happens, but we don't try to do this
13370 This function is used for dealing with types, decls and the like;
13371 for expressions, use tsubst_expr or tsubst_copy. */
13374 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
13376 enum tree_code code
;
13377 tree type
, r
= NULL_TREE
;
13379 if (t
== NULL_TREE
|| t
== error_mark_node
13380 || t
== integer_type_node
13381 || t
== void_type_node
13382 || t
== char_type_node
13383 || t
== unknown_type_node
13384 || TREE_CODE (t
) == NAMESPACE_DECL
13385 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
13389 return tsubst_decl (t
, args
, complain
);
13391 if (args
== NULL_TREE
)
13394 code
= TREE_CODE (t
);
13396 if (code
== IDENTIFIER_NODE
)
13397 type
= IDENTIFIER_TYPE_VALUE (t
);
13399 type
= TREE_TYPE (t
);
13401 gcc_assert (type
!= unknown_type_node
);
13403 /* Reuse typedefs. We need to do this to handle dependent attributes,
13404 such as attribute aligned. */
13406 && typedef_variant_p (t
))
13408 tree decl
= TYPE_NAME (t
);
13410 if (alias_template_specialization_p (t
))
13412 /* DECL represents an alias template and we want to
13414 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
13415 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
13416 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
13418 else if (DECL_CLASS_SCOPE_P (decl
)
13419 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
13420 && uses_template_parms (DECL_CONTEXT (decl
)))
13422 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
13423 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
13424 r
= retrieve_specialization (tmpl
, gen_args
, 0);
13426 else if (DECL_FUNCTION_SCOPE_P (decl
)
13427 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
13428 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
13429 r
= retrieve_local_specialization (decl
);
13431 /* The typedef is from a non-template context. */
13437 r
= cp_build_qualified_type_real
13438 (r
, cp_type_quals (t
) | cp_type_quals (r
),
13439 complain
| tf_ignore_bad_quals
);
13444 /* We don't have an instantiation yet, so drop the typedef. */
13445 int quals
= cp_type_quals (t
);
13446 t
= DECL_ORIGINAL_TYPE (decl
);
13447 t
= cp_build_qualified_type_real (t
, quals
,
13448 complain
| tf_ignore_bad_quals
);
13452 bool fndecl_type
= (complain
& tf_fndecl_type
);
13453 complain
&= ~tf_fndecl_type
;
13456 && code
!= TYPENAME_TYPE
13457 && code
!= TEMPLATE_TYPE_PARM
13458 && code
!= TEMPLATE_PARM_INDEX
13459 && code
!= IDENTIFIER_NODE
13460 && code
!= FUNCTION_TYPE
13461 && code
!= METHOD_TYPE
)
13462 type
= tsubst (type
, args
, complain
, in_decl
);
13463 if (type
== error_mark_node
)
13464 return error_mark_node
;
13470 case ENUMERAL_TYPE
:
13471 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
13472 /*entering_scope=*/0);
13475 case IDENTIFIER_NODE
:
13486 if (t
== integer_type_node
)
13489 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
13490 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
13494 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
13496 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
13497 /*integral_constant_expression_p=*/false);
13499 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
13501 if (TREE_CODE (max
) == NOP_EXPR
13502 && TREE_SIDE_EFFECTS (omax
)
13503 && !TREE_TYPE (max
))
13504 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
13506 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
13507 with TREE_SIDE_EFFECTS that indicates this is not an integral
13508 constant expression. */
13509 if (processing_template_decl
13510 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
13512 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
13513 TREE_SIDE_EFFECTS (max
) = 1;
13516 return compute_array_index_type (NULL_TREE
, max
, complain
);
13519 case TEMPLATE_TYPE_PARM
:
13520 case TEMPLATE_TEMPLATE_PARM
:
13521 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13522 case TEMPLATE_PARM_INDEX
:
13527 tree arg
= NULL_TREE
;
13529 /* Early in template argument deduction substitution, we don't
13530 want to reduce the level of 'auto', or it will be confused
13531 with a normal template parm in subsequent deduction. */
13532 if (is_auto (t
) && (complain
& tf_partial
))
13537 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
13538 template_parm_level_and_index (t
, &level
, &idx
);
13540 levels
= TMPL_ARGS_DEPTH (args
);
13541 if (level
<= levels
13542 && TREE_VEC_LENGTH (TMPL_ARGS_LEVEL (args
, level
)) > 0)
13544 arg
= TMPL_ARG (args
, level
, idx
);
13546 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
13548 /* See through ARGUMENT_PACK_SELECT arguments. */
13549 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
13550 /* If the selected argument is an expansion E, that most
13551 likely means we were called from
13552 gen_elem_of_pack_expansion_instantiation during the
13553 substituting of pack an argument pack (which Ith
13554 element is a pack expansion, where I is
13555 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
13556 In this case, the Ith element resulting from this
13557 substituting is going to be a pack expansion, which
13558 pattern is the pattern of E. Let's return the
13560 gen_elem_of_pack_expansion_instantiation will
13561 build the resulting pack expansion from it. */
13562 if (PACK_EXPANSION_P (arg
))
13564 /* Make sure we aren't throwing away arg info. */
13565 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
13566 arg
= PACK_EXPANSION_PATTERN (arg
);
13571 if (arg
== error_mark_node
)
13572 return error_mark_node
;
13573 else if (arg
!= NULL_TREE
)
13575 if (ARGUMENT_PACK_P (arg
))
13576 /* If ARG is an argument pack, we don't actually want to
13577 perform a substitution here, because substitutions
13578 for argument packs are only done
13579 element-by-element. We can get to this point when
13580 substituting the type of a non-type template
13581 parameter pack, when that type actually contains
13582 template parameter packs from an outer template, e.g.,
13584 template<typename... Types> struct A {
13585 template<Types... Values> struct B { };
13589 if (code
== TEMPLATE_TYPE_PARM
)
13592 gcc_assert (TYPE_P (arg
));
13594 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
13596 return cp_build_qualified_type_real
13597 (arg
, quals
, complain
| tf_ignore_bad_quals
);
13599 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
13601 /* We are processing a type constructed from a
13602 template template parameter. */
13603 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
13604 args
, complain
, in_decl
);
13605 if (argvec
== error_mark_node
)
13606 return error_mark_node
;
13608 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
13609 || TREE_CODE (arg
) == TEMPLATE_DECL
13610 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
13612 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
13613 /* Consider this code:
13615 template <template <class> class Template>
13617 template <class Arg> using Bind = Template<Arg>;
13620 template <template <class> class Template, class Arg>
13621 using Instantiate = Template<Arg>; //#0
13623 template <template <class> class Template,
13626 Instantiate<Internal<Template>::template Bind,
13629 When #1 is parsed, the
13630 BOUND_TEMPLATE_TEMPLATE_PARM representing the
13631 parameter `Template' in #0 matches the
13632 UNBOUND_CLASS_TEMPLATE representing the argument
13633 `Internal<Template>::template Bind'; We then want
13634 to assemble the type `Bind<Argument>' that can't
13635 be fully created right now, because
13636 `Internal<Template>' not being complete, the Bind
13637 template cannot be looked up in that context. So
13638 we need to "store" `Bind<Argument>' for later
13639 when the context of Bind becomes complete. Let's
13640 store that in a TYPENAME_TYPE. */
13641 return make_typename_type (TYPE_CONTEXT (arg
),
13642 build_nt (TEMPLATE_ID_EXPR
,
13643 TYPE_IDENTIFIER (arg
),
13648 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
13649 are resolving nested-types in the signature of a
13650 member function templates. Otherwise ARG is a
13651 TEMPLATE_DECL and is the real template to be
13653 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
13654 arg
= TYPE_NAME (arg
);
13656 r
= lookup_template_class (arg
,
13658 DECL_CONTEXT (arg
),
13659 /*entering_scope=*/0,
13661 return cp_build_qualified_type_real
13662 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
13664 else if (code
== TEMPLATE_TEMPLATE_PARM
)
13667 /* TEMPLATE_PARM_INDEX. */
13668 return convert_from_reference (unshare_expr (arg
));
13672 /* This can happen during the attempted tsubst'ing in
13673 unify. This means that we don't yet have any information
13674 about the template parameter in question. */
13677 /* If we get here, we must have been looking at a parm for a
13678 more deeply nested template. Make a new version of this
13679 template parameter, but with a lower level. */
13682 case TEMPLATE_TYPE_PARM
:
13683 case TEMPLATE_TEMPLATE_PARM
:
13684 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13685 if (cp_type_quals (t
))
13687 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
13688 r
= cp_build_qualified_type_real
13689 (r
, cp_type_quals (t
),
13690 complain
| (code
== TEMPLATE_TYPE_PARM
13691 ? tf_ignore_bad_quals
: 0));
13693 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
13694 && PLACEHOLDER_TYPE_CONSTRAINTS (t
)
13695 && (r
= (TEMPLATE_PARM_DESCENDANTS
13696 (TEMPLATE_TYPE_PARM_INDEX (t
))))
13697 && (r
= TREE_TYPE (r
))
13698 && !PLACEHOLDER_TYPE_CONSTRAINTS (r
))
13699 /* Break infinite recursion when substituting the constraints
13700 of a constrained placeholder. */;
13704 TEMPLATE_TYPE_PARM_INDEX (r
)
13705 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
13706 r
, levels
, args
, complain
);
13707 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
13708 TYPE_MAIN_VARIANT (r
) = r
;
13709 TYPE_POINTER_TO (r
) = NULL_TREE
;
13710 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
13712 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
13714 /* Propagate constraints on placeholders. */
13715 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
13716 PLACEHOLDER_TYPE_CONSTRAINTS (r
)
13717 = tsubst_constraint (constr
, args
, complain
, in_decl
);
13718 else if (tree pl
= CLASS_PLACEHOLDER_TEMPLATE (t
))
13720 if (DECL_TEMPLATE_TEMPLATE_PARM_P (pl
))
13721 pl
= tsubst (pl
, args
, complain
, in_decl
);
13722 CLASS_PLACEHOLDER_TEMPLATE (r
) = pl
;
13726 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
13727 /* We have reduced the level of the template
13728 template parameter, but not the levels of its
13729 template parameters, so canonical_type_parameter
13730 will not be able to find the canonical template
13731 template parameter for this level. Thus, we
13732 require structural equality checking to compare
13733 TEMPLATE_TEMPLATE_PARMs. */
13734 SET_TYPE_STRUCTURAL_EQUALITY (r
);
13735 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
13736 SET_TYPE_STRUCTURAL_EQUALITY (r
);
13738 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
13740 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
13742 tree tinfo
= TYPE_TEMPLATE_INFO (t
);
13743 /* We might need to substitute into the types of non-type
13744 template parameters. */
13745 tree tmpl
= tsubst (TI_TEMPLATE (tinfo
), args
,
13746 complain
, in_decl
);
13747 if (tmpl
== error_mark_node
)
13748 return error_mark_node
;
13749 tree argvec
= tsubst (TI_ARGS (tinfo
), args
,
13750 complain
, in_decl
);
13751 if (argvec
== error_mark_node
)
13752 return error_mark_node
;
13754 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
13755 = build_template_info (tmpl
, argvec
);
13760 case TEMPLATE_PARM_INDEX
:
13761 /* OK, now substitute the type of the non-type parameter. We
13762 couldn't do it earlier because it might be an auto parameter,
13763 and we wouldn't need to if we had an argument. */
13764 type
= tsubst (type
, args
, complain
, in_decl
);
13765 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
13769 gcc_unreachable ();
13777 tree purpose
, value
, chain
;
13779 if (t
== void_list_node
)
13782 purpose
= TREE_PURPOSE (t
);
13785 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
13786 if (purpose
== error_mark_node
)
13787 return error_mark_node
;
13789 value
= TREE_VALUE (t
);
13792 value
= tsubst (value
, args
, complain
, in_decl
);
13793 if (value
== error_mark_node
)
13794 return error_mark_node
;
13796 chain
= TREE_CHAIN (t
);
13797 if (chain
&& chain
!= void_type_node
)
13799 chain
= tsubst (chain
, args
, complain
, in_decl
);
13800 if (chain
== error_mark_node
)
13801 return error_mark_node
;
13803 if (purpose
== TREE_PURPOSE (t
)
13804 && value
== TREE_VALUE (t
)
13805 && chain
== TREE_CHAIN (t
))
13807 return hash_tree_cons (purpose
, value
, chain
);
13811 /* We should never be tsubsting a binfo. */
13812 gcc_unreachable ();
13815 /* A vector of template arguments. */
13816 gcc_assert (!type
);
13817 return tsubst_template_args (t
, args
, complain
, in_decl
);
13820 case REFERENCE_TYPE
:
13822 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
13827 Type deduction may fail for any of the following
13830 -- Attempting to create a pointer to reference type.
13831 -- Attempting to create a reference to a reference type or
13832 a reference to void.
13834 Core issue 106 says that creating a reference to a reference
13835 during instantiation is no longer a cause for failure. We
13836 only enforce this check in strict C++98 mode. */
13837 if ((TREE_CODE (type
) == REFERENCE_TYPE
13838 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
13839 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
13841 static location_t last_loc
;
13843 /* We keep track of the last time we issued this error
13844 message to avoid spewing a ton of messages during a
13845 single bad template instantiation. */
13846 if (complain
& tf_error
13847 && last_loc
!= input_location
)
13849 if (VOID_TYPE_P (type
))
13850 error ("forming reference to void");
13851 else if (code
== POINTER_TYPE
)
13852 error ("forming pointer to reference type %qT", type
);
13854 error ("forming reference to reference type %qT", type
);
13855 last_loc
= input_location
;
13858 return error_mark_node
;
13860 else if (TREE_CODE (type
) == FUNCTION_TYPE
13861 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
13862 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
13864 if (complain
& tf_error
)
13866 if (code
== POINTER_TYPE
)
13867 error ("forming pointer to qualified function type %qT",
13870 error ("forming reference to qualified function type %qT",
13873 return error_mark_node
;
13875 else if (code
== POINTER_TYPE
)
13877 r
= build_pointer_type (type
);
13878 if (TREE_CODE (type
) == METHOD_TYPE
)
13879 r
= build_ptrmemfunc_type (r
);
13881 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
13882 /* In C++0x, during template argument substitution, when there is an
13883 attempt to create a reference to a reference type, reference
13884 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
13886 "If a template-argument for a template-parameter T names a type
13887 that is a reference to a type A, an attempt to create the type
13888 'lvalue reference to cv T' creates the type 'lvalue reference to
13889 A,' while an attempt to create the type type rvalue reference to
13890 cv T' creates the type T"
13892 r
= cp_build_reference_type
13894 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
13896 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
13897 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
13899 if (r
!= error_mark_node
)
13900 /* Will this ever be needed for TYPE_..._TO values? */
13907 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
13908 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
13912 Type deduction may fail for any of the following
13915 -- Attempting to create "pointer to member of T" when T
13916 is not a class type. */
13917 if (complain
& tf_error
)
13918 error ("creating pointer to member of non-class type %qT", r
);
13919 return error_mark_node
;
13921 if (TREE_CODE (type
) == REFERENCE_TYPE
)
13923 if (complain
& tf_error
)
13924 error ("creating pointer to member reference type %qT", type
);
13925 return error_mark_node
;
13927 if (VOID_TYPE_P (type
))
13929 if (complain
& tf_error
)
13930 error ("creating pointer to member of type void");
13931 return error_mark_node
;
13933 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
13934 if (TREE_CODE (type
) == FUNCTION_TYPE
)
13936 /* The type of the implicit object parameter gets its
13937 cv-qualifiers from the FUNCTION_TYPE. */
13940 = build_memfn_type (type
, r
, type_memfn_quals (type
),
13941 type_memfn_rqual (type
));
13942 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
13943 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
13947 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
13951 case FUNCTION_TYPE
:
13956 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
13957 if (fntype
== error_mark_node
)
13958 return error_mark_node
;
13960 /* Substitute the exception specification. */
13961 specs
= tsubst_exception_specification (t
, args
, complain
, in_decl
,
13962 /*defer_ok*/fndecl_type
);
13963 if (specs
== error_mark_node
)
13964 return error_mark_node
;
13966 fntype
= build_exception_variant (fntype
, specs
);
13971 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
13972 if (domain
== error_mark_node
)
13973 return error_mark_node
;
13975 /* As an optimization, we avoid regenerating the array type if
13976 it will obviously be the same as T. */
13977 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
13980 /* These checks should match the ones in create_array_type_for_decl.
13984 The deduction may fail for any of the following reasons:
13986 -- Attempting to create an array with an element type that
13987 is void, a function type, or a reference type, or [DR337]
13988 an abstract class type. */
13989 if (VOID_TYPE_P (type
)
13990 || TREE_CODE (type
) == FUNCTION_TYPE
13991 || (TREE_CODE (type
) == ARRAY_TYPE
13992 && TYPE_DOMAIN (type
) == NULL_TREE
)
13993 || TREE_CODE (type
) == REFERENCE_TYPE
)
13995 if (complain
& tf_error
)
13996 error ("creating array of %qT", type
);
13997 return error_mark_node
;
14000 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
14001 return error_mark_node
;
14003 r
= build_cplus_array_type (type
, domain
);
14005 if (TYPE_USER_ALIGN (t
))
14007 SET_TYPE_ALIGN (r
, TYPE_ALIGN (t
));
14008 TYPE_USER_ALIGN (r
) = 1;
14014 case TYPENAME_TYPE
:
14016 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
14017 in_decl
, /*entering_scope=*/1);
14018 if (ctx
== error_mark_node
)
14019 return error_mark_node
;
14021 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
14022 complain
, in_decl
);
14023 if (f
== error_mark_node
)
14024 return error_mark_node
;
14026 if (!MAYBE_CLASS_TYPE_P (ctx
))
14028 if (complain
& tf_error
)
14029 error ("%qT is not a class, struct, or union type", ctx
);
14030 return error_mark_node
;
14032 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
14034 /* Normally, make_typename_type does not require that the CTX
14035 have complete type in order to allow things like:
14037 template <class T> struct S { typename S<T>::X Y; };
14039 But, such constructs have already been resolved by this
14040 point, so here CTX really should have complete type, unless
14041 it's a partial instantiation. */
14042 ctx
= complete_type (ctx
);
14043 if (!COMPLETE_TYPE_P (ctx
))
14045 if (complain
& tf_error
)
14046 cxx_incomplete_type_error (NULL_TREE
, ctx
);
14047 return error_mark_node
;
14051 f
= make_typename_type (ctx
, f
, typename_type
,
14052 complain
| tf_keep_type_decl
);
14053 if (f
== error_mark_node
)
14055 if (TREE_CODE (f
) == TYPE_DECL
)
14057 complain
|= tf_ignore_bad_quals
;
14061 if (TREE_CODE (f
) != TYPENAME_TYPE
)
14063 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
14065 if (complain
& tf_error
)
14066 error ("%qT resolves to %qT, which is not an enumeration type",
14069 return error_mark_node
;
14071 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
14073 if (complain
& tf_error
)
14074 error ("%qT resolves to %qT, which is is not a class type",
14077 return error_mark_node
;
14081 return cp_build_qualified_type_real
14082 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
14085 case UNBOUND_CLASS_TEMPLATE
:
14087 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
14088 in_decl
, /*entering_scope=*/1);
14089 tree name
= TYPE_IDENTIFIER (t
);
14090 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
14092 if (ctx
== error_mark_node
|| name
== error_mark_node
)
14093 return error_mark_node
;
14096 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
14097 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
14104 ++cp_unevaluated_operand
;
14105 ++c_inhibit_evaluation_warnings
;
14107 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
14109 /*integral_constant_expression_p=*/false);
14111 --cp_unevaluated_operand
;
14112 --c_inhibit_evaluation_warnings
;
14114 type
= finish_typeof (type
);
14115 return cp_build_qualified_type_real (type
,
14117 | cp_type_quals (type
),
14121 case DECLTYPE_TYPE
:
14125 ++cp_unevaluated_operand
;
14126 ++c_inhibit_evaluation_warnings
;
14128 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
14129 complain
|tf_decltype
, in_decl
,
14130 /*function_p*/false,
14131 /*integral_constant_expression*/false);
14133 if (DECLTYPE_FOR_INIT_CAPTURE (t
))
14135 if (type
== NULL_TREE
)
14137 if (complain
& tf_error
)
14138 error ("empty initializer in lambda init-capture");
14139 type
= error_mark_node
;
14141 else if (TREE_CODE (type
) == TREE_LIST
)
14142 type
= build_x_compound_expr_from_list (type
, ELK_INIT
, complain
);
14145 --cp_unevaluated_operand
;
14146 --c_inhibit_evaluation_warnings
;
14148 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
14149 type
= lambda_capture_field_type (type
,
14150 DECLTYPE_FOR_INIT_CAPTURE (t
),
14151 DECLTYPE_FOR_REF_CAPTURE (t
));
14152 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
14153 type
= lambda_proxy_type (type
);
14156 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
14157 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
14159 /* In a template ~id could be either a complement expression
14160 or an unqualified-id naming a destructor; if instantiating
14161 it produces an expression, it's not an id-expression or
14164 type
= finish_decltype_type (type
, id
, complain
);
14166 return cp_build_qualified_type_real (type
,
14168 | cp_type_quals (type
),
14169 complain
| tf_ignore_bad_quals
);
14172 case UNDERLYING_TYPE
:
14174 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
14175 complain
, in_decl
);
14176 return finish_underlying_type (type
);
14179 case TYPE_ARGUMENT_PACK
:
14180 case NONTYPE_ARGUMENT_PACK
:
14184 if (code
== NONTYPE_ARGUMENT_PACK
)
14185 r
= make_node (code
);
14187 r
= cxx_make_type (code
);
14189 tree pack_args
= ARGUMENT_PACK_ARGS (t
);
14190 pack_args
= tsubst_template_args (pack_args
, args
, complain
, in_decl
);
14191 SET_ARGUMENT_PACK_ARGS (r
, pack_args
);
14209 /* We should use one of the expression tsubsts for these codes. */
14210 gcc_unreachable ();
14213 sorry ("use of %qs in template", get_tree_code_name (code
));
14214 return error_mark_node
;
14218 /* tsubst a BASELINK. OBJECT_TYPE, if non-NULL, is the type of the
14219 expression on the left-hand side of the "." or "->" operator. A
14220 baselink indicates a function from a base class. Both the
14221 BASELINK_ACCESS_BINFO and the base class referenced may indicate
14222 bases of the template class, rather than the instantiated class.
14223 In addition, lookups that were not ambiguous before may be
14224 ambiguous now. Therefore, we perform the lookup again. */
14227 tsubst_baselink (tree baselink
, tree object_type
,
14228 tree args
, tsubst_flags_t complain
, tree in_decl
)
14230 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
14232 tree qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
14233 qualifying_scope
= tsubst (qualifying_scope
, args
, complain
, in_decl
);
14235 tree optype
= BASELINK_OPTYPE (baselink
);
14236 optype
= tsubst (optype
, args
, complain
, in_decl
);
14238 tree template_args
= NULL_TREE
;
14239 bool template_id_p
= false;
14240 tree fns
= BASELINK_FUNCTIONS (baselink
);
14241 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
14243 template_id_p
= true;
14244 template_args
= TREE_OPERAND (fns
, 1);
14245 fns
= TREE_OPERAND (fns
, 0);
14247 template_args
= tsubst_template_args (template_args
, args
,
14248 complain
, in_decl
);
14251 tree name
= OVL_NAME (fns
);
14252 if (IDENTIFIER_CONV_OP_P (name
))
14253 name
= make_conv_op_name (optype
);
14255 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
14258 if ((complain
& tf_error
) && constructor_name_p (name
, qualifying_scope
))
14259 error ("cannot call constructor %<%T::%D%> directly",
14260 qualifying_scope
, name
);
14261 return error_mark_node
;
14264 /* If lookup found a single function, mark it as used at this point.
14265 (If it lookup found multiple functions the one selected later by
14266 overload resolution will be marked as used at that point.) */
14267 if (BASELINK_P (baselink
))
14268 fns
= BASELINK_FUNCTIONS (baselink
);
14269 if (!template_id_p
&& !really_overloaded_fn (fns
)
14270 && !mark_used (OVL_FIRST (fns
), complain
) && !(complain
& tf_error
))
14271 return error_mark_node
;
14273 if (BASELINK_P (baselink
))
14275 /* Add back the template arguments, if present. */
14277 BASELINK_FUNCTIONS (baselink
)
14278 = build2 (TEMPLATE_ID_EXPR
, unknown_type_node
,
14279 BASELINK_FUNCTIONS (baselink
), template_args
);
14281 /* Update the conversion operator type. */
14282 BASELINK_OPTYPE (baselink
) = optype
;
14286 object_type
= current_class_type
;
14288 if (qualified
|| name
== complete_dtor_identifier
)
14290 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
14294 /* We need to call adjust_result_of_qualified_name_lookup in case the
14295 destructor names a base class, but we unset BASELINK_QUALIFIED_P
14296 so that we still get virtual function binding. */
14297 BASELINK_QUALIFIED_P (baselink
) = false;
14303 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
14304 true if the qualified-id will be a postfix-expression in-and-of
14305 itself; false if more of the postfix-expression follows the
14306 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
14310 tsubst_qualified_id (tree qualified_id
, tree args
,
14311 tsubst_flags_t complain
, tree in_decl
,
14312 bool done
, bool address_p
)
14318 tree template_args
;
14319 location_t loc
= UNKNOWN_LOCATION
;
14321 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
14323 /* Figure out what name to look up. */
14324 name
= TREE_OPERAND (qualified_id
, 1);
14325 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
14327 is_template
= true;
14328 loc
= EXPR_LOCATION (name
);
14329 template_args
= TREE_OPERAND (name
, 1);
14331 template_args
= tsubst_template_args (template_args
, args
,
14332 complain
, in_decl
);
14333 if (template_args
== error_mark_node
)
14334 return error_mark_node
;
14335 name
= TREE_OPERAND (name
, 0);
14339 is_template
= false;
14340 template_args
= NULL_TREE
;
14343 /* Substitute into the qualifying scope. When there are no ARGS, we
14344 are just trying to simplify a non-dependent expression. In that
14345 case the qualifying scope may be dependent, and, in any case,
14346 substituting will not help. */
14347 scope
= TREE_OPERAND (qualified_id
, 0);
14350 scope
= tsubst (scope
, args
, complain
, in_decl
);
14351 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
14356 if (dependent_scope_p (scope
))
14359 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
14360 tree r
= build_qualified_name (NULL_TREE
, scope
, expr
,
14361 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
14362 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (qualified_id
);
14366 if (!BASELINK_P (name
) && !DECL_P (expr
))
14368 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
14370 /* A BIT_NOT_EXPR is used to represent a destructor. */
14371 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
14373 error ("qualifying type %qT does not match destructor name ~%qT",
14374 scope
, TREE_OPERAND (expr
, 0));
14375 expr
= error_mark_node
;
14378 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
14379 /*is_type_p=*/0, false);
14382 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
14383 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
14384 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
14386 if (complain
& tf_error
)
14388 error ("dependent-name %qE is parsed as a non-type, but "
14389 "instantiation yields a type", qualified_id
);
14390 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
14392 return error_mark_node
;
14398 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
14400 /* Remember that there was a reference to this entity. */
14401 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
14402 return error_mark_node
;
14405 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
14407 if (complain
& tf_error
)
14408 qualified_name_lookup_error (scope
,
14409 TREE_OPERAND (qualified_id
, 1),
14410 expr
, input_location
);
14411 return error_mark_node
;
14416 if (variable_template_p (expr
))
14417 expr
= lookup_and_finish_template_variable (expr
, template_args
,
14420 expr
= lookup_template_function (expr
, template_args
);
14423 if (expr
== error_mark_node
&& complain
& tf_error
)
14424 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
14425 expr
, input_location
);
14426 else if (TYPE_P (scope
))
14428 expr
= (adjust_result_of_qualified_name_lookup
14429 (expr
, scope
, current_nonlambda_class_type ()));
14430 expr
= (finish_qualified_id_expr
14431 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
14432 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
14433 /*template_arg_p=*/false, complain
));
14436 /* Expressions do not generally have reference type. */
14437 if (TREE_CODE (expr
) != SCOPE_REF
14438 /* However, if we're about to form a pointer-to-member, we just
14439 want the referenced member referenced. */
14440 && TREE_CODE (expr
) != OFFSET_REF
)
14441 expr
= convert_from_reference (expr
);
14443 if (REF_PARENTHESIZED_P (qualified_id
))
14444 expr
= force_paren_expr (expr
);
14449 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
14450 initializer, DECL is the substituted VAR_DECL. Other arguments are as
14454 tsubst_init (tree init
, tree decl
, tree args
,
14455 tsubst_flags_t complain
, tree in_decl
)
14460 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
14462 if (!init
&& TREE_TYPE (decl
) != error_mark_node
)
14464 /* If we had an initializer but it
14465 instantiated to nothing,
14466 value-initialize the object. This will
14467 only occur when the initializer was a
14468 pack expansion where the parameter packs
14469 used in that expansion were of length
14471 init
= build_value_init (TREE_TYPE (decl
),
14473 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
14474 init
= get_target_expr_sfinae (init
, complain
);
14475 if (TREE_CODE (init
) == TARGET_EXPR
)
14476 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
14482 /* Like tsubst, but deals with expressions. This function just replaces
14483 template parms; to finish processing the resultant expression, use
14484 tsubst_copy_and_build or tsubst_expr. */
14487 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14489 enum tree_code code
;
14492 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
14495 code
= TREE_CODE (t
);
14500 r
= retrieve_local_specialization (t
);
14502 if (r
== NULL_TREE
)
14504 /* We get here for a use of 'this' in an NSDMI as part of a
14505 constructor call or as part of an aggregate initialization. */
14506 if (DECL_NAME (t
) == this_identifier
14507 && ((current_function_decl
14508 && DECL_CONSTRUCTOR_P (current_function_decl
))
14509 || (current_class_ref
14510 && TREE_CODE (current_class_ref
) == PLACEHOLDER_EXPR
)))
14511 return current_class_ptr
;
14513 /* This can happen for a parameter name used later in a function
14514 declaration (such as in a late-specified return type). Just
14515 make a dummy decl, since it's only used for its type. */
14516 gcc_assert (cp_unevaluated_operand
!= 0);
14517 r
= tsubst_decl (t
, args
, complain
);
14518 /* Give it the template pattern as its context; its true context
14519 hasn't been instantiated yet and this is good enough for
14521 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
14524 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
14525 r
= ARGUMENT_PACK_SELECT_ARG (r
);
14526 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
14527 return error_mark_node
;
14535 if (DECL_TEMPLATE_PARM_P (t
))
14536 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
14537 /* There is no need to substitute into namespace-scope
14539 if (DECL_NAMESPACE_SCOPE_P (t
))
14541 /* If ARGS is NULL, then T is known to be non-dependent. */
14542 if (args
== NULL_TREE
)
14543 return scalar_constant_value (t
);
14545 /* Unfortunately, we cannot just call lookup_name here.
14548 template <int I> int f() {
14550 struct S { void g() { E e = a; } };
14553 When we instantiate f<7>::S::g(), say, lookup_name is not
14554 clever enough to find f<7>::a. */
14556 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
14557 /*entering_scope=*/0);
14559 for (v
= TYPE_VALUES (enum_type
);
14561 v
= TREE_CHAIN (v
))
14562 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
14563 return TREE_VALUE (v
);
14565 /* We didn't find the name. That should never happen; if
14566 name-lookup found it during preliminary parsing, we
14567 should find it again here during instantiation. */
14568 gcc_unreachable ();
14573 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
14575 /* Check for a local specialization set up by
14576 tsubst_pack_expansion. */
14577 if (tree r
= retrieve_local_specialization (t
))
14579 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
14580 r
= ARGUMENT_PACK_SELECT_ARG (r
);
14584 /* When retrieving a capture pack from a generic lambda, remove the
14585 lambda call op's own template argument list from ARGS. Only the
14586 template arguments active for the closure type should be used to
14587 retrieve the pack specialization. */
14588 if (LAMBDA_FUNCTION_P (current_function_decl
)
14589 && (template_class_depth (DECL_CONTEXT (t
))
14590 != TMPL_ARGS_DEPTH (args
)))
14591 args
= strip_innermost_template_args (args
, 1);
14593 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
14594 tsubst_decl put in the hash table. */
14595 return retrieve_specialization (t
, args
, 0);
14598 if (DECL_CONTEXT (t
))
14602 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
14603 /*entering_scope=*/1);
14604 if (ctx
!= DECL_CONTEXT (t
))
14606 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
14609 if (complain
& tf_error
)
14610 error ("using invalid field %qD", t
);
14611 return error_mark_node
;
14620 case FUNCTION_DECL
:
14621 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
14622 r
= tsubst (t
, args
, complain
, in_decl
);
14623 else if (local_variable_p (t
)
14624 && uses_template_parms (DECL_CONTEXT (t
)))
14626 r
= retrieve_local_specialization (t
);
14627 if (r
== NULL_TREE
)
14629 /* First try name lookup to find the instantiation. */
14630 r
= lookup_name (DECL_NAME (t
));
14631 if (r
&& !is_capture_proxy (r
))
14633 /* Make sure that the one we found is the one we want. */
14634 tree ctx
= DECL_CONTEXT (t
);
14635 if (DECL_LANG_SPECIFIC (ctx
) && DECL_TEMPLATE_INFO (ctx
))
14636 ctx
= tsubst (ctx
, args
, complain
, in_decl
);
14637 if (ctx
!= DECL_CONTEXT (r
))
14645 /* This can happen for a variable used in a
14646 late-specified return type of a local lambda, or for a
14647 local static or constant. Building a new VAR_DECL
14648 should be OK in all those cases. */
14649 r
= tsubst_decl (t
, args
, complain
);
14650 if (local_specializations
)
14651 /* Avoid infinite recursion (79640). */
14652 register_local_specialization (r
, t
);
14653 if (decl_maybe_constant_var_p (r
))
14655 /* We can't call cp_finish_decl, so handle the
14656 initializer by hand. */
14657 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
14658 complain
, in_decl
);
14659 if (!processing_template_decl
)
14660 init
= maybe_constant_init (init
);
14661 if (processing_template_decl
14662 ? potential_constant_expression (init
)
14663 : reduced_constant_expression_p (init
))
14664 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
14665 = TREE_CONSTANT (r
) = true;
14666 DECL_INITIAL (r
) = init
;
14667 if (tree auto_node
= type_uses_auto (TREE_TYPE (r
)))
14669 = do_auto_deduction (TREE_TYPE (r
), init
, auto_node
,
14670 complain
, adc_variable_type
);
14672 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
14673 || decl_constant_var_p (r
)
14674 || errorcount
|| sorrycount
);
14675 if (!processing_template_decl
14676 && !TREE_STATIC (r
))
14677 r
= process_outer_var_ref (r
, complain
);
14679 /* Remember this for subsequent uses. */
14680 if (local_specializations
)
14681 register_local_specialization (r
, t
);
14686 if (!mark_used (r
, complain
))
14687 return error_mark_node
;
14690 case NAMESPACE_DECL
:
14694 /* An OVERLOAD will always be a non-dependent overload set; an
14695 overload set from function scope will just be represented with an
14696 IDENTIFIER_NODE, and from class scope with a BASELINK. */
14697 gcc_assert (!uses_template_parms (t
));
14698 /* We must have marked any lookups as persistent. */
14699 gcc_assert (!OVL_LOOKUP_P (t
) || OVL_USED_P (t
));
14703 return tsubst_baselink (t
, current_nonlambda_class_type (),
14704 args
, complain
, in_decl
);
14706 case TEMPLATE_DECL
:
14707 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
14708 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
14709 args
, complain
, in_decl
);
14710 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
14711 return tsubst (t
, args
, complain
, in_decl
);
14712 else if (DECL_CLASS_SCOPE_P (t
)
14713 && uses_template_parms (DECL_CONTEXT (t
)))
14715 /* Template template argument like the following example need
14718 template <template <class> class TT> struct C {};
14719 template <class T> struct D {
14720 template <class U> struct E {};
14725 We are processing the template argument `E' in #1 for
14726 the template instantiation #2. Originally, `E' is a
14727 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
14728 have to substitute this with one having context `D<int>'. */
14730 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
14731 if (dependent_scope_p (context
))
14733 /* When rewriting a constructor into a deduction guide, a
14734 non-dependent name can become dependent, so memtmpl<args>
14735 becomes context::template memtmpl<args>. */
14736 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14737 return build_qualified_name (type
, context
, DECL_NAME (t
),
14740 return lookup_field (context
, DECL_NAME(t
), 0, false);
14743 /* Ordinary template template argument. */
14747 case REINTERPRET_CAST_EXPR
:
14748 case CONST_CAST_EXPR
:
14749 case STATIC_CAST_EXPR
:
14750 case DYNAMIC_CAST_EXPR
:
14751 case IMPLICIT_CONV_EXPR
:
14755 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14756 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14757 return build1 (code
, type
, op0
);
14761 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
14762 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
14764 tree expanded
, op
= TREE_OPERAND (t
, 0);
14767 if (SIZEOF_EXPR_TYPE_P (t
))
14768 op
= TREE_TYPE (op
);
14770 ++cp_unevaluated_operand
;
14771 ++c_inhibit_evaluation_warnings
;
14772 /* We only want to compute the number of arguments. */
14773 if (PACK_EXPANSION_P (op
))
14774 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
14776 expanded
= tsubst_template_args (ARGUMENT_PACK_ARGS (op
),
14777 args
, complain
, in_decl
);
14778 --cp_unevaluated_operand
;
14779 --c_inhibit_evaluation_warnings
;
14781 if (TREE_CODE (expanded
) == TREE_VEC
)
14783 len
= TREE_VEC_LENGTH (expanded
);
14784 /* Set TREE_USED for the benefit of -Wunused. */
14785 for (int i
= 0; i
< len
; i
++)
14786 if (DECL_P (TREE_VEC_ELT (expanded
, i
)))
14787 TREE_USED (TREE_VEC_ELT (expanded
, i
)) = true;
14790 if (expanded
== error_mark_node
)
14791 return error_mark_node
;
14792 else if (PACK_EXPANSION_P (expanded
)
14793 || (TREE_CODE (expanded
) == TREE_VEC
14794 && pack_expansion_args_count (expanded
)))
14797 if (PACK_EXPANSION_P (expanded
))
14799 else if (TREE_VEC_LENGTH (expanded
) == 1)
14800 expanded
= TREE_VEC_ELT (expanded
, 0);
14802 expanded
= make_argument_pack (expanded
);
14804 if (TYPE_P (expanded
))
14805 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
14806 complain
& tf_error
);
14808 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
14809 complain
& tf_error
);
14812 return build_int_cst (size_type_node
, len
);
14814 if (SIZEOF_EXPR_TYPE_P (t
))
14816 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
14817 args
, complain
, in_decl
);
14818 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
14819 r
= build1 (SIZEOF_EXPR
,
14820 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
14821 SIZEOF_EXPR_TYPE_P (r
) = 1;
14828 case TRUTH_NOT_EXPR
:
14831 case UNARY_PLUS_EXPR
: /* Unary + */
14833 case AT_ENCODE_EXPR
:
14837 case REALPART_EXPR
:
14838 case IMAGPART_EXPR
:
14841 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14842 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14843 return build1 (code
, type
, op0
);
14846 case COMPONENT_REF
:
14851 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14852 name
= TREE_OPERAND (t
, 1);
14853 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
14855 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
14856 complain
, in_decl
);
14857 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
14859 else if (TREE_CODE (name
) == SCOPE_REF
14860 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
14862 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
14863 complain
, in_decl
);
14864 name
= TREE_OPERAND (name
, 1);
14865 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
14866 complain
, in_decl
);
14867 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
14868 name
= build_qualified_name (/*type=*/NULL_TREE
,
14870 /*template_p=*/false);
14872 else if (BASELINK_P (name
))
14873 name
= tsubst_baselink (name
,
14874 non_reference (TREE_TYPE (object
)),
14878 name
= tsubst_copy (name
, args
, complain
, in_decl
);
14879 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
14885 case TRUNC_DIV_EXPR
:
14886 case CEIL_DIV_EXPR
:
14887 case FLOOR_DIV_EXPR
:
14888 case ROUND_DIV_EXPR
:
14889 case EXACT_DIV_EXPR
:
14893 case TRUNC_MOD_EXPR
:
14894 case FLOOR_MOD_EXPR
:
14895 case TRUTH_ANDIF_EXPR
:
14896 case TRUTH_ORIF_EXPR
:
14897 case TRUTH_AND_EXPR
:
14898 case TRUTH_OR_EXPR
:
14911 case COMPOUND_EXPR
:
14914 case PREDECREMENT_EXPR
:
14915 case PREINCREMENT_EXPR
:
14916 case POSTDECREMENT_EXPR
:
14917 case POSTINCREMENT_EXPR
:
14919 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14920 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14921 return build_nt (code
, op0
, op1
);
14926 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14927 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14928 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
14929 QUALIFIED_NAME_IS_TEMPLATE (t
));
14934 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14935 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14936 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
14941 int n
= VL_EXP_OPERAND_LENGTH (t
);
14942 tree result
= build_vl_exp (CALL_EXPR
, n
);
14944 for (i
= 0; i
< n
; i
++)
14945 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
14946 complain
, in_decl
);
14952 case PSEUDO_DTOR_EXPR
:
14953 case VEC_PERM_EXPR
:
14955 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14956 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14957 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
14958 r
= build_nt (code
, op0
, op1
, op2
);
14959 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14965 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14966 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14967 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
14968 r
= build_nt (code
, op0
, op1
, op2
);
14969 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
14975 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14976 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14977 r
= build_nt (code
, op0
, op1
);
14978 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
14979 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
14983 case TEMPLATE_ID_EXPR
:
14985 /* Substituted template arguments */
14986 tree fn
= TREE_OPERAND (t
, 0);
14987 tree targs
= TREE_OPERAND (t
, 1);
14989 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
14991 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14993 return lookup_template_function (fn
, targs
);
14998 tree purpose
, value
, chain
;
15000 if (t
== void_list_node
)
15003 purpose
= TREE_PURPOSE (t
);
15005 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
15006 value
= TREE_VALUE (t
);
15008 value
= tsubst_copy (value
, args
, complain
, in_decl
);
15009 chain
= TREE_CHAIN (t
);
15010 if (chain
&& chain
!= void_type_node
)
15011 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
15012 if (purpose
== TREE_PURPOSE (t
)
15013 && value
== TREE_VALUE (t
)
15014 && chain
== TREE_CHAIN (t
))
15016 return tree_cons (purpose
, value
, chain
);
15021 case ENUMERAL_TYPE
:
15023 case TEMPLATE_TYPE_PARM
:
15024 case TEMPLATE_TEMPLATE_PARM
:
15025 case BOUND_TEMPLATE_TEMPLATE_PARM
:
15026 case TEMPLATE_PARM_INDEX
:
15028 case REFERENCE_TYPE
:
15030 case FUNCTION_TYPE
:
15033 case TYPENAME_TYPE
:
15034 case UNBOUND_CLASS_TEMPLATE
:
15036 case DECLTYPE_TYPE
:
15038 return tsubst (t
, args
, complain
, in_decl
);
15042 /* Fall through. */
15043 case IDENTIFIER_NODE
:
15044 if (IDENTIFIER_CONV_OP_P (t
))
15046 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15047 return make_conv_op_name (new_type
);
15053 /* This is handled by tsubst_copy_and_build. */
15054 gcc_unreachable ();
15058 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15059 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15060 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
15063 case CLEANUP_POINT_EXPR
:
15064 /* We shouldn't have built any of these during initial template
15065 generation. Instead, they should be built during instantiation
15066 in response to the saved STMT_IS_FULL_EXPR_P setting. */
15067 gcc_unreachable ();
15071 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15072 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15073 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15074 r
= build2 (code
, type
, op0
, op1
);
15075 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
15076 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
15077 && !(complain
& tf_error
))
15078 return error_mark_node
;
15082 case EXPR_PACK_EXPANSION
:
15083 error ("invalid use of pack expansion expression");
15084 return error_mark_node
;
15086 case NONTYPE_ARGUMENT_PACK
:
15087 error ("use %<...%> to expand argument pack");
15088 return error_mark_node
;
15091 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
15099 /* Instantiate any typedefs in the type. */
15100 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15101 r
= fold_convert (type
, t
);
15102 gcc_assert (TREE_CODE (r
) == code
);
15107 /* These can sometimes show up in a partial instantiation, but never
15108 involve template parms. */
15109 gcc_assert (!uses_template_parms (t
));
15112 case UNARY_LEFT_FOLD_EXPR
:
15113 return tsubst_unary_left_fold (t
, args
, complain
, in_decl
);
15114 case UNARY_RIGHT_FOLD_EXPR
:
15115 return tsubst_unary_right_fold (t
, args
, complain
, in_decl
);
15116 case BINARY_LEFT_FOLD_EXPR
:
15117 return tsubst_binary_left_fold (t
, args
, complain
, in_decl
);
15118 case BINARY_RIGHT_FOLD_EXPR
:
15119 return tsubst_binary_right_fold (t
, args
, complain
, in_decl
);
15124 /* We shouldn't get here, but keep going if !flag_checking. */
15126 gcc_unreachable ();
15131 /* Helper function for tsubst_omp_clauses, used for instantiation of
15132 OMP_CLAUSE_DECL of clauses. */
15135 tsubst_omp_clause_decl (tree decl
, tree args
, tsubst_flags_t complain
,
15138 if (decl
== NULL_TREE
)
15141 /* Handle an OpenMP array section represented as a TREE_LIST (or
15142 OMP_CLAUSE_DEPEND_KIND). An OMP_CLAUSE_DEPEND (with a depend
15143 kind of OMP_CLAUSE_DEPEND_SINK) can also be represented as a
15144 TREE_LIST. We can handle it exactly the same as an array section
15145 (purpose, value, and a chain), even though the nomenclature
15146 (low_bound, length, etc) is different. */
15147 if (TREE_CODE (decl
) == TREE_LIST
)
15150 = tsubst_expr (TREE_PURPOSE (decl
), args
, complain
, in_decl
,
15151 /*integral_constant_expression_p=*/false);
15152 tree length
= tsubst_expr (TREE_VALUE (decl
), args
, complain
, in_decl
,
15153 /*integral_constant_expression_p=*/false);
15154 tree chain
= tsubst_omp_clause_decl (TREE_CHAIN (decl
), args
, complain
,
15156 if (TREE_PURPOSE (decl
) == low_bound
15157 && TREE_VALUE (decl
) == length
15158 && TREE_CHAIN (decl
) == chain
)
15160 tree ret
= tree_cons (low_bound
, length
, chain
);
15161 OMP_CLAUSE_DEPEND_SINK_NEGATIVE (ret
)
15162 = OMP_CLAUSE_DEPEND_SINK_NEGATIVE (decl
);
15165 tree ret
= tsubst_expr (decl
, args
, complain
, in_decl
,
15166 /*integral_constant_expression_p=*/false);
15167 /* Undo convert_from_reference tsubst_expr could have called. */
15169 && REFERENCE_REF_P (ret
)
15170 && !REFERENCE_REF_P (decl
))
15171 ret
= TREE_OPERAND (ret
, 0);
15175 /* Like tsubst_copy, but specifically for OpenMP clauses. */
15178 tsubst_omp_clauses (tree clauses
, enum c_omp_region_type ort
,
15179 tree args
, tsubst_flags_t complain
, tree in_decl
)
15181 tree new_clauses
= NULL_TREE
, nc
, oc
;
15182 tree linear_no_step
= NULL_TREE
;
15184 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
15186 nc
= copy_node (oc
);
15187 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
15190 switch (OMP_CLAUSE_CODE (nc
))
15192 case OMP_CLAUSE_LASTPRIVATE
:
15193 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
15195 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
15196 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
15197 in_decl
, /*integral_constant_expression_p=*/false);
15198 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
15199 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
15202 case OMP_CLAUSE_PRIVATE
:
15203 case OMP_CLAUSE_SHARED
:
15204 case OMP_CLAUSE_FIRSTPRIVATE
:
15205 case OMP_CLAUSE_COPYIN
:
15206 case OMP_CLAUSE_COPYPRIVATE
:
15207 case OMP_CLAUSE_UNIFORM
:
15208 case OMP_CLAUSE_DEPEND
:
15209 case OMP_CLAUSE_FROM
:
15210 case OMP_CLAUSE_TO
:
15211 case OMP_CLAUSE_MAP
:
15212 case OMP_CLAUSE_USE_DEVICE_PTR
:
15213 case OMP_CLAUSE_IS_DEVICE_PTR
:
15214 OMP_CLAUSE_DECL (nc
)
15215 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
15218 case OMP_CLAUSE_TILE
:
15219 case OMP_CLAUSE_IF
:
15220 case OMP_CLAUSE_NUM_THREADS
:
15221 case OMP_CLAUSE_SCHEDULE
:
15222 case OMP_CLAUSE_COLLAPSE
:
15223 case OMP_CLAUSE_FINAL
:
15224 case OMP_CLAUSE_DEVICE
:
15225 case OMP_CLAUSE_DIST_SCHEDULE
:
15226 case OMP_CLAUSE_NUM_TEAMS
:
15227 case OMP_CLAUSE_THREAD_LIMIT
:
15228 case OMP_CLAUSE_SAFELEN
:
15229 case OMP_CLAUSE_SIMDLEN
:
15230 case OMP_CLAUSE_NUM_TASKS
:
15231 case OMP_CLAUSE_GRAINSIZE
:
15232 case OMP_CLAUSE_PRIORITY
:
15233 case OMP_CLAUSE_ORDERED
:
15234 case OMP_CLAUSE_HINT
:
15235 case OMP_CLAUSE_NUM_GANGS
:
15236 case OMP_CLAUSE_NUM_WORKERS
:
15237 case OMP_CLAUSE_VECTOR_LENGTH
:
15238 case OMP_CLAUSE_WORKER
:
15239 case OMP_CLAUSE_VECTOR
:
15240 case OMP_CLAUSE_ASYNC
:
15241 case OMP_CLAUSE_WAIT
:
15242 OMP_CLAUSE_OPERAND (nc
, 0)
15243 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
15244 in_decl
, /*integral_constant_expression_p=*/false);
15246 case OMP_CLAUSE_REDUCTION
:
15247 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
15249 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
15250 if (TREE_CODE (placeholder
) == SCOPE_REF
)
15252 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
15253 complain
, in_decl
);
15254 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
15255 = build_qualified_name (NULL_TREE
, scope
,
15256 TREE_OPERAND (placeholder
, 1),
15260 gcc_assert (identifier_p (placeholder
));
15262 OMP_CLAUSE_DECL (nc
)
15263 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
15266 case OMP_CLAUSE_GANG
:
15267 case OMP_CLAUSE_ALIGNED
:
15268 OMP_CLAUSE_DECL (nc
)
15269 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
15271 OMP_CLAUSE_OPERAND (nc
, 1)
15272 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
15273 in_decl
, /*integral_constant_expression_p=*/false);
15275 case OMP_CLAUSE_LINEAR
:
15276 OMP_CLAUSE_DECL (nc
)
15277 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
15279 if (OMP_CLAUSE_LINEAR_STEP (oc
) == NULL_TREE
)
15281 gcc_assert (!linear_no_step
);
15282 linear_no_step
= nc
;
15284 else if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (oc
))
15285 OMP_CLAUSE_LINEAR_STEP (nc
)
15286 = tsubst_omp_clause_decl (OMP_CLAUSE_LINEAR_STEP (oc
), args
,
15287 complain
, in_decl
);
15289 OMP_CLAUSE_LINEAR_STEP (nc
)
15290 = tsubst_expr (OMP_CLAUSE_LINEAR_STEP (oc
), args
, complain
,
15292 /*integral_constant_expression_p=*/false);
15294 case OMP_CLAUSE_NOWAIT
:
15295 case OMP_CLAUSE_DEFAULT
:
15296 case OMP_CLAUSE_UNTIED
:
15297 case OMP_CLAUSE_MERGEABLE
:
15298 case OMP_CLAUSE_INBRANCH
:
15299 case OMP_CLAUSE_NOTINBRANCH
:
15300 case OMP_CLAUSE_PROC_BIND
:
15301 case OMP_CLAUSE_FOR
:
15302 case OMP_CLAUSE_PARALLEL
:
15303 case OMP_CLAUSE_SECTIONS
:
15304 case OMP_CLAUSE_TASKGROUP
:
15305 case OMP_CLAUSE_NOGROUP
:
15306 case OMP_CLAUSE_THREADS
:
15307 case OMP_CLAUSE_SIMD
:
15308 case OMP_CLAUSE_DEFAULTMAP
:
15309 case OMP_CLAUSE_INDEPENDENT
:
15310 case OMP_CLAUSE_AUTO
:
15311 case OMP_CLAUSE_SEQ
:
15314 gcc_unreachable ();
15316 if ((ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
)
15317 switch (OMP_CLAUSE_CODE (nc
))
15319 case OMP_CLAUSE_SHARED
:
15320 case OMP_CLAUSE_PRIVATE
:
15321 case OMP_CLAUSE_FIRSTPRIVATE
:
15322 case OMP_CLAUSE_LASTPRIVATE
:
15323 case OMP_CLAUSE_COPYPRIVATE
:
15324 case OMP_CLAUSE_LINEAR
:
15325 case OMP_CLAUSE_REDUCTION
:
15326 case OMP_CLAUSE_USE_DEVICE_PTR
:
15327 case OMP_CLAUSE_IS_DEVICE_PTR
:
15328 /* tsubst_expr on SCOPE_REF results in returning
15329 finish_non_static_data_member result. Undo that here. */
15330 if (TREE_CODE (OMP_CLAUSE_DECL (oc
)) == SCOPE_REF
15331 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (oc
), 1))
15332 == IDENTIFIER_NODE
))
15334 tree t
= OMP_CLAUSE_DECL (nc
);
15337 switch (TREE_CODE (v
))
15339 case COMPONENT_REF
:
15343 case POINTER_PLUS_EXPR
:
15344 v
= TREE_OPERAND (v
, 0);
15347 if (DECL_CONTEXT (v
) == current_function_decl
15348 && DECL_ARTIFICIAL (v
)
15349 && DECL_NAME (v
) == this_identifier
)
15350 OMP_CLAUSE_DECL (nc
) = TREE_OPERAND (t
, 1);
15357 else if (VAR_P (OMP_CLAUSE_DECL (oc
))
15358 && DECL_HAS_VALUE_EXPR_P (OMP_CLAUSE_DECL (oc
))
15359 && DECL_ARTIFICIAL (OMP_CLAUSE_DECL (oc
))
15360 && DECL_LANG_SPECIFIC (OMP_CLAUSE_DECL (oc
))
15361 && DECL_OMP_PRIVATIZED_MEMBER (OMP_CLAUSE_DECL (oc
)))
15363 tree decl
= OMP_CLAUSE_DECL (nc
);
15366 retrofit_lang_decl (decl
);
15367 DECL_OMP_PRIVATIZED_MEMBER (decl
) = 1;
15376 new_clauses
= nreverse (new_clauses
);
15377 if (ort
!= C_ORT_OMP_DECLARE_SIMD
)
15379 new_clauses
= finish_omp_clauses (new_clauses
, ort
);
15380 if (linear_no_step
)
15381 for (nc
= new_clauses
; nc
; nc
= OMP_CLAUSE_CHAIN (nc
))
15382 if (nc
== linear_no_step
)
15384 OMP_CLAUSE_LINEAR_STEP (nc
) = NULL_TREE
;
15388 return new_clauses
;
15391 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
15394 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
15397 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
15399 tree purpose
, value
, chain
;
15404 if (TREE_CODE (t
) != TREE_LIST
)
15405 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
15406 /*function_p=*/false,
15407 /*integral_constant_expression_p=*/false);
15409 if (t
== void_list_node
)
15412 purpose
= TREE_PURPOSE (t
);
15414 purpose
= RECUR (purpose
);
15415 value
= TREE_VALUE (t
);
15418 if (TREE_CODE (value
) != LABEL_DECL
)
15419 value
= RECUR (value
);
15422 value
= lookup_label (DECL_NAME (value
));
15423 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
15424 TREE_USED (value
) = 1;
15427 chain
= TREE_CHAIN (t
);
15428 if (chain
&& chain
!= void_type_node
)
15429 chain
= RECUR (chain
);
15430 return tree_cons (purpose
, value
, chain
);
15434 /* Used to temporarily communicate the list of #pragma omp parallel
15435 clauses to #pragma omp for instantiation if they are combined
15438 static tree
*omp_parallel_combined_clauses
;
15440 /* Substitute one OMP_FOR iterator. */
15443 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree orig_declv
,
15444 tree initv
, tree condv
, tree incrv
, tree
*clauses
,
15445 tree args
, tsubst_flags_t complain
, tree in_decl
,
15446 bool integral_constant_expression_p
)
15448 #define RECUR(NODE) \
15449 tsubst_expr ((NODE), args, complain, in_decl, \
15450 integral_constant_expression_p)
15451 tree decl
, init
, cond
, incr
;
15453 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
15454 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
15456 if (orig_declv
&& OMP_FOR_ORIG_DECLS (t
))
15458 tree o
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t
), i
);
15459 TREE_VEC_ELT (orig_declv
, i
) = RECUR (o
);
15462 decl
= TREE_OPERAND (init
, 0);
15463 init
= TREE_OPERAND (init
, 1);
15464 tree decl_expr
= NULL_TREE
;
15465 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
15467 /* We need to jump through some hoops to handle declarations in the
15468 init-statement, since we might need to handle auto deduction,
15469 but we need to keep control of initialization. */
15471 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
15472 decl
= tsubst_decl (decl
, args
, complain
);
15476 if (TREE_CODE (decl
) == SCOPE_REF
)
15478 decl
= RECUR (decl
);
15479 if (TREE_CODE (decl
) == COMPONENT_REF
)
15483 switch (TREE_CODE (v
))
15485 case COMPONENT_REF
:
15489 case POINTER_PLUS_EXPR
:
15490 v
= TREE_OPERAND (v
, 0);
15493 if (DECL_CONTEXT (v
) == current_function_decl
15494 && DECL_ARTIFICIAL (v
)
15495 && DECL_NAME (v
) == this_identifier
)
15497 decl
= TREE_OPERAND (decl
, 1);
15498 decl
= omp_privatize_field (decl
, false);
15508 decl
= RECUR (decl
);
15510 init
= RECUR (init
);
15512 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
15513 if (auto_node
&& init
)
15515 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
15517 gcc_assert (!type_dependent_expression_p (decl
));
15519 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
15523 /* Declare the variable, but don't let that initialize it. */
15524 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
15525 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
15527 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
15530 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
15531 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
15532 if (TREE_CODE (incr
) == MODIFY_EXPR
)
15534 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
15535 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
15536 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
15537 NOP_EXPR
, rhs
, complain
);
15540 incr
= RECUR (incr
);
15541 TREE_VEC_ELT (declv
, i
) = decl
;
15542 TREE_VEC_ELT (initv
, i
) = init
;
15543 TREE_VEC_ELT (condv
, i
) = cond
;
15544 TREE_VEC_ELT (incrv
, i
) = incr
;
15550 /* Declare and initialize the variable. */
15558 for (j
= (omp_parallel_combined_clauses
== NULL
? 1 : 0); j
< 2; j
++)
15560 for (pc
= j
? clauses
: omp_parallel_combined_clauses
; *pc
; )
15562 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
15563 && OMP_CLAUSE_DECL (*pc
) == decl
)
15565 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_LASTPRIVATE
15566 && OMP_CLAUSE_DECL (*pc
) == decl
)
15570 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
15572 *pc
= OMP_CLAUSE_CHAIN (c
);
15573 OMP_CLAUSE_CHAIN (c
) = *clauses
;
15576 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_FIRSTPRIVATE
15577 && OMP_CLAUSE_DECL (*pc
) == decl
)
15579 error ("iteration variable %qD should not be firstprivate",
15581 *pc
= OMP_CLAUSE_CHAIN (*pc
);
15583 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_REDUCTION
15584 && OMP_CLAUSE_DECL (*pc
) == decl
)
15586 error ("iteration variable %qD should not be reduction",
15588 *pc
= OMP_CLAUSE_CHAIN (*pc
);
15591 pc
= &OMP_CLAUSE_CHAIN (*pc
);
15596 if (*pc
== NULL_TREE
)
15598 tree c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
15599 OMP_CLAUSE_DECL (c
) = decl
;
15600 c
= finish_omp_clauses (c
, C_ORT_OMP
);
15603 OMP_CLAUSE_CHAIN (c
) = *clauses
;
15608 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
15609 if (COMPARISON_CLASS_P (cond
))
15611 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
15612 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
15613 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
15616 cond
= RECUR (cond
);
15617 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
15618 switch (TREE_CODE (incr
))
15620 case PREINCREMENT_EXPR
:
15621 case PREDECREMENT_EXPR
:
15622 case POSTINCREMENT_EXPR
:
15623 case POSTDECREMENT_EXPR
:
15624 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
15625 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
15628 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
15629 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
15631 tree rhs
= TREE_OPERAND (incr
, 1);
15632 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
15633 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
15634 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
15635 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
15636 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
15640 incr
= RECUR (incr
);
15643 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
15644 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
15646 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
15647 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
15648 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
15649 TREE_TYPE (decl
), lhs
,
15650 RECUR (TREE_OPERAND (incr
, 2))));
15652 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
15653 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
15654 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
15656 tree rhs
= TREE_OPERAND (incr
, 2);
15657 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
15658 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
15659 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
15660 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
15661 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
15665 incr
= RECUR (incr
);
15668 incr
= RECUR (incr
);
15672 TREE_VEC_ELT (declv
, i
) = decl
;
15673 TREE_VEC_ELT (initv
, i
) = init
;
15674 TREE_VEC_ELT (condv
, i
) = cond
;
15675 TREE_VEC_ELT (incrv
, i
) = incr
;
15679 /* Helper function of tsubst_expr, find OMP_TEAMS inside
15680 of OMP_TARGET's body. */
15683 tsubst_find_omp_teams (tree
*tp
, int *walk_subtrees
, void *)
15685 *walk_subtrees
= 0;
15686 switch (TREE_CODE (*tp
))
15691 case STATEMENT_LIST
:
15692 *walk_subtrees
= 1;
15700 /* Helper function for tsubst_expr. For decomposition declaration
15701 artificial base DECL, which is tsubsted PATTERN_DECL, tsubst
15702 also the corresponding decls representing the identifiers
15703 of the decomposition declaration. Return DECL if successful
15704 or error_mark_node otherwise, set *FIRST to the first decl
15705 in the list chained through DECL_CHAIN and *CNT to the number
15709 tsubst_decomp_names (tree decl
, tree pattern_decl
, tree args
,
15710 tsubst_flags_t complain
, tree in_decl
, tree
*first
,
15713 tree decl2
, decl3
, prev
= decl
;
15715 gcc_assert (DECL_NAME (decl
) == NULL_TREE
);
15716 for (decl2
= DECL_CHAIN (pattern_decl
);
15719 && DECL_DECOMPOSITION_P (decl2
)
15720 && DECL_NAME (decl2
);
15721 decl2
= DECL_CHAIN (decl2
))
15723 if (TREE_TYPE (decl2
) == error_mark_node
&& *cnt
== 0)
15725 gcc_assert (errorcount
);
15726 return error_mark_node
;
15729 gcc_assert (DECL_DECOMP_BASE (decl2
) == pattern_decl
);
15730 gcc_assert (DECL_HAS_VALUE_EXPR_P (decl2
));
15731 tree v
= DECL_VALUE_EXPR (decl2
);
15732 DECL_HAS_VALUE_EXPR_P (decl2
) = 0;
15733 SET_DECL_VALUE_EXPR (decl2
, NULL_TREE
);
15734 decl3
= tsubst (decl2
, args
, complain
, in_decl
);
15735 SET_DECL_VALUE_EXPR (decl2
, v
);
15736 DECL_HAS_VALUE_EXPR_P (decl2
) = 1;
15738 DECL_TEMPLATE_INSTANTIATED (decl3
) = 1;
15739 maybe_push_decl (decl3
);
15740 if (error_operand_p (decl3
))
15741 decl
= error_mark_node
;
15742 else if (decl
!= error_mark_node
15743 && DECL_CHAIN (decl3
) != prev
)
15745 gcc_assert (errorcount
);
15746 decl
= error_mark_node
;
15755 /* Like tsubst_copy for expressions, etc. but also does semantic
15759 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
15760 bool integral_constant_expression_p
)
15762 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
15763 #define RECUR(NODE) \
15764 tsubst_expr ((NODE), args, complain, in_decl, \
15765 integral_constant_expression_p)
15771 if (t
== NULL_TREE
|| t
== error_mark_node
)
15774 loc
= input_location
;
15775 if (EXPR_HAS_LOCATION (t
))
15776 input_location
= EXPR_LOCATION (t
);
15777 if (STATEMENT_CODE_P (TREE_CODE (t
)))
15778 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
15780 switch (TREE_CODE (t
))
15782 case STATEMENT_LIST
:
15784 tree_stmt_iterator i
;
15785 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
15786 RECUR (tsi_stmt (i
));
15790 case CTOR_INITIALIZER
:
15791 finish_mem_initializers (tsubst_initializer_list
15792 (TREE_OPERAND (t
, 0), args
));
15796 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
15800 tmp
= RECUR (EXPR_STMT_EXPR (t
));
15801 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
15802 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
15804 finish_expr_stmt (tmp
);
15808 finish_local_using_directive (USING_STMT_NAMESPACE (t
),
15809 /*attribs=*/NULL_TREE
);
15814 tree decl
, pattern_decl
;
15817 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
15818 if (TREE_CODE (decl
) == LABEL_DECL
)
15819 finish_label_decl (DECL_NAME (decl
));
15820 else if (TREE_CODE (decl
) == USING_DECL
)
15822 tree scope
= USING_DECL_SCOPE (decl
);
15823 tree name
= DECL_NAME (decl
);
15825 scope
= tsubst (scope
, args
, complain
, in_decl
);
15826 decl
= lookup_qualified_name (scope
, name
,
15827 /*is_type_p=*/false,
15828 /*complain=*/false);
15829 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
15830 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
15832 finish_local_using_decl (decl
, scope
, name
);
15834 else if (DECL_PACK_P (decl
))
15836 /* Don't build up decls for a variadic capture proxy, we'll
15837 instantiate the elements directly as needed. */
15842 init
= DECL_INITIAL (decl
);
15843 decl
= tsubst (decl
, args
, complain
, in_decl
);
15844 if (decl
!= error_mark_node
)
15846 /* By marking the declaration as instantiated, we avoid
15847 trying to instantiate it. Since instantiate_decl can't
15848 handle local variables, and since we've already done
15849 all that needs to be done, that's the right thing to
15852 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
15854 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
15855 /* Anonymous aggregates are a special case. */
15856 finish_anon_union (decl
);
15857 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
15859 DECL_CONTEXT (decl
) = current_function_decl
;
15860 if (DECL_NAME (decl
) == this_identifier
)
15862 tree lam
= DECL_CONTEXT (current_function_decl
);
15863 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
15864 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
15866 insert_capture_proxy (decl
);
15868 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
15869 /* We already did a pushtag. */;
15870 else if (TREE_CODE (decl
) == FUNCTION_DECL
15871 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
15872 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
15874 DECL_CONTEXT (decl
) = NULL_TREE
;
15876 DECL_CONTEXT (decl
) = current_function_decl
;
15877 cp_check_omp_declare_reduction (decl
);
15881 int const_init
= false;
15882 maybe_push_decl (decl
);
15884 && DECL_PRETTY_FUNCTION_P (decl
))
15886 /* For __PRETTY_FUNCTION__ we have to adjust the
15888 const char *const name
15889 = cxx_printable_name (current_function_decl
, 2);
15890 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
15893 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
15896 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
15898 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
15900 && DECL_DECOMPOSITION_P (decl
)
15901 && TREE_TYPE (pattern_decl
) != error_mark_node
)
15905 decl
= tsubst_decomp_names (decl
, pattern_decl
, args
,
15906 complain
, in_decl
, &first
,
15908 if (decl
!= error_mark_node
)
15909 cp_finish_decomp (decl
, first
, cnt
);
15919 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
15920 RECUR (FOR_INIT_STMT (t
));
15921 finish_init_stmt (stmt
);
15922 tmp
= RECUR (FOR_COND (t
));
15923 finish_for_cond (tmp
, stmt
, false);
15924 tmp
= RECUR (FOR_EXPR (t
));
15925 finish_for_expr (tmp
, stmt
);
15926 RECUR (FOR_BODY (t
));
15927 finish_for_stmt (stmt
);
15930 case RANGE_FOR_STMT
:
15933 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
15934 decl
= RANGE_FOR_DECL (t
);
15935 decl
= tsubst (decl
, args
, complain
, in_decl
);
15936 maybe_push_decl (decl
);
15937 expr
= RECUR (RANGE_FOR_EXPR (t
));
15938 if (VAR_P (decl
) && DECL_DECOMPOSITION_P (decl
))
15942 decl
= tsubst_decomp_names (decl
, RANGE_FOR_DECL (t
), args
,
15943 complain
, in_decl
, &first
, &cnt
);
15944 stmt
= cp_convert_range_for (stmt
, decl
, expr
, first
, cnt
,
15945 RANGE_FOR_IVDEP (t
));
15948 stmt
= cp_convert_range_for (stmt
, decl
, expr
, NULL_TREE
, 0,
15949 RANGE_FOR_IVDEP (t
));
15950 RECUR (RANGE_FOR_BODY (t
));
15951 finish_for_stmt (stmt
);
15956 stmt
= begin_while_stmt ();
15957 tmp
= RECUR (WHILE_COND (t
));
15958 finish_while_stmt_cond (tmp
, stmt
, false);
15959 RECUR (WHILE_BODY (t
));
15960 finish_while_stmt (stmt
);
15964 stmt
= begin_do_stmt ();
15965 RECUR (DO_BODY (t
));
15966 finish_do_body (stmt
);
15967 tmp
= RECUR (DO_COND (t
));
15968 finish_do_stmt (tmp
, stmt
, false);
15972 stmt
= begin_if_stmt ();
15973 IF_STMT_CONSTEXPR_P (stmt
) = IF_STMT_CONSTEXPR_P (t
);
15974 tmp
= RECUR (IF_COND (t
));
15975 tmp
= finish_if_stmt_cond (tmp
, stmt
);
15976 if (IF_STMT_CONSTEXPR_P (t
) && integer_zerop (tmp
))
15977 /* Don't instantiate the THEN_CLAUSE. */;
15980 bool inhibit
= integer_zerop (fold_non_dependent_expr (tmp
));
15982 ++c_inhibit_evaluation_warnings
;
15983 RECUR (THEN_CLAUSE (t
));
15985 --c_inhibit_evaluation_warnings
;
15987 finish_then_clause (stmt
);
15989 if (IF_STMT_CONSTEXPR_P (t
) && integer_nonzerop (tmp
))
15990 /* Don't instantiate the ELSE_CLAUSE. */;
15991 else if (ELSE_CLAUSE (t
))
15993 bool inhibit
= integer_nonzerop (fold_non_dependent_expr (tmp
));
15994 begin_else_clause (stmt
);
15996 ++c_inhibit_evaluation_warnings
;
15997 RECUR (ELSE_CLAUSE (t
));
15999 --c_inhibit_evaluation_warnings
;
16000 finish_else_clause (stmt
);
16003 finish_if_stmt (stmt
);
16007 if (BIND_EXPR_BODY_BLOCK (t
))
16008 stmt
= begin_function_body ();
16010 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
16011 ? BCS_TRY_BLOCK
: 0);
16013 RECUR (BIND_EXPR_BODY (t
));
16015 if (BIND_EXPR_BODY_BLOCK (t
))
16016 finish_function_body (stmt
);
16018 finish_compound_stmt (stmt
);
16022 finish_break_stmt ();
16025 case CONTINUE_STMT
:
16026 finish_continue_stmt ();
16030 stmt
= begin_switch_stmt ();
16031 tmp
= RECUR (SWITCH_STMT_COND (t
));
16032 finish_switch_cond (tmp
, stmt
);
16033 RECUR (SWITCH_STMT_BODY (t
));
16034 finish_switch_stmt (stmt
);
16037 case CASE_LABEL_EXPR
:
16039 tree low
= RECUR (CASE_LOW (t
));
16040 tree high
= RECUR (CASE_HIGH (t
));
16041 tree l
= finish_case_label (EXPR_LOCATION (t
), low
, high
);
16042 if (l
&& TREE_CODE (l
) == CASE_LABEL_EXPR
)
16043 FALLTHROUGH_LABEL_P (CASE_LABEL (l
))
16044 = FALLTHROUGH_LABEL_P (CASE_LABEL (t
));
16050 tree decl
= LABEL_EXPR_LABEL (t
);
16053 label
= finish_label_stmt (DECL_NAME (decl
));
16054 if (TREE_CODE (label
) == LABEL_DECL
)
16055 FALLTHROUGH_LABEL_P (label
) = FALLTHROUGH_LABEL_P (decl
);
16056 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
16057 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
16062 tmp
= GOTO_DESTINATION (t
);
16063 if (TREE_CODE (tmp
) != LABEL_DECL
)
16064 /* Computed goto's must be tsubst'd into. On the other hand,
16065 non-computed gotos must not be; the identifier in question
16066 will have no binding. */
16069 tmp
= DECL_NAME (tmp
);
16070 finish_goto_stmt (tmp
);
16075 tree string
= RECUR (ASM_STRING (t
));
16076 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
16077 complain
, in_decl
);
16078 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
16079 complain
, in_decl
);
16080 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
16081 complain
, in_decl
);
16082 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
16083 complain
, in_decl
);
16084 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
16086 tree asm_expr
= tmp
;
16087 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
16088 asm_expr
= TREE_OPERAND (asm_expr
, 0);
16089 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
16096 stmt
= begin_try_block ();
16097 RECUR (TRY_STMTS (t
));
16098 finish_cleanup_try_block (stmt
);
16099 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
16103 tree compound_stmt
= NULL_TREE
;
16105 if (FN_TRY_BLOCK_P (t
))
16106 stmt
= begin_function_try_block (&compound_stmt
);
16108 stmt
= begin_try_block ();
16110 RECUR (TRY_STMTS (t
));
16112 if (FN_TRY_BLOCK_P (t
))
16113 finish_function_try_block (stmt
);
16115 finish_try_block (stmt
);
16117 RECUR (TRY_HANDLERS (t
));
16118 if (FN_TRY_BLOCK_P (t
))
16119 finish_function_handler_sequence (stmt
, compound_stmt
);
16121 finish_handler_sequence (stmt
);
16127 tree decl
= HANDLER_PARMS (t
);
16131 decl
= tsubst (decl
, args
, complain
, in_decl
);
16132 /* Prevent instantiate_decl from trying to instantiate
16133 this variable. We've already done all that needs to be
16135 if (decl
!= error_mark_node
)
16136 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
16138 stmt
= begin_handler ();
16139 finish_handler_parms (decl
, stmt
);
16140 RECUR (HANDLER_BODY (t
));
16141 finish_handler (stmt
);
16146 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
16147 if (CLASS_TYPE_P (tmp
))
16149 /* Local classes are not independent templates; they are
16150 instantiated along with their containing function. And this
16151 way we don't have to deal with pushing out of one local class
16152 to instantiate a member of another local class. */
16153 /* Closures are handled by the LAMBDA_EXPR. */
16154 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
16155 complete_type (tmp
);
16156 for (tree fld
= TYPE_FIELDS (tmp
); fld
; fld
= DECL_CHAIN (fld
))
16158 || (TREE_CODE (fld
) == FUNCTION_DECL
16159 && !DECL_ARTIFICIAL (fld
)))
16160 && DECL_TEMPLATE_INSTANTIATION (fld
))
16161 instantiate_decl (fld
, /*defer_ok=*/false,
16162 /*expl_inst_class=*/false);
16166 case STATIC_ASSERT
:
16170 ++c_inhibit_evaluation_warnings
;
16172 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
16175 /*integral_constant_expression_p=*/true);
16176 --c_inhibit_evaluation_warnings
;
16178 finish_static_assert (condition
,
16179 STATIC_ASSERT_MESSAGE (t
),
16180 STATIC_ASSERT_SOURCE_LOCATION (t
),
16181 /*member_p=*/false);
16186 case OACC_PARALLEL
:
16187 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_ACC
, args
, complain
,
16189 stmt
= begin_omp_parallel ();
16190 RECUR (OMP_BODY (t
));
16191 finish_omp_construct (TREE_CODE (t
), stmt
, tmp
);
16195 r
= push_omp_privatization_clauses (OMP_PARALLEL_COMBINED (t
));
16196 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), C_ORT_OMP
, args
,
16197 complain
, in_decl
);
16198 if (OMP_PARALLEL_COMBINED (t
))
16199 omp_parallel_combined_clauses
= &tmp
;
16200 stmt
= begin_omp_parallel ();
16201 RECUR (OMP_PARALLEL_BODY (t
));
16202 gcc_assert (omp_parallel_combined_clauses
== NULL
);
16203 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
16204 = OMP_PARALLEL_COMBINED (t
);
16205 pop_omp_privatization_clauses (r
);
16209 r
= push_omp_privatization_clauses (false);
16210 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), C_ORT_OMP
, args
,
16211 complain
, in_decl
);
16212 stmt
= begin_omp_task ();
16213 RECUR (OMP_TASK_BODY (t
));
16214 finish_omp_task (tmp
, stmt
);
16215 pop_omp_privatization_clauses (r
);
16222 case OMP_DISTRIBUTE
:
16226 tree clauses
, body
, pre_body
;
16227 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
16228 tree orig_declv
= NULL_TREE
;
16229 tree incrv
= NULL_TREE
;
16230 enum c_omp_region_type ort
= C_ORT_OMP
;
16233 if (TREE_CODE (t
) == CILK_SIMD
|| TREE_CODE (t
) == CILK_FOR
)
16235 else if (TREE_CODE (t
) == OACC_LOOP
)
16238 r
= push_omp_privatization_clauses (OMP_FOR_INIT (t
) == NULL_TREE
);
16239 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), ort
, args
, complain
,
16241 if (OMP_FOR_INIT (t
) != NULL_TREE
)
16243 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16244 if (OMP_FOR_ORIG_DECLS (t
))
16245 orig_declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16246 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16247 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16248 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16251 stmt
= begin_omp_structured_block ();
16253 pre_body
= push_stmt_list ();
16254 RECUR (OMP_FOR_PRE_BODY (t
));
16255 pre_body
= pop_stmt_list (pre_body
);
16257 if (OMP_FOR_INIT (t
) != NULL_TREE
)
16258 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
16259 tsubst_omp_for_iterator (t
, i
, declv
, orig_declv
, initv
, condv
,
16260 incrv
, &clauses
, args
, complain
, in_decl
,
16261 integral_constant_expression_p
);
16262 omp_parallel_combined_clauses
= NULL
;
16264 body
= push_stmt_list ();
16265 RECUR (OMP_FOR_BODY (t
));
16266 body
= pop_stmt_list (body
);
16268 if (OMP_FOR_INIT (t
) != NULL_TREE
)
16269 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
,
16270 orig_declv
, initv
, condv
, incrv
, body
, pre_body
,
16274 t
= make_node (TREE_CODE (t
));
16275 TREE_TYPE (t
) = void_type_node
;
16276 OMP_FOR_BODY (t
) = body
;
16277 OMP_FOR_PRE_BODY (t
) = pre_body
;
16278 OMP_FOR_CLAUSES (t
) = clauses
;
16279 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
16283 add_stmt (finish_omp_structured_block (stmt
));
16284 pop_omp_privatization_clauses (r
);
16289 omp_parallel_combined_clauses
= NULL
;
16294 r
= push_omp_privatization_clauses (TREE_CODE (t
) == OMP_TEAMS
16295 && OMP_TEAMS_COMBINED (t
));
16296 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_OMP
, args
, complain
,
16298 stmt
= push_stmt_list ();
16299 RECUR (OMP_BODY (t
));
16300 stmt
= pop_stmt_list (stmt
);
16303 OMP_BODY (t
) = stmt
;
16304 OMP_CLAUSES (t
) = tmp
;
16306 pop_omp_privatization_clauses (r
);
16310 case OMP_TARGET_DATA
:
16312 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), (TREE_CODE (t
) == OACC_DATA
)
16313 ? C_ORT_ACC
: C_ORT_OMP
, args
, complain
,
16315 keep_next_level (true);
16316 stmt
= begin_omp_structured_block ();
16318 RECUR (OMP_BODY (t
));
16319 stmt
= finish_omp_structured_block (stmt
);
16322 OMP_BODY (t
) = stmt
;
16323 OMP_CLAUSES (t
) = tmp
;
16324 if (TREE_CODE (t
) == OMP_TARGET
&& OMP_TARGET_COMBINED (t
))
16326 tree teams
= cp_walk_tree (&stmt
, tsubst_find_omp_teams
, NULL
, NULL
);
16329 /* For combined target teams, ensure the num_teams and
16330 thread_limit clause expressions are evaluated on the host,
16331 before entering the target construct. */
16333 for (c
= OMP_TEAMS_CLAUSES (teams
);
16334 c
; c
= OMP_CLAUSE_CHAIN (c
))
16335 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
16336 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
16337 && TREE_CODE (OMP_CLAUSE_OPERAND (c
, 0)) != INTEGER_CST
)
16339 tree expr
= OMP_CLAUSE_OPERAND (c
, 0);
16340 expr
= force_target_expr (TREE_TYPE (expr
), expr
, tf_none
);
16341 if (expr
== error_mark_node
)
16343 tmp
= TARGET_EXPR_SLOT (expr
);
16345 OMP_CLAUSE_OPERAND (c
, 0) = expr
;
16346 tree tc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
16347 OMP_CLAUSE_FIRSTPRIVATE
);
16348 OMP_CLAUSE_DECL (tc
) = tmp
;
16349 OMP_CLAUSE_CHAIN (tc
) = OMP_TARGET_CLAUSES (t
);
16350 OMP_TARGET_CLAUSES (t
) = tc
;
16359 tmp
= tsubst_omp_clauses (OACC_DECLARE_CLAUSES (t
), C_ORT_ACC
, args
,
16360 complain
, in_decl
);
16361 OACC_DECLARE_CLAUSES (t
) = tmp
;
16365 case OMP_TARGET_UPDATE
:
16366 case OMP_TARGET_ENTER_DATA
:
16367 case OMP_TARGET_EXIT_DATA
:
16368 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_OMP
, args
,
16369 complain
, in_decl
);
16371 OMP_STANDALONE_CLAUSES (t
) = tmp
;
16375 case OACC_ENTER_DATA
:
16376 case OACC_EXIT_DATA
:
16378 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_ACC
, args
,
16379 complain
, in_decl
);
16381 OMP_STANDALONE_CLAUSES (t
) = tmp
;
16386 tmp
= tsubst_omp_clauses (OMP_ORDERED_CLAUSES (t
), C_ORT_OMP
, args
,
16387 complain
, in_decl
);
16388 stmt
= push_stmt_list ();
16389 RECUR (OMP_BODY (t
));
16390 stmt
= pop_stmt_list (stmt
);
16393 OMP_BODY (t
) = stmt
;
16394 OMP_ORDERED_CLAUSES (t
) = tmp
;
16400 case OMP_TASKGROUP
:
16401 stmt
= push_stmt_list ();
16402 RECUR (OMP_BODY (t
));
16403 stmt
= pop_stmt_list (stmt
);
16406 OMP_BODY (t
) = stmt
;
16411 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
16412 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
16414 tree op1
= TREE_OPERAND (t
, 1);
16415 tree rhs1
= NULL_TREE
;
16417 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
16419 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
16420 op1
= TREE_OPERAND (op1
, 1);
16422 lhs
= RECUR (TREE_OPERAND (op1
, 0));
16423 rhs
= RECUR (TREE_OPERAND (op1
, 1));
16424 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
16425 NULL_TREE
, NULL_TREE
, rhs1
,
16426 OMP_ATOMIC_SEQ_CST (t
));
16430 tree op1
= TREE_OPERAND (t
, 1);
16431 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
16432 tree rhs1
= NULL_TREE
;
16433 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
16434 enum tree_code opcode
= NOP_EXPR
;
16435 if (code
== OMP_ATOMIC_READ
)
16437 v
= RECUR (TREE_OPERAND (op1
, 0));
16438 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
16440 else if (code
== OMP_ATOMIC_CAPTURE_OLD
16441 || code
== OMP_ATOMIC_CAPTURE_NEW
)
16443 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
16444 v
= RECUR (TREE_OPERAND (op1
, 0));
16445 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
16446 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
16448 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
16449 op11
= TREE_OPERAND (op11
, 1);
16451 lhs
= RECUR (TREE_OPERAND (op11
, 0));
16452 rhs
= RECUR (TREE_OPERAND (op11
, 1));
16453 opcode
= TREE_CODE (op11
);
16454 if (opcode
== MODIFY_EXPR
)
16460 lhs
= RECUR (TREE_OPERAND (op1
, 0));
16461 rhs
= RECUR (TREE_OPERAND (op1
, 1));
16463 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
16464 OMP_ATOMIC_SEQ_CST (t
));
16468 case TRANSACTION_EXPR
:
16471 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
16472 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
16474 if (TRANSACTION_EXPR_IS_STMT (t
))
16476 tree body
= TRANSACTION_EXPR_BODY (t
);
16477 tree noex
= NULL_TREE
;
16478 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
16480 noex
= MUST_NOT_THROW_COND (body
);
16481 if (noex
== NULL_TREE
)
16482 noex
= boolean_true_node
;
16483 body
= TREE_OPERAND (body
, 0);
16485 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
16487 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
16491 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
16492 RECUR (TRANSACTION_EXPR_BODY (t
)),
16499 case MUST_NOT_THROW_EXPR
:
16501 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16502 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
16503 RETURN (build_must_not_throw_expr (op0
, cond
));
16506 case EXPR_PACK_EXPANSION
:
16507 error ("invalid use of pack expansion expression");
16508 RETURN (error_mark_node
);
16510 case NONTYPE_ARGUMENT_PACK
:
16511 error ("use %<...%> to expand argument pack");
16512 RETURN (error_mark_node
);
16514 case CILK_SPAWN_STMT
:
16515 cfun
->calls_cilk_spawn
= 1;
16516 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
16518 case CILK_SYNC_STMT
:
16519 RETURN (build_cilk_sync ());
16521 case COMPOUND_EXPR
:
16522 tmp
= RECUR (TREE_OPERAND (t
, 0));
16523 if (tmp
== NULL_TREE
)
16524 /* If the first operand was a statement, we're done with it. */
16525 RETURN (RECUR (TREE_OPERAND (t
, 1)));
16526 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
16527 RECUR (TREE_OPERAND (t
, 1)),
16530 case ANNOTATE_EXPR
:
16531 tmp
= RECUR (TREE_OPERAND (t
, 0));
16532 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
16533 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
16536 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
16538 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
16539 /*function_p=*/false,
16540 integral_constant_expression_p
));
16543 RETURN (NULL_TREE
);
16545 input_location
= loc
;
16551 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
16552 function. For description of the body see comment above
16553 cp_parser_omp_declare_reduction_exprs. */
16556 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
16558 if (t
== NULL_TREE
|| t
== error_mark_node
)
16561 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
16563 tree_stmt_iterator tsi
;
16566 memset (stmts
, 0, sizeof stmts
);
16567 for (i
= 0, tsi
= tsi_start (t
);
16568 i
< 7 && !tsi_end_p (tsi
);
16569 i
++, tsi_next (&tsi
))
16570 stmts
[i
] = tsi_stmt (tsi
);
16571 gcc_assert (tsi_end_p (tsi
));
16575 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
16576 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
16577 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
16578 args
, complain
, in_decl
);
16579 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
16580 args
, complain
, in_decl
);
16581 DECL_CONTEXT (omp_out
) = current_function_decl
;
16582 DECL_CONTEXT (omp_in
) = current_function_decl
;
16583 keep_next_level (true);
16584 tree block
= begin_omp_structured_block ();
16585 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
16586 block
= finish_omp_structured_block (block
);
16587 block
= maybe_cleanup_point_expr_void (block
);
16588 add_decl_expr (omp_out
);
16589 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
16590 TREE_NO_WARNING (omp_out
) = 1;
16591 add_decl_expr (omp_in
);
16592 finish_expr_stmt (block
);
16596 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
16597 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
16598 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
16599 args
, complain
, in_decl
);
16600 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
16601 args
, complain
, in_decl
);
16602 DECL_CONTEXT (omp_priv
) = current_function_decl
;
16603 DECL_CONTEXT (omp_orig
) = current_function_decl
;
16604 keep_next_level (true);
16605 tree block
= begin_omp_structured_block ();
16606 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
16607 block
= finish_omp_structured_block (block
);
16608 block
= maybe_cleanup_point_expr_void (block
);
16609 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
16610 add_decl_expr (omp_priv
);
16611 add_decl_expr (omp_orig
);
16612 finish_expr_stmt (block
);
16614 add_decl_expr (omp_orig
);
16618 /* T is a postfix-expression that is not being used in a function
16619 call. Return the substituted version of T. */
16622 tsubst_non_call_postfix_expression (tree t
, tree args
,
16623 tsubst_flags_t complain
,
16626 if (TREE_CODE (t
) == SCOPE_REF
)
16627 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
16628 /*done=*/false, /*address_p=*/false);
16630 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
16631 /*function_p=*/false,
16632 /*integral_constant_expression_p=*/false);
16637 /* Like tsubst but deals with expressions and performs semantic
16638 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
16641 tsubst_copy_and_build (tree t
,
16643 tsubst_flags_t complain
,
16646 bool integral_constant_expression_p
)
16648 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
16649 #define RECUR(NODE) \
16650 tsubst_copy_and_build (NODE, args, complain, in_decl, \
16651 /*function_p=*/false, \
16652 integral_constant_expression_p)
16657 if (t
== NULL_TREE
|| t
== error_mark_node
)
16660 loc
= input_location
;
16661 if (EXPR_HAS_LOCATION (t
))
16662 input_location
= EXPR_LOCATION (t
);
16664 /* N3276 decltype magic only applies to calls at the top level or on the
16665 right side of a comma. */
16666 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
16667 complain
&= ~tf_decltype
;
16669 switch (TREE_CODE (t
))
16673 /* Fall through. */
16674 case IDENTIFIER_NODE
:
16678 bool non_integral_constant_expression_p
;
16679 const char *error_msg
;
16681 if (IDENTIFIER_CONV_OP_P (t
))
16683 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16684 t
= make_conv_op_name (new_type
);
16687 /* Look up the name. */
16688 decl
= lookup_name (t
);
16690 /* By convention, expressions use ERROR_MARK_NODE to indicate
16691 failure, not NULL_TREE. */
16692 if (decl
== NULL_TREE
)
16693 decl
= error_mark_node
;
16695 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
16697 integral_constant_expression_p
,
16698 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
16699 &non_integral_constant_expression_p
,
16700 /*template_p=*/false,
16702 /*address_p=*/false,
16703 /*template_arg_p=*/false,
16708 if (!function_p
&& identifier_p (decl
))
16710 if (complain
& tf_error
)
16711 unqualified_name_lookup_error (decl
);
16712 decl
= error_mark_node
;
16717 case TEMPLATE_ID_EXPR
:
16720 tree templ
= RECUR (TREE_OPERAND (t
, 0));
16721 tree targs
= TREE_OPERAND (t
, 1);
16724 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
16725 if (targs
== error_mark_node
)
16726 return error_mark_node
;
16728 if (TREE_CODE (templ
) == SCOPE_REF
)
16730 tree name
= TREE_OPERAND (templ
, 1);
16731 tree tid
= lookup_template_function (name
, targs
);
16732 TREE_OPERAND (templ
, 1) = tid
;
16736 if (variable_template_p (templ
))
16737 RETURN (lookup_and_finish_template_variable (templ
, targs
, complain
));
16739 if (TREE_CODE (templ
) == COMPONENT_REF
)
16741 object
= TREE_OPERAND (templ
, 0);
16742 templ
= TREE_OPERAND (templ
, 1);
16745 object
= NULL_TREE
;
16746 templ
= lookup_template_function (templ
, targs
);
16749 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
16750 object
, templ
, NULL_TREE
));
16752 RETURN (baselink_for_fns (templ
));
16757 tree r
= RECUR (TREE_OPERAND (t
, 0));
16759 if (REFERENCE_REF_P (t
))
16761 /* A type conversion to reference type will be enclosed in
16762 such an indirect ref, but the substitution of the cast
16763 will have also added such an indirect ref. */
16764 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
16765 r
= convert_from_reference (r
);
16768 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
16769 complain
|decltype_flag
);
16771 if (TREE_CODE (r
) == INDIRECT_REF
)
16772 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
16779 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16780 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16781 RETURN (build_nop (type
, op0
));
16784 case IMPLICIT_CONV_EXPR
:
16786 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16787 tree expr
= RECUR (TREE_OPERAND (t
, 0));
16788 int flags
= LOOKUP_IMPLICIT
;
16789 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
16790 flags
= LOOKUP_NORMAL
;
16791 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
16797 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16798 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16799 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
16803 case REINTERPRET_CAST_EXPR
:
16804 case CONST_CAST_EXPR
:
16805 case DYNAMIC_CAST_EXPR
:
16806 case STATIC_CAST_EXPR
:
16809 tree op
, r
= NULL_TREE
;
16811 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16812 if (integral_constant_expression_p
16813 && !cast_valid_in_integral_constant_expression_p (type
))
16815 if (complain
& tf_error
)
16816 error ("a cast to a type other than an integral or "
16817 "enumeration type cannot appear in a constant-expression");
16818 RETURN (error_mark_node
);
16821 op
= RECUR (TREE_OPERAND (t
, 0));
16823 warning_sentinel
s(warn_useless_cast
);
16824 switch (TREE_CODE (t
))
16827 r
= build_functional_cast (type
, op
, complain
);
16829 case REINTERPRET_CAST_EXPR
:
16830 r
= build_reinterpret_cast (type
, op
, complain
);
16832 case CONST_CAST_EXPR
:
16833 r
= build_const_cast (type
, op
, complain
);
16835 case DYNAMIC_CAST_EXPR
:
16836 r
= build_dynamic_cast (type
, op
, complain
);
16838 case STATIC_CAST_EXPR
:
16839 r
= build_static_cast (type
, op
, complain
);
16842 gcc_unreachable ();
16848 case POSTDECREMENT_EXPR
:
16849 case POSTINCREMENT_EXPR
:
16850 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
16851 args
, complain
, in_decl
);
16852 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
16853 complain
|decltype_flag
));
16855 case PREDECREMENT_EXPR
:
16856 case PREINCREMENT_EXPR
:
16860 case TRUTH_NOT_EXPR
:
16861 case UNARY_PLUS_EXPR
: /* Unary + */
16862 case REALPART_EXPR
:
16863 case IMAGPART_EXPR
:
16864 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
16865 RECUR (TREE_OPERAND (t
, 0)),
16866 complain
|decltype_flag
));
16868 case FIX_TRUNC_EXPR
:
16869 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
16873 op1
= TREE_OPERAND (t
, 0);
16874 if (TREE_CODE (op1
) == LABEL_DECL
)
16875 RETURN (finish_label_address_expr (DECL_NAME (op1
),
16876 EXPR_LOCATION (op1
)));
16877 if (TREE_CODE (op1
) == SCOPE_REF
)
16878 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
16879 /*done=*/true, /*address_p=*/true);
16881 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
16883 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
16884 complain
|decltype_flag
));
16889 case TRUNC_DIV_EXPR
:
16890 case CEIL_DIV_EXPR
:
16891 case FLOOR_DIV_EXPR
:
16892 case ROUND_DIV_EXPR
:
16893 case EXACT_DIV_EXPR
:
16897 case TRUNC_MOD_EXPR
:
16898 case FLOOR_MOD_EXPR
:
16899 case TRUTH_ANDIF_EXPR
:
16900 case TRUTH_ORIF_EXPR
:
16901 case TRUTH_AND_EXPR
:
16902 case TRUTH_OR_EXPR
:
16918 warning_sentinel
s1(warn_type_limits
);
16919 warning_sentinel
s2(warn_div_by_zero
);
16920 warning_sentinel
s3(warn_logical_op
);
16921 warning_sentinel
s4(warn_tautological_compare
);
16922 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16923 tree op1
= RECUR (TREE_OPERAND (t
, 1));
16924 tree r
= build_x_binary_op
16925 (input_location
, TREE_CODE (t
),
16927 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
16929 : TREE_CODE (TREE_OPERAND (t
, 0))),
16931 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
16933 : TREE_CODE (TREE_OPERAND (t
, 1))),
16935 complain
|decltype_flag
);
16936 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
16937 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
16942 case POINTER_PLUS_EXPR
:
16944 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16945 tree op1
= RECUR (TREE_OPERAND (t
, 1));
16946 return fold_build_pointer_plus (op0
, op1
);
16950 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
16951 /*address_p=*/false));
16953 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
16954 args
, complain
, in_decl
);
16955 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
16956 RECUR (TREE_OPERAND (t
, 1)),
16957 complain
|decltype_flag
));
16959 case ARRAY_NOTATION_REF
:
16961 tree start_index
, length
, stride
;
16962 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
16963 args
, complain
, in_decl
);
16964 start_index
= RECUR (ARRAY_NOTATION_START (t
));
16965 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
16966 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
16967 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
16968 length
, stride
, TREE_TYPE (op1
)));
16971 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
16972 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
16973 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
16980 op1
= TREE_OPERAND (t
, 0);
16981 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
16982 op1
= TREE_TYPE (op1
);
16985 /* When there are no ARGS, we are trying to evaluate a
16986 non-dependent expression from the parser. Trying to do
16987 the substitutions may not work. */
16989 op1
= TREE_TYPE (op1
);
16993 ++cp_unevaluated_operand
;
16994 ++c_inhibit_evaluation_warnings
;
16996 op1
= tsubst (op1
, args
, complain
, in_decl
);
16998 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
16999 /*function_p=*/false,
17000 /*integral_constant_expression_p=*/
17002 --cp_unevaluated_operand
;
17003 --c_inhibit_evaluation_warnings
;
17006 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
17007 complain
& tf_error
);
17009 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
17010 complain
& tf_error
);
17011 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
17013 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
17015 if (!processing_template_decl
&& TYPE_P (op1
))
17017 r
= build_min (SIZEOF_EXPR
, size_type_node
,
17018 build1 (NOP_EXPR
, op1
, error_mark_node
));
17019 SIZEOF_EXPR_TYPE_P (r
) = 1;
17022 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
17023 TREE_SIDE_EFFECTS (r
) = 0;
17024 TREE_READONLY (r
) = 1;
17026 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
17031 case AT_ENCODE_EXPR
:
17033 op1
= TREE_OPERAND (t
, 0);
17034 ++cp_unevaluated_operand
;
17035 ++c_inhibit_evaluation_warnings
;
17036 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
17037 /*function_p=*/false,
17038 /*integral_constant_expression_p=*/false);
17039 --cp_unevaluated_operand
;
17040 --c_inhibit_evaluation_warnings
;
17041 RETURN (objc_build_encode_expr (op1
));
17044 case NOEXCEPT_EXPR
:
17045 op1
= TREE_OPERAND (t
, 0);
17046 ++cp_unevaluated_operand
;
17047 ++c_inhibit_evaluation_warnings
;
17048 ++cp_noexcept_operand
;
17049 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
17050 /*function_p=*/false,
17051 /*integral_constant_expression_p=*/false);
17052 --cp_unevaluated_operand
;
17053 --c_inhibit_evaluation_warnings
;
17054 --cp_noexcept_operand
;
17055 RETURN (finish_noexcept_expr (op1
, complain
));
17059 warning_sentinel
s(warn_div_by_zero
);
17060 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
17061 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
17062 tree r
= build_x_modify_expr
17063 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
17064 complain
|decltype_flag
);
17065 /* TREE_NO_WARNING must be set if either the expression was
17066 parenthesized or it uses an operator such as >>= rather
17067 than plain assignment. In the former case, it was already
17068 set and must be copied. In the latter case,
17069 build_x_modify_expr sets it and it must not be reset
17071 if (TREE_NO_WARNING (t
))
17072 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
17078 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
17079 args
, complain
, in_decl
);
17080 /* Remember that there was a reference to this entity. */
17082 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
17083 RETURN (error_mark_node
);
17084 RETURN (build_x_arrow (input_location
, op1
, complain
));
17088 tree placement
= RECUR (TREE_OPERAND (t
, 0));
17089 tree init
= RECUR (TREE_OPERAND (t
, 3));
17090 vec
<tree
, va_gc
> *placement_vec
;
17091 vec
<tree
, va_gc
> *init_vec
;
17094 if (placement
== NULL_TREE
)
17095 placement_vec
= NULL
;
17098 placement_vec
= make_tree_vector ();
17099 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
17100 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
17103 /* If there was an initializer in the original tree, but it
17104 instantiated to an empty list, then we should pass a
17105 non-NULL empty vector to tell build_new that it was an
17106 empty initializer() rather than no initializer. This can
17107 only happen when the initializer is a pack expansion whose
17108 parameter packs are of length zero. */
17109 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
17113 init_vec
= make_tree_vector ();
17114 if (init
== void_node
)
17115 gcc_assert (init_vec
!= NULL
);
17118 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
17119 vec_safe_push (init_vec
, TREE_VALUE (init
));
17123 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
17124 tree op2
= RECUR (TREE_OPERAND (t
, 2));
17125 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
17126 NEW_EXPR_USE_GLOBAL (t
),
17129 if (placement_vec
!= NULL
)
17130 release_tree_vector (placement_vec
);
17131 if (init_vec
!= NULL
)
17132 release_tree_vector (init_vec
);
17139 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17140 tree op1
= RECUR (TREE_OPERAND (t
, 1));
17141 RETURN (delete_sanity (op0
, op1
,
17142 DELETE_EXPR_USE_VEC (t
),
17143 DELETE_EXPR_USE_GLOBAL (t
),
17147 case COMPOUND_EXPR
:
17149 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
17150 complain
& ~tf_decltype
, in_decl
,
17151 /*function_p=*/false,
17152 integral_constant_expression_p
);
17153 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
17155 RECUR (TREE_OPERAND (t
, 1)),
17156 complain
|decltype_flag
));
17162 vec
<tree
, va_gc
> *call_args
;
17163 unsigned int nargs
, i
;
17168 function
= CALL_EXPR_FN (t
);
17169 /* Internal function with no arguments. */
17170 if (function
== NULL_TREE
&& call_expr_nargs (t
) == 0)
17173 /* When we parsed the expression, we determined whether or
17174 not Koenig lookup should be performed. */
17175 koenig_p
= KOENIG_LOOKUP_P (t
);
17176 if (function
== NULL_TREE
)
17179 qualified_p
= false;
17181 else if (TREE_CODE (function
) == SCOPE_REF
)
17183 qualified_p
= true;
17184 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
17186 /*address_p=*/false);
17188 else if (koenig_p
&& identifier_p (function
))
17190 /* Do nothing; calling tsubst_copy_and_build on an identifier
17191 would incorrectly perform unqualified lookup again.
17193 Note that we can also have an IDENTIFIER_NODE if the earlier
17194 unqualified lookup found a member function; in that case
17195 koenig_p will be false and we do want to do the lookup
17196 again to find the instantiated member function.
17198 FIXME but doing that causes c++/15272, so we need to stop
17199 using IDENTIFIER_NODE in that situation. */
17200 qualified_p
= false;
17204 if (TREE_CODE (function
) == COMPONENT_REF
)
17206 tree op
= TREE_OPERAND (function
, 1);
17208 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
17209 || (BASELINK_P (op
)
17210 && BASELINK_QUALIFIED_P (op
)));
17213 qualified_p
= false;
17215 if (TREE_CODE (function
) == ADDR_EXPR
17216 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
17217 /* Avoid error about taking the address of a constructor. */
17218 function
= TREE_OPERAND (function
, 0);
17220 function
= tsubst_copy_and_build (function
, args
, complain
,
17223 integral_constant_expression_p
);
17225 if (BASELINK_P (function
))
17226 qualified_p
= true;
17229 nargs
= call_expr_nargs (t
);
17230 call_args
= make_tree_vector ();
17231 for (i
= 0; i
< nargs
; ++i
)
17233 tree arg
= CALL_EXPR_ARG (t
, i
);
17235 if (!PACK_EXPANSION_P (arg
))
17236 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
17239 /* Expand the pack expansion and push each entry onto
17241 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
17242 if (TREE_CODE (arg
) == TREE_VEC
)
17244 unsigned int len
, j
;
17246 len
= TREE_VEC_LENGTH (arg
);
17247 for (j
= 0; j
< len
; ++j
)
17249 tree value
= TREE_VEC_ELT (arg
, j
);
17250 if (value
!= NULL_TREE
)
17251 value
= convert_from_reference (value
);
17252 vec_safe_push (call_args
, value
);
17257 /* A partial substitution. Add one entry. */
17258 vec_safe_push (call_args
, arg
);
17263 /* We do not perform argument-dependent lookup if normal
17264 lookup finds a non-function, in accordance with the
17265 expected resolution of DR 218. */
17267 && ((is_overloaded_fn (function
)
17268 /* If lookup found a member function, the Koenig lookup is
17269 not appropriate, even if an unqualified-name was used
17270 to denote the function. */
17271 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
17272 || identifier_p (function
))
17273 /* Only do this when substitution turns a dependent call
17274 into a non-dependent call. */
17275 && type_dependent_expression_p_push (t
)
17276 && !any_type_dependent_arguments_p (call_args
))
17277 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
17279 if (function
!= NULL_TREE
17280 && identifier_p (function
)
17281 && !any_type_dependent_arguments_p (call_args
))
17283 if (koenig_p
&& (complain
& tf_warning_or_error
))
17285 /* For backwards compatibility and good diagnostics, try
17286 the unqualified lookup again if we aren't in SFINAE
17288 tree unq
= (tsubst_copy_and_build
17289 (function
, args
, complain
, in_decl
, true,
17290 integral_constant_expression_p
));
17291 if (unq
== error_mark_node
)
17293 release_tree_vector (call_args
);
17294 RETURN (error_mark_node
);
17297 if (unq
!= function
)
17299 /* In a lambda fn, we have to be careful to not
17300 introduce new this captures. Legacy code can't
17301 be using lambdas anyway, so it's ok to be
17303 bool in_lambda
= (current_class_type
17304 && LAMBDA_TYPE_P (current_class_type
));
17305 char const *const msg
17306 = G_("%qD was not declared in this scope, "
17307 "and no declarations were found by "
17308 "argument-dependent lookup at the point "
17309 "of instantiation");
17313 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
17316 diag
= permerror (EXPR_LOC_OR_LOC (t
, input_location
),
17322 if (INDIRECT_REF_P (fn
))
17323 fn
= TREE_OPERAND (fn
, 0);
17324 if (is_overloaded_fn (fn
))
17325 fn
= get_first_fn (fn
);
17328 /* Can't say anything more. */;
17329 else if (DECL_CLASS_SCOPE_P (fn
))
17331 location_t loc
= EXPR_LOC_OR_LOC (t
,
17334 "declarations in dependent base %qT are "
17335 "not found by unqualified lookup",
17336 DECL_CLASS_CONTEXT (fn
));
17337 if (current_class_ptr
)
17339 "use %<this->%D%> instead", function
);
17342 "use %<%T::%D%> instead",
17343 current_class_name
, function
);
17346 inform (DECL_SOURCE_LOCATION (fn
),
17347 "%qD declared here, later in the "
17348 "translation unit", fn
);
17351 release_tree_vector (call_args
);
17352 RETURN (error_mark_node
);
17359 if (identifier_p (function
))
17361 if (complain
& tf_error
)
17362 unqualified_name_lookup_error (function
);
17363 release_tree_vector (call_args
);
17364 RETURN (error_mark_node
);
17368 /* Remember that there was a reference to this entity. */
17369 if (function
!= NULL_TREE
17370 && DECL_P (function
)
17371 && !mark_used (function
, complain
) && !(complain
& tf_error
))
17373 release_tree_vector (call_args
);
17374 RETURN (error_mark_node
);
17377 /* Put back tf_decltype for the actual call. */
17378 complain
|= decltype_flag
;
17380 if (function
== NULL_TREE
)
17381 switch (CALL_EXPR_IFN (t
))
17384 gcc_assert (nargs
== 1);
17385 if (vec_safe_length (call_args
) != 1)
17387 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
17388 "wrong number of arguments to "
17389 "%<__builtin_launder%>");
17390 ret
= error_mark_node
;
17393 ret
= finish_builtin_launder (EXPR_LOC_OR_LOC (t
,
17395 (*call_args
)[0], complain
);
17399 /* Unsupported internal function with arguments. */
17400 gcc_unreachable ();
17402 else if (TREE_CODE (function
) == OFFSET_REF
)
17403 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
17405 else if (TREE_CODE (function
) == COMPONENT_REF
)
17407 tree instance
= TREE_OPERAND (function
, 0);
17408 tree fn
= TREE_OPERAND (function
, 1);
17410 if (processing_template_decl
17411 && (type_dependent_expression_p (instance
)
17412 || (!BASELINK_P (fn
)
17413 && TREE_CODE (fn
) != FIELD_DECL
)
17414 || type_dependent_expression_p (fn
)
17415 || any_type_dependent_arguments_p (call_args
)))
17416 ret
= build_min_nt_call_vec (function
, call_args
);
17417 else if (!BASELINK_P (fn
))
17418 ret
= finish_call_expr (function
, &call_args
,
17419 /*disallow_virtual=*/false,
17420 /*koenig_p=*/false,
17423 ret
= (build_new_method_call
17425 &call_args
, NULL_TREE
,
17426 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
17431 ret
= finish_call_expr (function
, &call_args
,
17432 /*disallow_virtual=*/qualified_p
,
17436 release_tree_vector (call_args
);
17438 if (ret
!= error_mark_node
)
17440 bool op
= CALL_EXPR_OPERATOR_SYNTAX (t
);
17441 bool ord
= CALL_EXPR_ORDERED_ARGS (t
);
17442 bool rev
= CALL_EXPR_REVERSE_ARGS (t
);
17443 bool thk
= CALL_FROM_THUNK_P (t
);
17444 if (op
|| ord
|| rev
|| thk
)
17446 function
= extract_call_expr (ret
);
17447 CALL_EXPR_OPERATOR_SYNTAX (function
) = op
;
17448 CALL_EXPR_ORDERED_ARGS (function
) = ord
;
17449 CALL_EXPR_REVERSE_ARGS (function
) = rev
;
17452 CALL_FROM_THUNK_P (function
) = true;
17453 /* The thunk location is not interesting. */
17454 SET_EXPR_LOCATION (function
, UNKNOWN_LOCATION
);
17464 tree cond
= RECUR (TREE_OPERAND (t
, 0));
17465 tree folded_cond
= fold_non_dependent_expr (cond
);
17468 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
17470 if (integer_zerop (folded_cond
))
17472 ++c_inhibit_evaluation_warnings
;
17473 exp1
= RECUR (TREE_OPERAND (t
, 1));
17474 --c_inhibit_evaluation_warnings
;
17475 exp2
= RECUR (TREE_OPERAND (t
, 2));
17479 exp1
= RECUR (TREE_OPERAND (t
, 1));
17480 ++c_inhibit_evaluation_warnings
;
17481 exp2
= RECUR (TREE_OPERAND (t
, 2));
17482 --c_inhibit_evaluation_warnings
;
17484 cond
= folded_cond
;
17488 exp1
= RECUR (TREE_OPERAND (t
, 1));
17489 exp2
= RECUR (TREE_OPERAND (t
, 2));
17492 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
17493 cond
, exp1
, exp2
, complain
));
17496 case PSEUDO_DTOR_EXPR
:
17498 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17499 tree op1
= RECUR (TREE_OPERAND (t
, 1));
17500 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
17501 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
17507 tree purpose
, value
, chain
;
17509 if (t
== void_list_node
)
17512 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
17513 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
17515 /* We have pack expansions, so expand those and
17516 create a new list out of it. */
17517 tree purposevec
= NULL_TREE
;
17518 tree valuevec
= NULL_TREE
;
17522 /* Expand the argument expressions. */
17523 if (TREE_PURPOSE (t
))
17524 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
17525 complain
, in_decl
);
17526 if (TREE_VALUE (t
))
17527 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
17528 complain
, in_decl
);
17530 /* Build the rest of the list. */
17531 chain
= TREE_CHAIN (t
);
17532 if (chain
&& chain
!= void_type_node
)
17533 chain
= RECUR (chain
);
17535 /* Determine the number of arguments. */
17536 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
17538 len
= TREE_VEC_LENGTH (purposevec
);
17539 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
17541 else if (TREE_CODE (valuevec
) == TREE_VEC
)
17542 len
= TREE_VEC_LENGTH (valuevec
);
17545 /* Since we only performed a partial substitution into
17546 the argument pack, we only RETURN (a single list
17548 if (purposevec
== TREE_PURPOSE (t
)
17549 && valuevec
== TREE_VALUE (t
)
17550 && chain
== TREE_CHAIN (t
))
17553 RETURN (tree_cons (purposevec
, valuevec
, chain
));
17556 /* Convert the argument vectors into a TREE_LIST */
17560 /* Grab the Ith values. */
17562 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
17565 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
17568 /* Build the list (backwards). */
17569 chain
= tree_cons (purpose
, value
, chain
);
17575 purpose
= TREE_PURPOSE (t
);
17577 purpose
= RECUR (purpose
);
17578 value
= TREE_VALUE (t
);
17580 value
= RECUR (value
);
17581 chain
= TREE_CHAIN (t
);
17582 if (chain
&& chain
!= void_type_node
)
17583 chain
= RECUR (chain
);
17584 if (purpose
== TREE_PURPOSE (t
)
17585 && value
== TREE_VALUE (t
)
17586 && chain
== TREE_CHAIN (t
))
17588 RETURN (tree_cons (purpose
, value
, chain
));
17591 case COMPONENT_REF
:
17598 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
17599 args
, complain
, in_decl
);
17600 /* Remember that there was a reference to this entity. */
17601 if (DECL_P (object
)
17602 && !mark_used (object
, complain
) && !(complain
& tf_error
))
17603 RETURN (error_mark_node
);
17604 object_type
= TREE_TYPE (object
);
17606 member
= TREE_OPERAND (t
, 1);
17607 if (BASELINK_P (member
))
17608 member
= tsubst_baselink (member
,
17609 non_reference (TREE_TYPE (object
)),
17610 args
, complain
, in_decl
);
17612 member
= tsubst_copy (member
, args
, complain
, in_decl
);
17613 if (member
== error_mark_node
)
17614 RETURN (error_mark_node
);
17616 if (TREE_CODE (member
) == FIELD_DECL
)
17618 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
17619 if (TREE_CODE (r
) == COMPONENT_REF
)
17620 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
17623 else if (type_dependent_expression_p (object
))
17624 /* We can't do much here. */;
17625 else if (!CLASS_TYPE_P (object_type
))
17627 if (scalarish_type_p (object_type
))
17629 tree s
= NULL_TREE
;
17630 tree dtor
= member
;
17632 if (TREE_CODE (dtor
) == SCOPE_REF
)
17634 s
= TREE_OPERAND (dtor
, 0);
17635 dtor
= TREE_OPERAND (dtor
, 1);
17637 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
17639 dtor
= TREE_OPERAND (dtor
, 0);
17641 RETURN (finish_pseudo_destructor_expr
17642 (object
, s
, dtor
, input_location
));
17646 else if (TREE_CODE (member
) == SCOPE_REF
17647 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
17649 /* Lookup the template functions now that we know what the
17651 tree scope
= TREE_OPERAND (member
, 0);
17652 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
17653 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
17654 member
= lookup_qualified_name (scope
, tmpl
,
17655 /*is_type_p=*/false,
17656 /*complain=*/false);
17657 if (BASELINK_P (member
))
17659 BASELINK_FUNCTIONS (member
)
17660 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
17662 member
= (adjust_result_of_qualified_name_lookup
17663 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
17668 qualified_name_lookup_error (scope
, tmpl
, member
,
17670 RETURN (error_mark_node
);
17673 else if (TREE_CODE (member
) == SCOPE_REF
17674 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
17675 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
17677 if (complain
& tf_error
)
17679 if (TYPE_P (TREE_OPERAND (member
, 0)))
17680 error ("%qT is not a class or namespace",
17681 TREE_OPERAND (member
, 0));
17683 error ("%qD is not a class or namespace",
17684 TREE_OPERAND (member
, 0));
17686 RETURN (error_mark_node
);
17689 r
= finish_class_member_access_expr (object
, member
,
17690 /*template_p=*/false,
17692 if (TREE_CODE (r
) == COMPONENT_REF
)
17693 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
17698 RETURN (build_throw
17699 (RECUR (TREE_OPERAND (t
, 0))));
17703 vec
<constructor_elt
, va_gc
> *n
;
17704 constructor_elt
*ce
;
17705 unsigned HOST_WIDE_INT idx
;
17706 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17707 bool process_index_p
;
17709 bool need_copy_p
= false;
17712 if (type
== error_mark_node
)
17713 RETURN (error_mark_node
);
17715 /* digest_init will do the wrong thing if we let it. */
17716 if (type
&& TYPE_PTRMEMFUNC_P (type
))
17719 /* We do not want to process the index of aggregate
17720 initializers as they are identifier nodes which will be
17721 looked up by digest_init. */
17722 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
17724 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
17725 newlen
= vec_safe_length (n
);
17726 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
17728 if (ce
->index
&& process_index_p
17729 /* An identifier index is looked up in the type
17730 being initialized, not the current scope. */
17731 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
17732 ce
->index
= RECUR (ce
->index
);
17734 if (PACK_EXPANSION_P (ce
->value
))
17736 /* Substitute into the pack expansion. */
17737 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
17740 if (ce
->value
== error_mark_node
17741 || PACK_EXPANSION_P (ce
->value
))
17743 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
17744 /* Just move the argument into place. */
17745 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
17748 /* Update the length of the final CONSTRUCTOR
17749 arguments vector, and note that we will need to
17751 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
17752 need_copy_p
= true;
17756 ce
->value
= RECUR (ce
->value
);
17761 vec
<constructor_elt
, va_gc
> *old_n
= n
;
17763 vec_alloc (n
, newlen
);
17764 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
17766 if (TREE_CODE (ce
->value
) == TREE_VEC
)
17768 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
17769 for (i
= 0; i
< len
; ++i
)
17770 CONSTRUCTOR_APPEND_ELT (n
, 0,
17771 TREE_VEC_ELT (ce
->value
, i
));
17774 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
17778 r
= build_constructor (init_list_type_node
, n
);
17779 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
17781 if (TREE_HAS_CONSTRUCTOR (t
))
17783 fcl_t cl
= fcl_functional
;
17784 if (CONSTRUCTOR_C99_COMPOUND_LITERAL (t
))
17786 RETURN (finish_compound_literal (type
, r
, complain
, cl
));
17789 TREE_TYPE (r
) = type
;
17795 tree operand_0
= TREE_OPERAND (t
, 0);
17796 if (TYPE_P (operand_0
))
17798 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
17799 RETURN (get_typeid (operand_0
, complain
));
17803 operand_0
= RECUR (operand_0
);
17804 RETURN (build_typeid (operand_0
, complain
));
17811 else if (DECL_PACK_P (t
))
17813 /* We don't build decls for an instantiation of a
17814 variadic capture proxy, we instantiate the elements
17816 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
17817 return RECUR (DECL_VALUE_EXPR (t
));
17823 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
17824 /* ??? We're doing a subset of finish_id_expression here. */
17826 && !processing_template_decl
17827 && !cp_unevaluated_operand
17828 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
17829 && CP_DECL_THREAD_LOCAL_P (r
))
17831 if (tree wrap
= get_tls_wrapper_fn (r
))
17832 /* Replace an evaluated use of the thread_local variable with
17833 a call to its wrapper. */
17834 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
17836 else if (outer_automatic_var_p (r
))
17838 r
= process_outer_var_ref (r
, complain
);
17839 if (is_capture_proxy (r
))
17840 register_local_specialization (r
, t
);
17843 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
17844 /* If the original type was a reference, we'll be wrapped in
17845 the appropriate INDIRECT_REF. */
17846 r
= convert_from_reference (r
);
17852 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17853 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17854 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
17857 case OFFSETOF_EXPR
:
17860 = tsubst_copy_and_build (TREE_OPERAND (t
, 1), args
, complain
,
17861 in_decl
, /*function_p=*/false,
17862 /*integral_constant_expression_p=*/false);
17863 RETURN (finish_offsetof (object_ptr
,
17864 RECUR (TREE_OPERAND (t
, 0)),
17865 EXPR_LOCATION (t
)));
17868 case ADDRESSOF_EXPR
:
17869 RETURN (cp_build_addressof (EXPR_LOCATION (t
),
17870 RECUR (TREE_OPERAND (t
, 0)), complain
));
17874 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
17875 complain
, in_decl
);
17877 tree type2
= TRAIT_EXPR_TYPE2 (t
);
17878 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
17879 type2
= RECUR (type2
);
17881 type2
= tsubst (type2
, args
, complain
, in_decl
);
17883 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
17888 tree old_stmt_expr
= cur_stmt_expr
;
17889 tree stmt_expr
= begin_stmt_expr ();
17891 cur_stmt_expr
= stmt_expr
;
17892 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
17893 integral_constant_expression_p
);
17894 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
17895 cur_stmt_expr
= old_stmt_expr
;
17897 /* If the resulting list of expression statement is empty,
17898 fold it further into void_node. */
17899 if (empty_expr_stmt_p (stmt_expr
))
17900 stmt_expr
= void_node
;
17902 RETURN (stmt_expr
);
17907 tree r
= build_lambda_expr ();
17909 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
17910 LAMBDA_EXPR_CLOSURE (r
) = type
;
17911 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
17913 LAMBDA_EXPR_LOCATION (r
)
17914 = LAMBDA_EXPR_LOCATION (t
);
17915 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
17916 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
17917 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
17918 LAMBDA_EXPR_DISCRIMINATOR (r
)
17919 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
17920 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
17922 /* No substitution needed. */;
17923 else if (VAR_OR_FUNCTION_DECL_P (scope
))
17924 /* For a function or variable scope, we want to use tsubst so that we
17925 don't complain about referring to an auto before deduction. */
17926 scope
= tsubst (scope
, args
, complain
, in_decl
);
17927 else if (TREE_CODE (scope
) == PARM_DECL
)
17929 /* Look up the parameter we want directly, as tsubst_copy
17930 doesn't do what we need. */
17931 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
17932 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
17933 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
17934 parm
= DECL_CHAIN (parm
);
17936 /* FIXME Work around the parm not having DECL_CONTEXT set. */
17937 if (DECL_CONTEXT (scope
) == NULL_TREE
)
17938 DECL_CONTEXT (scope
) = fn
;
17940 else if (TREE_CODE (scope
) == FIELD_DECL
)
17941 /* For a field, use tsubst_copy so that we look up the existing field
17942 rather than build a new one. */
17943 scope
= RECUR (scope
);
17945 gcc_unreachable ();
17946 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
17948 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
17949 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
17951 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
17952 determine_visibility (TYPE_NAME (type
));
17953 /* Now that we know visibility, instantiate the type so we have a
17954 declaration of the op() for later calls to lambda_function. */
17955 complete_type (type
);
17957 if (tree fn
= lambda_function (type
))
17958 LAMBDA_EXPR_RETURN_TYPE (r
) = TREE_TYPE (TREE_TYPE (fn
));
17960 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
17962 insert_pending_capture_proxies ();
17964 RETURN (build_lambda_object (r
));
17968 /* We can get here for a constant initializer of non-dependent type.
17969 FIXME stop folding in cp_parser_initializer_clause. */
17971 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
17976 case TRANSACTION_EXPR
:
17977 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
17978 integral_constant_expression_p
));
17981 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
17983 case VEC_PERM_EXPR
:
17985 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17986 tree op1
= RECUR (TREE_OPERAND (t
, 1));
17987 tree op2
= RECUR (TREE_OPERAND (t
, 2));
17988 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
17992 case REQUIRES_EXPR
:
17993 RETURN (tsubst_requires_expr (t
, args
, complain
, in_decl
));
17996 /* Handle Objective-C++ constructs, if appropriate. */
17999 = objcp_tsubst_copy_and_build (t
, args
, complain
,
18000 in_decl
, /*function_p=*/false);
18004 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
18010 input_location
= loc
;
18014 /* Verify that the instantiated ARGS are valid. For type arguments,
18015 make sure that the type's linkage is ok. For non-type arguments,
18016 make sure they are constants if they are integral or enumerations.
18017 Emit an error under control of COMPLAIN, and return TRUE on error. */
18020 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
18022 if (dependent_template_arg_p (t
))
18024 if (ARGUMENT_PACK_P (t
))
18026 tree vec
= ARGUMENT_PACK_ARGS (t
);
18027 int len
= TREE_VEC_LENGTH (vec
);
18028 bool result
= false;
18031 for (i
= 0; i
< len
; ++i
)
18032 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
18036 else if (TYPE_P (t
))
18038 /* [basic.link]: A name with no linkage (notably, the name
18039 of a class or enumeration declared in a local scope)
18040 shall not be used to declare an entity with linkage.
18041 This implies that names with no linkage cannot be used as
18044 DR 757 relaxes this restriction for C++0x. */
18045 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
18046 : no_linkage_check (t
, /*relaxed_p=*/false));
18050 /* DR 488 makes use of a type with no linkage cause
18051 type deduction to fail. */
18052 if (complain
& tf_error
)
18054 if (TYPE_UNNAMED_P (nt
))
18055 error ("%qT is/uses unnamed type", t
);
18057 error ("template argument for %qD uses local type %qT",
18062 /* In order to avoid all sorts of complications, we do not
18063 allow variably-modified types as template arguments. */
18064 else if (variably_modified_type_p (t
, NULL_TREE
))
18066 if (complain
& tf_error
)
18067 error ("%qT is a variably modified type", t
);
18071 /* Class template and alias template arguments should be OK. */
18072 else if (DECL_TYPE_TEMPLATE_P (t
))
18074 /* A non-type argument of integral or enumerated type must be a
18076 else if (TREE_TYPE (t
)
18077 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
18078 && !REFERENCE_REF_P (t
)
18079 && !TREE_CONSTANT (t
))
18081 if (complain
& tf_error
)
18082 error ("integral expression %qE is not constant", t
);
18089 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
18091 int ix
, len
= DECL_NTPARMS (tmpl
);
18092 bool result
= false;
18094 for (ix
= 0; ix
!= len
; ix
++)
18096 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
18099 if (result
&& (complain
& tf_error
))
18100 error (" trying to instantiate %qD", tmpl
);
18104 /* We're out of SFINAE context now, so generate diagnostics for the access
18105 errors we saw earlier when instantiating D from TMPL and ARGS. */
18108 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
18110 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
18111 tree type
= TREE_TYPE (pattern
);
18112 location_t loc
= input_location
;
18114 push_access_scope (d
);
18115 push_deferring_access_checks (dk_no_deferred
);
18116 input_location
= DECL_SOURCE_LOCATION (pattern
);
18117 tsubst (type
, args
, tf_warning_or_error
, d
);
18118 input_location
= loc
;
18119 pop_deferring_access_checks ();
18120 pop_access_scope (d
);
18123 /* Instantiate the indicated variable, function, or alias template TMPL with
18124 the template arguments in TARG_PTR. */
18127 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
18129 tree targ_ptr
= orig_args
;
18133 bool access_ok
= true;
18135 if (tmpl
== error_mark_node
)
18136 return error_mark_node
;
18138 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
18140 /* If this function is a clone, handle it specially. */
18141 if (DECL_CLONED_FUNCTION_P (tmpl
))
18146 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
18147 DECL_CLONED_FUNCTION. */
18148 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
18149 targ_ptr
, complain
);
18150 if (spec
== error_mark_node
)
18151 return error_mark_node
;
18153 /* Look for the clone. */
18154 FOR_EACH_CLONE (clone
, spec
)
18155 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
18157 /* We should always have found the clone by now. */
18158 gcc_unreachable ();
18162 if (targ_ptr
== error_mark_node
)
18163 return error_mark_node
;
18165 /* Check to see if we already have this specialization. */
18166 gen_tmpl
= most_general_template (tmpl
);
18167 if (TMPL_ARGS_DEPTH (targ_ptr
)
18168 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
)))
18169 /* targ_ptr only has the innermost template args, so add the outer ones
18170 from tmpl, which could be either a partial instantiation or gen_tmpl (in
18171 the case of a non-dependent call within a template definition). */
18172 targ_ptr
= (add_outermost_template_args
18173 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (tmpl
)),
18176 /* It would be nice to avoid hashing here and then again in tsubst_decl,
18177 but it doesn't seem to be on the hot path. */
18178 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
18180 gcc_assert (tmpl
== gen_tmpl
18181 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
18183 || fndecl
== NULL_TREE
);
18185 if (spec
!= NULL_TREE
)
18187 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
18189 if (complain
& tf_error
)
18190 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
18191 return error_mark_node
;
18196 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
18198 return error_mark_node
;
18200 /* We are building a FUNCTION_DECL, during which the access of its
18201 parameters and return types have to be checked. However this
18202 FUNCTION_DECL which is the desired context for access checking
18203 is not built yet. We solve this chicken-and-egg problem by
18204 deferring all checks until we have the FUNCTION_DECL. */
18205 push_deferring_access_checks (dk_deferred
);
18207 /* Instantiation of the function happens in the context of the function
18208 template, not the context of the overload resolution we're doing. */
18209 push_to_top_level ();
18210 /* If there are dependent arguments, e.g. because we're doing partial
18211 ordering, make sure processing_template_decl stays set. */
18212 if (uses_template_parms (targ_ptr
))
18213 ++processing_template_decl
;
18214 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
18216 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
18217 complain
, gen_tmpl
, true);
18218 push_nested_class (ctx
);
18221 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
18223 fndecl
= NULL_TREE
;
18224 if (VAR_P (pattern
))
18226 /* We need to determine if we're using a partial or explicit
18227 specialization now, because the type of the variable could be
18229 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
18230 tree elt
= most_specialized_partial_spec (tid
, complain
);
18231 if (elt
== error_mark_node
)
18232 pattern
= error_mark_node
;
18235 tree partial_tmpl
= TREE_VALUE (elt
);
18236 tree partial_args
= TREE_PURPOSE (elt
);
18237 tree partial_pat
= DECL_TEMPLATE_RESULT (partial_tmpl
);
18238 fndecl
= tsubst (partial_pat
, partial_args
, complain
, gen_tmpl
);
18242 /* Substitute template parameters to obtain the specialization. */
18243 if (fndecl
== NULL_TREE
)
18244 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
18245 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
18246 pop_nested_class ();
18247 pop_from_top_level ();
18249 if (fndecl
== error_mark_node
)
18251 pop_deferring_access_checks ();
18252 return error_mark_node
;
18255 /* The DECL_TI_TEMPLATE should always be the immediate parent
18256 template, not the most general template. */
18257 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
18258 DECL_TI_ARGS (fndecl
) = targ_ptr
;
18260 /* Now we know the specialization, compute access previously
18261 deferred. Do no access control for inheriting constructors,
18262 as we already checked access for the inherited constructor. */
18263 if (!(flag_new_inheriting_ctors
18264 && DECL_INHERITED_CTOR (fndecl
)))
18266 push_access_scope (fndecl
);
18267 if (!perform_deferred_access_checks (complain
))
18269 pop_access_scope (fndecl
);
18271 pop_deferring_access_checks ();
18273 /* If we've just instantiated the main entry point for a function,
18274 instantiate all the alternate entry points as well. We do this
18275 by cloning the instantiation of the main entry point, not by
18276 instantiating the template clones. */
18277 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
18278 clone_function_decl (fndecl
, /*update_methods=*/false);
18282 if (!(complain
& tf_error
))
18284 /* Remember to reinstantiate when we're out of SFINAE so the user
18285 can see the errors. */
18286 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
18288 return error_mark_node
;
18293 /* Wrapper for instantiate_template_1. */
18296 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
18299 timevar_push (TV_TEMPLATE_INST
);
18300 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
18301 timevar_pop (TV_TEMPLATE_INST
);
18305 /* Instantiate the alias template TMPL with ARGS. Also push a template
18306 instantiation level, which instantiate_template doesn't do because
18307 functions and variables have sufficient context established by the
18311 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
18313 struct pending_template
*old_last_pend
= last_pending_template
;
18314 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
18315 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
18316 return error_mark_node
;
18317 tree tinst
= build_tree_list (tmpl
, args
);
18318 if (!push_tinst_level (tinst
))
18321 return error_mark_node
;
18325 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
18326 args
, tmpl
, complain
,
18327 /*require_all_args=*/true,
18328 /*use_default_args=*/true);
18330 tree r
= instantiate_template (tmpl
, args
, complain
);
18331 pop_tinst_level ();
18332 /* We can't free this if a pending_template entry or last_error_tinst_level
18333 is pointing at it. */
18334 if (last_pending_template
== old_last_pend
18335 && last_error_tinst_level
== old_error_tinst
)
18341 /* PARM is a template parameter pack for FN. Returns true iff
18342 PARM is used in a deducible way in the argument list of FN. */
18345 pack_deducible_p (tree parm
, tree fn
)
18347 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
18348 for (; t
; t
= TREE_CHAIN (t
))
18350 tree type
= TREE_VALUE (t
);
18352 if (!PACK_EXPANSION_P (type
))
18354 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
18355 packs
; packs
= TREE_CHAIN (packs
))
18356 if (template_args_equal (TREE_VALUE (packs
), parm
))
18358 /* The template parameter pack is used in a function parameter
18359 pack. If this is the end of the parameter list, the
18360 template parameter pack is deducible. */
18361 if (TREE_CHAIN (t
) == void_list_node
)
18364 /* Otherwise, not. Well, it could be deduced from
18365 a non-pack parameter, but doing so would end up with
18366 a deduction mismatch, so don't bother. */
18370 /* The template parameter pack isn't used in any function parameter
18371 packs, but it might be used deeper, e.g. tuple<Args...>. */
18375 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
18376 NARGS elements of the arguments that are being used when calling
18377 it. TARGS is a vector into which the deduced template arguments
18380 Returns either a FUNCTION_DECL for the matching specialization of FN or
18381 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
18382 true, diagnostics will be printed to explain why it failed.
18384 If FN is a conversion operator, or we are trying to produce a specific
18385 specialization, RETURN_TYPE is the return type desired.
18387 The EXPLICIT_TARGS are explicit template arguments provided via a
18390 The parameter STRICT is one of:
18393 We are deducing arguments for a function call, as in
18394 [temp.deduct.call]. If RETURN_TYPE is non-null, we are
18395 deducing arguments for a call to the result of a conversion
18396 function template, as in [over.call.object].
18399 We are deducing arguments for a conversion function, as in
18400 [temp.deduct.conv].
18403 We are deducing arguments when doing an explicit instantiation
18404 as in [temp.explicit], when determining an explicit specialization
18405 as in [temp.expl.spec], or when taking the address of a function
18406 template, as in [temp.deduct.funcaddr]. */
18409 fn_type_unification (tree fn
,
18410 tree explicit_targs
,
18413 unsigned int nargs
,
18415 unification_kind_t strict
,
18422 tree decl
= NULL_TREE
;
18423 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
18425 static int deduction_depth
;
18426 struct pending_template
*old_last_pend
= last_pending_template
;
18427 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
18430 if (flag_new_inheriting_ctors
)
18431 fn
= strip_inheriting_ctors (fn
);
18433 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
18435 tree r
= error_mark_node
;
18437 tree full_targs
= targs
;
18438 if (TMPL_ARGS_DEPTH (targs
)
18439 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (fn
)))
18440 full_targs
= (add_outermost_template_args
18441 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (fn
)),
18445 complain
|= tf_decltype
;
18447 /* In C++0x, it's possible to have a function template whose type depends
18448 on itself recursively. This is most obvious with decltype, but can also
18449 occur with enumeration scope (c++/48969). So we need to catch infinite
18450 recursion and reject the substitution at deduction time; this function
18451 will return error_mark_node for any repeated substitution.
18453 This also catches excessive recursion such as when f<N> depends on
18454 f<N-1> across all integers, and returns error_mark_node for all the
18455 substitutions back up to the initial one.
18457 This is, of course, not reentrant. */
18458 if (excessive_deduction_depth
)
18459 return error_mark_node
;
18460 tinst
= build_tree_list (fn
, NULL_TREE
);
18463 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
18465 fntype
= TREE_TYPE (fn
);
18466 if (explicit_targs
)
18470 The specified template arguments must match the template
18471 parameters in kind (i.e., type, nontype, template), and there
18472 must not be more arguments than there are parameters;
18473 otherwise type deduction fails.
18475 Nontype arguments must match the types of the corresponding
18476 nontype template parameters, or must be convertible to the
18477 types of the corresponding nontype parameters as specified in
18478 _temp.arg.nontype_, otherwise type deduction fails.
18480 All references in the function type of the function template
18481 to the corresponding template parameters are replaced by the
18482 specified template argument values. If a substitution in a
18483 template parameter or in the function type of the function
18484 template results in an invalid type, type deduction fails. */
18485 int i
, len
= TREE_VEC_LENGTH (tparms
);
18486 location_t loc
= input_location
;
18487 bool incomplete
= false;
18489 if (explicit_targs
== error_mark_node
)
18492 if (TMPL_ARGS_DEPTH (explicit_targs
)
18493 < TMPL_ARGS_DEPTH (full_targs
))
18494 explicit_targs
= add_outermost_template_args (full_targs
,
18497 /* Adjust any explicit template arguments before entering the
18498 substitution context. */
18500 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
18502 /*require_all_args=*/false,
18503 /*use_default_args=*/false));
18504 if (explicit_targs
== error_mark_node
)
18507 /* Substitute the explicit args into the function type. This is
18508 necessary so that, for instance, explicitly declared function
18509 arguments can match null pointed constants. If we were given
18510 an incomplete set of explicit args, we must not do semantic
18511 processing during substitution as we could create partial
18513 for (i
= 0; i
< len
; i
++)
18515 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
18516 bool parameter_pack
= false;
18517 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
18519 /* Dig out the actual parm. */
18520 if (TREE_CODE (parm
) == TYPE_DECL
18521 || TREE_CODE (parm
) == TEMPLATE_DECL
)
18523 parm
= TREE_TYPE (parm
);
18524 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
18526 else if (TREE_CODE (parm
) == PARM_DECL
)
18528 parm
= DECL_INITIAL (parm
);
18529 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
18532 if (!parameter_pack
&& targ
== NULL_TREE
)
18533 /* No explicit argument for this template parameter. */
18536 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
18538 /* Mark the argument pack as "incomplete". We could
18539 still deduce more arguments during unification.
18540 We remove this mark in type_unification_real. */
18543 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
18544 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
18545 = ARGUMENT_PACK_ARGS (targ
);
18548 /* We have some incomplete argument packs. */
18553 TREE_VALUE (tinst
) = explicit_targs
;
18554 if (!push_tinst_level (tinst
))
18556 excessive_deduction_depth
= true;
18559 processing_template_decl
+= incomplete
;
18560 input_location
= DECL_SOURCE_LOCATION (fn
);
18561 /* Ignore any access checks; we'll see them again in
18562 instantiate_template and they might have the wrong
18563 access path at this point. */
18564 push_deferring_access_checks (dk_deferred
);
18565 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
18566 complain
| tf_partial
| tf_fndecl_type
, NULL_TREE
);
18567 pop_deferring_access_checks ();
18568 input_location
= loc
;
18569 processing_template_decl
-= incomplete
;
18570 pop_tinst_level ();
18572 if (fntype
== error_mark_node
)
18575 /* Place the explicitly specified arguments in TARGS. */
18576 explicit_targs
= INNERMOST_TEMPLATE_ARGS (explicit_targs
);
18577 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
18578 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
18581 /* Never do unification on the 'this' parameter. */
18582 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
18584 if (return_type
&& strict
== DEDUCE_CALL
)
18586 /* We're deducing for a call to the result of a template conversion
18587 function. The parms we really want are in return_type. */
18588 if (POINTER_TYPE_P (return_type
))
18589 return_type
= TREE_TYPE (return_type
);
18590 parms
= TYPE_ARG_TYPES (return_type
);
18592 else if (return_type
)
18596 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
18597 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
18598 new_args
[0] = return_type
;
18599 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
18604 /* We allow incomplete unification without an error message here
18605 because the standard doesn't seem to explicitly prohibit it. Our
18606 callers must be ready to deal with unification failures in any
18609 TREE_VALUE (tinst
) = targs
;
18610 /* If we aren't explaining yet, push tinst context so we can see where
18611 any errors (e.g. from class instantiations triggered by instantiation
18612 of default template arguments) come from. If we are explaining, this
18613 context is redundant. */
18614 if (!explain_p
&& !push_tinst_level (tinst
))
18616 excessive_deduction_depth
= true;
18620 /* type_unification_real will pass back any access checks from default
18621 template argument substitution. */
18622 vec
<deferred_access_check
, va_gc
> *checks
;
18625 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
18626 full_targs
, parms
, args
, nargs
, /*subr=*/0,
18627 strict
, flags
, &checks
, explain_p
);
18629 pop_tinst_level ();
18633 /* Now that we have bindings for all of the template arguments,
18634 ensure that the arguments deduced for the template template
18635 parameters have compatible template parameter lists. We cannot
18636 check this property before we have deduced all template
18637 arguments, because the template parameter types of a template
18638 template parameter might depend on prior template parameters
18639 deduced after the template template parameter. The following
18640 ill-formed example illustrates this issue:
18642 template<typename T, template<T> class C> void f(C<5>, T);
18644 template<int N> struct X {};
18647 f(X<5>(), 5l); // error: template argument deduction fails
18650 The template parameter list of 'C' depends on the template type
18651 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
18652 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
18653 time that we deduce 'C'. */
18654 if (!template_template_parm_bindings_ok_p
18655 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
18657 unify_inconsistent_template_template_parameters (explain_p
);
18661 /* All is well so far. Now, check:
18665 When all template arguments have been deduced, all uses of
18666 template parameters in nondeduced contexts are replaced with
18667 the corresponding deduced argument values. If the
18668 substitution results in an invalid type, as described above,
18669 type deduction fails. */
18670 TREE_VALUE (tinst
) = targs
;
18671 if (!push_tinst_level (tinst
))
18673 excessive_deduction_depth
= true;
18677 /* Also collect access checks from the instantiation. */
18678 reopen_deferring_access_checks (checks
);
18680 decl
= instantiate_template (fn
, targs
, complain
);
18682 checks
= get_deferred_access_checks ();
18683 pop_deferring_access_checks ();
18685 pop_tinst_level ();
18687 if (decl
== error_mark_node
)
18690 /* Now perform any access checks encountered during substitution. */
18691 push_access_scope (decl
);
18692 ok
= perform_access_checks (checks
, complain
);
18693 pop_access_scope (decl
);
18697 /* If we're looking for an exact match, check that what we got
18698 is indeed an exact match. It might not be if some template
18699 parameters are used in non-deduced contexts. But don't check
18700 for an exact match if we have dependent template arguments;
18701 in that case we're doing partial ordering, and we already know
18702 that we have two candidates that will provide the actual type. */
18703 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
18705 tree substed
= TREE_TYPE (decl
);
18709 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
18711 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
18712 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
18713 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
18715 unify_type_mismatch (explain_p
, args
[i
],
18716 TREE_VALUE (sarg
));
18721 /* After doing deduction with the inherited constructor, actually return an
18722 instantiation of the inheriting constructor. */
18724 decl
= instantiate_template (orig_fn
, targs
, complain
);
18730 if (excessive_deduction_depth
)
18732 if (deduction_depth
== 0)
18733 /* Reset once we're all the way out. */
18734 excessive_deduction_depth
= false;
18737 /* We can't free this if a pending_template entry or last_error_tinst_level
18738 is pointing at it. */
18739 if (last_pending_template
== old_last_pend
18740 && last_error_tinst_level
== old_error_tinst
)
18746 /* Adjust types before performing type deduction, as described in
18747 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
18748 sections are symmetric. PARM is the type of a function parameter
18749 or the return type of the conversion function. ARG is the type of
18750 the argument passed to the call, or the type of the value
18751 initialized with the result of the conversion function.
18752 ARG_EXPR is the original argument expression, which may be null. */
18755 maybe_adjust_types_for_deduction (unification_kind_t strict
,
18768 /* Swap PARM and ARG throughout the remainder of this
18769 function; the handling is precisely symmetric since PARM
18770 will initialize ARG rather than vice versa. */
18771 std::swap (parm
, arg
);
18775 /* Core issue #873: Do the DR606 thing (see below) for these cases,
18776 too, but here handle it by stripping the reference from PARM
18777 rather than by adding it to ARG. */
18778 if (TREE_CODE (*parm
) == REFERENCE_TYPE
18779 && TYPE_REF_IS_RVALUE (*parm
)
18780 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
18781 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
18782 && TREE_CODE (*arg
) == REFERENCE_TYPE
18783 && !TYPE_REF_IS_RVALUE (*arg
))
18784 *parm
= TREE_TYPE (*parm
);
18785 /* Nothing else to do in this case. */
18789 gcc_unreachable ();
18792 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
18794 /* [temp.deduct.call]
18796 If P is not a reference type:
18798 --If A is an array type, the pointer type produced by the
18799 array-to-pointer standard conversion (_conv.array_) is
18800 used in place of A for type deduction; otherwise,
18802 --If A is a function type, the pointer type produced by
18803 the function-to-pointer standard conversion
18804 (_conv.func_) is used in place of A for type deduction;
18807 --If A is a cv-qualified type, the top level
18808 cv-qualifiers of A's type are ignored for type
18810 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
18811 *arg
= build_pointer_type (TREE_TYPE (*arg
));
18812 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
18813 *arg
= build_pointer_type (*arg
);
18815 *arg
= TYPE_MAIN_VARIANT (*arg
);
18818 /* [14.8.2.1/3 temp.deduct.call], "A forwarding reference is an rvalue
18819 reference to a cv-unqualified template parameter that does not represent a
18820 template parameter of a class template (during class template argument
18821 deduction (13.3.1.8)). If P is a forwarding reference and the argument is
18822 an lvalue, the type "lvalue reference to A" is used in place of A for type
18824 if (TREE_CODE (*parm
) == REFERENCE_TYPE
18825 && TYPE_REF_IS_RVALUE (*parm
)
18826 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
18827 && !TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (*parm
))
18828 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
18829 && (arg_expr
? lvalue_p (arg_expr
)
18830 /* try_one_overload doesn't provide an arg_expr, but
18831 functions are always lvalues. */
18832 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
18833 *arg
= build_reference_type (*arg
);
18835 /* [temp.deduct.call]
18837 If P is a cv-qualified type, the top level cv-qualifiers
18838 of P's type are ignored for type deduction. If P is a
18839 reference type, the type referred to by P is used for
18841 *parm
= TYPE_MAIN_VARIANT (*parm
);
18842 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
18844 *parm
= TREE_TYPE (*parm
);
18845 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
18848 /* DR 322. For conversion deduction, remove a reference type on parm
18849 too (which has been swapped into ARG). */
18850 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
18851 *arg
= TREE_TYPE (*arg
);
18856 /* Subroutine of unify_one_argument. PARM is a function parameter of a
18857 template which does contain any deducible template parameters; check if
18858 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
18859 unify_one_argument. */
18862 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
18863 int flags
, bool explain_p
)
18868 type
= TREE_TYPE (arg
);
18872 if (same_type_p (parm
, type
))
18873 return unify_success (explain_p
);
18875 if (strict
== DEDUCE_CONV
)
18877 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
18878 explain_p
? tf_warning_or_error
: tf_none
))
18879 return unify_success (explain_p
);
18881 else if (strict
!= DEDUCE_EXACT
)
18883 if (can_convert_arg (parm
, type
,
18884 TYPE_P (arg
) ? NULL_TREE
: arg
,
18885 flags
, explain_p
? tf_warning_or_error
: tf_none
))
18886 return unify_success (explain_p
);
18889 if (strict
== DEDUCE_EXACT
)
18890 return unify_type_mismatch (explain_p
, parm
, arg
);
18892 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
18895 static bool uses_deducible_template_parms (tree type
);
18897 /* Returns true iff the expression EXPR is one from which a template
18898 argument can be deduced. In other words, if it's an undecorated
18899 use of a template non-type parameter. */
18902 deducible_expression (tree expr
)
18904 /* Strip implicit conversions. */
18905 while (CONVERT_EXPR_P (expr
))
18906 expr
= TREE_OPERAND (expr
, 0);
18907 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
18910 /* Returns true iff the array domain DOMAIN uses a template parameter in a
18911 deducible way; that is, if it has a max value of <PARM> - 1. */
18914 deducible_array_bound (tree domain
)
18916 if (domain
== NULL_TREE
)
18919 tree max
= TYPE_MAX_VALUE (domain
);
18920 if (TREE_CODE (max
) != MINUS_EXPR
)
18923 return deducible_expression (TREE_OPERAND (max
, 0));
18926 /* Returns true iff the template arguments ARGS use a template parameter
18927 in a deducible way. */
18930 deducible_template_args (tree args
)
18932 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
18935 tree elt
= TREE_VEC_ELT (args
, i
);
18936 if (ARGUMENT_PACK_P (elt
))
18937 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
18940 if (PACK_EXPANSION_P (elt
))
18941 elt
= PACK_EXPANSION_PATTERN (elt
);
18942 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
18944 else if (TYPE_P (elt
))
18945 deducible
= uses_deducible_template_parms (elt
);
18947 deducible
= deducible_expression (elt
);
18955 /* Returns true iff TYPE contains any deducible references to template
18956 parameters, as per 14.8.2.5. */
18959 uses_deducible_template_parms (tree type
)
18961 if (PACK_EXPANSION_P (type
))
18962 type
= PACK_EXPANSION_PATTERN (type
);
18969 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
18970 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18976 if (POINTER_TYPE_P (type
))
18977 return uses_deducible_template_parms (TREE_TYPE (type
));
18979 /* T[integer-constant ]
18981 if (TREE_CODE (type
) == ARRAY_TYPE
)
18982 return (uses_deducible_template_parms (TREE_TYPE (type
))
18983 || deducible_array_bound (TYPE_DOMAIN (type
)));
18995 if (TYPE_PTRMEM_P (type
))
18996 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
18997 || (uses_deducible_template_parms
18998 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
19000 /* template-name <T> (where template-name refers to a class template)
19001 template-name <i> (where template-name refers to a class template) */
19002 if (CLASS_TYPE_P (type
)
19003 && CLASSTYPE_TEMPLATE_INFO (type
)
19004 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
19005 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
19006 (CLASSTYPE_TI_ARGS (type
)));
19011 if (TREE_CODE (type
) == FUNCTION_TYPE
19012 || TREE_CODE (type
) == METHOD_TYPE
)
19014 if (uses_deducible_template_parms (TREE_TYPE (type
)))
19016 tree parm
= TYPE_ARG_TYPES (type
);
19017 if (TREE_CODE (type
) == METHOD_TYPE
)
19018 parm
= TREE_CHAIN (parm
);
19019 for (; parm
; parm
= TREE_CHAIN (parm
))
19020 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
19027 /* Subroutine of type_unification_real and unify_pack_expansion to
19028 handle unification of a single P/A pair. Parameters are as
19029 for those functions. */
19032 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
19033 int subr
, unification_kind_t strict
,
19036 tree arg_expr
= NULL_TREE
;
19039 if (arg
== error_mark_node
|| parm
== error_mark_node
)
19040 return unify_invalid (explain_p
);
19041 if (arg
== unknown_type_node
)
19042 /* We can't deduce anything from this, but we might get all the
19043 template args from other function args. */
19044 return unify_success (explain_p
);
19046 /* Implicit conversions (Clause 4) will be performed on a function
19047 argument to convert it to the type of the corresponding function
19048 parameter if the parameter type contains no template-parameters that
19049 participate in template argument deduction. */
19050 if (strict
!= DEDUCE_EXACT
19051 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
19052 /* For function parameters with no deducible template parameters,
19053 just return. We'll check non-dependent conversions later. */
19054 return unify_success (explain_p
);
19059 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
19060 | UNIFY_ALLOW_MORE_CV_QUAL
19061 | UNIFY_ALLOW_DERIVED
);
19065 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
19069 arg_strict
= UNIFY_ALLOW_NONE
;
19073 gcc_unreachable ();
19076 /* We only do these transformations if this is the top-level
19077 parameter_type_list in a call or declaration matching; in other
19078 situations (nested function declarators, template argument lists) we
19079 won't be comparing a type to an expression, and we don't do any type
19085 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
19086 if (type_unknown_p (arg
))
19088 /* [temp.deduct.type] A template-argument can be
19089 deduced from a pointer to function or pointer
19090 to member function argument if the set of
19091 overloaded functions does not contain function
19092 templates and at most one of a set of
19093 overloaded functions provides a unique
19096 if (resolve_overloaded_unification
19097 (tparms
, targs
, parm
, arg
, strict
,
19098 arg_strict
, explain_p
))
19099 return unify_success (explain_p
);
19100 return unify_overload_resolution_failure (explain_p
, arg
);
19104 arg
= unlowered_expr_type (arg
);
19105 if (arg
== error_mark_node
)
19106 return unify_invalid (explain_p
);
19110 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
19113 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
19114 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
19115 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
19117 /* For deduction from an init-list we need the actual list. */
19118 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
19120 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
19123 /* for_each_template_parm callback that always returns 0. */
19126 zero_r (tree
, void *)
19131 /* for_each_template_parm any_fn callback to handle deduction of a template
19132 type argument from the type of an array bound. */
19135 array_deduction_r (tree t
, void *data
)
19137 tree_pair_p d
= (tree_pair_p
)data
;
19138 tree
&tparms
= d
->purpose
;
19139 tree
&targs
= d
->value
;
19141 if (TREE_CODE (t
) == ARRAY_TYPE
)
19142 if (tree dom
= TYPE_DOMAIN (t
))
19143 if (tree max
= TYPE_MAX_VALUE (dom
))
19145 if (TREE_CODE (max
) == MINUS_EXPR
)
19146 max
= TREE_OPERAND (max
, 0);
19147 if (TREE_CODE (max
) == TEMPLATE_PARM_INDEX
)
19148 unify (tparms
, targs
, TREE_TYPE (max
), size_type_node
,
19149 UNIFY_ALLOW_NONE
, /*explain*/false);
19152 /* Keep walking. */
19156 /* Try to deduce any not-yet-deduced template type arguments from the type of
19157 an array bound. This is handled separately from unify because 14.8.2.5 says
19158 "The type of a type parameter is only deduced from an array bound if it is
19159 not otherwise deduced." */
19162 try_array_deduction (tree tparms
, tree targs
, tree parm
)
19164 tree_pair_s data
= { tparms
, targs
};
19165 hash_set
<tree
> visited
;
19166 for_each_template_parm (parm
, zero_r
, &data
, &visited
,
19167 /*nondeduced*/false, array_deduction_r
);
19170 /* Most parms like fn_type_unification.
19172 If SUBR is 1, we're being called recursively (to unify the
19173 arguments of a function or method parameter of a function
19176 CHECKS is a pointer to a vector of access checks encountered while
19177 substituting default template arguments. */
19180 type_unification_real (tree tparms
,
19184 unsigned int xnargs
,
19186 unification_kind_t strict
,
19188 vec
<deferred_access_check
, va_gc
> **checks
,
19193 int ntparms
= TREE_VEC_LENGTH (tparms
);
19194 int saw_undeduced
= 0;
19197 unsigned int nargs
;
19200 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
19201 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
19202 gcc_assert (ntparms
> 0);
19204 tree targs
= INNERMOST_TEMPLATE_ARGS (full_targs
);
19206 /* Reset the number of non-defaulted template arguments contained
19208 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
19216 while (parms
&& parms
!= void_list_node
19219 parm
= TREE_VALUE (parms
);
19221 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
19222 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
19223 /* For a function parameter pack that occurs at the end of the
19224 parameter-declaration-list, the type A of each remaining
19225 argument of the call is compared with the type P of the
19226 declarator-id of the function parameter pack. */
19229 parms
= TREE_CHAIN (parms
);
19231 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
19232 /* For a function parameter pack that does not occur at the
19233 end of the parameter-declaration-list, the type of the
19234 parameter pack is a non-deduced context. */
19240 if (unify_one_argument (tparms
, full_targs
, parm
, arg
, subr
, strict
,
19246 && parms
!= void_list_node
19247 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
19249 /* Unify the remaining arguments with the pack expansion type. */
19251 tree parmvec
= make_tree_vec (1);
19253 /* Allocate a TREE_VEC and copy in all of the arguments */
19254 argvec
= make_tree_vec (nargs
- ia
);
19255 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
19256 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
19258 /* Copy the parameter into parmvec. */
19259 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
19260 if (unify_pack_expansion (tparms
, full_targs
, parmvec
, argvec
, strict
,
19261 /*subr=*/subr
, explain_p
))
19264 /* Advance to the end of the list of parameters. */
19265 parms
= TREE_CHAIN (parms
);
19268 /* Fail if we've reached the end of the parm list, and more args
19269 are present, and the parm list isn't variadic. */
19270 if (ia
< nargs
&& parms
== void_list_node
)
19271 return unify_too_many_arguments (explain_p
, nargs
, ia
);
19272 /* Fail if parms are left and they don't have default values and
19273 they aren't all deduced as empty packs (c++/57397). This is
19274 consistent with sufficient_parms_p. */
19275 if (parms
&& parms
!= void_list_node
19276 && TREE_PURPOSE (parms
) == NULL_TREE
)
19278 unsigned int count
= nargs
;
19283 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
19286 p
= TREE_CHAIN (p
);
19288 while (p
&& p
!= void_list_node
);
19289 if (count
!= nargs
)
19290 return unify_too_few_arguments (explain_p
, ia
, count
,
19296 tsubst_flags_t complain
= (explain_p
19297 ? tf_warning_or_error
19299 bool tried_array_deduction
= (cxx_dialect
< cxx1z
);
19301 for (i
= 0; i
< ntparms
; i
++)
19303 tree targ
= TREE_VEC_ELT (targs
, i
);
19304 tree tparm
= TREE_VEC_ELT (tparms
, i
);
19306 /* Clear the "incomplete" flags on all argument packs now so that
19307 substituting them into later default arguments works. */
19308 if (targ
&& ARGUMENT_PACK_P (targ
))
19310 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
19311 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
19314 if (targ
|| tparm
== error_mark_node
)
19316 tparm
= TREE_VALUE (tparm
);
19318 if (TREE_CODE (tparm
) == TYPE_DECL
19319 && !tried_array_deduction
)
19321 try_array_deduction (tparms
, targs
, xparms
);
19322 tried_array_deduction
= true;
19323 if (TREE_VEC_ELT (targs
, i
))
19327 /* If this is an undeduced nontype parameter that depends on
19328 a type parameter, try another pass; its type may have been
19329 deduced from a later argument than the one from which
19330 this parameter can be deduced. */
19331 if (TREE_CODE (tparm
) == PARM_DECL
19332 && uses_template_parms (TREE_TYPE (tparm
))
19333 && saw_undeduced
< 2)
19339 /* Core issue #226 (C++0x) [temp.deduct]:
19341 If a template argument has not been deduced, its
19342 default template argument, if any, is used.
19344 When we are in C++98 mode, TREE_PURPOSE will either
19345 be NULL_TREE or ERROR_MARK_NODE, so we do not need
19346 to explicitly check cxx_dialect here. */
19347 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
19348 /* OK, there is a default argument. Wait until after the
19349 conversion check to do substitution. */
19352 /* If the type parameter is a parameter pack, then it will
19353 be deduced to an empty parameter pack. */
19354 if (template_parameter_pack_p (tparm
))
19358 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
19360 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
19361 TREE_CONSTANT (arg
) = 1;
19364 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
19366 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
19368 TREE_VEC_ELT (targs
, i
) = arg
;
19372 return unify_parameter_deduction_failure (explain_p
, tparm
);
19375 /* DR 1391: All parameters have args, now check non-dependent parms for
19377 if (saw_undeduced
< 2)
19378 for (ia
= 0, parms
= xparms
, args
= xargs
, nargs
= xnargs
;
19379 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
19381 parm
= TREE_VALUE (parms
);
19383 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
19384 && (!TREE_CHAIN (parms
)
19385 || TREE_CHAIN (parms
) == void_list_node
))
19386 /* For a function parameter pack that occurs at the end of the
19387 parameter-declaration-list, the type A of each remaining
19388 argument of the call is compared with the type P of the
19389 declarator-id of the function parameter pack. */
19392 parms
= TREE_CHAIN (parms
);
19394 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
19395 /* For a function parameter pack that does not occur at the
19396 end of the parameter-declaration-list, the type of the
19397 parameter pack is a non-deduced context. */
19403 if (uses_template_parms (parm
))
19405 if (check_non_deducible_conversion (parm
, arg
, strict
, flags
,
19410 /* Now substitute into the default template arguments. */
19411 for (i
= 0; i
< ntparms
; i
++)
19413 tree targ
= TREE_VEC_ELT (targs
, i
);
19414 tree tparm
= TREE_VEC_ELT (tparms
, i
);
19416 if (targ
|| tparm
== error_mark_node
)
19418 tree parm
= TREE_VALUE (tparm
);
19420 if (TREE_CODE (parm
) == PARM_DECL
19421 && uses_template_parms (TREE_TYPE (parm
))
19422 && saw_undeduced
< 2)
19425 tree arg
= TREE_PURPOSE (tparm
);
19426 reopen_deferring_access_checks (*checks
);
19427 location_t save_loc
= input_location
;
19429 input_location
= DECL_SOURCE_LOCATION (parm
);
19430 arg
= tsubst_template_arg (arg
, full_targs
, complain
, NULL_TREE
);
19431 if (!uses_template_parms (arg
))
19432 arg
= convert_template_argument (parm
, arg
, full_targs
, complain
,
19434 else if (saw_undeduced
< 2)
19437 arg
= error_mark_node
;
19438 input_location
= save_loc
;
19439 *checks
= get_deferred_access_checks ();
19440 pop_deferring_access_checks ();
19441 if (arg
== error_mark_node
)
19445 TREE_VEC_ELT (targs
, i
) = arg
;
19446 /* The position of the first default template argument,
19447 is also the number of non-defaulted arguments in TARGS.
19449 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
19450 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
19454 if (saw_undeduced
++ == 1)
19458 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
19459 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
19461 return unify_success (explain_p
);
19464 /* Subroutine of type_unification_real. Args are like the variables
19465 at the call site. ARG is an overloaded function (or template-id);
19466 we try deducing template args from each of the overloads, and if
19467 only one succeeds, we go with that. Modifies TARGS and returns
19468 true on success. */
19471 resolve_overloaded_unification (tree tparms
,
19475 unification_kind_t strict
,
19479 tree tempargs
= copy_node (targs
);
19481 tree goodfn
= NULL_TREE
;
19484 if (TREE_CODE (arg
) == ADDR_EXPR
)
19486 arg
= TREE_OPERAND (arg
, 0);
19492 if (TREE_CODE (arg
) == COMPONENT_REF
)
19493 /* Handle `&x' where `x' is some static or non-static member
19495 arg
= TREE_OPERAND (arg
, 1);
19497 if (TREE_CODE (arg
) == OFFSET_REF
)
19498 arg
= TREE_OPERAND (arg
, 1);
19500 /* Strip baselink information. */
19501 if (BASELINK_P (arg
))
19502 arg
= BASELINK_FUNCTIONS (arg
);
19504 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
19506 /* If we got some explicit template args, we need to plug them into
19507 the affected templates before we try to unify, in case the
19508 explicit args will completely resolve the templates in question. */
19511 tree expl_subargs
= TREE_OPERAND (arg
, 1);
19512 arg
= TREE_OPERAND (arg
, 0);
19514 for (lkp_iterator
iter (arg
); iter
; ++iter
)
19517 tree subargs
, elem
;
19519 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
19522 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
19523 expl_subargs
, NULL_TREE
, tf_none
,
19524 /*require_all_args=*/true,
19525 /*use_default_args=*/true);
19526 if (subargs
!= error_mark_node
19527 && !any_dependent_template_arguments_p (subargs
))
19529 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
19530 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
19531 elem
, strict
, sub_strict
, addr_p
, explain_p
)
19532 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
19541 /* If no templates (or more than one) are fully resolved by the
19542 explicit arguments, this template-id is a non-deduced context; it
19543 could still be OK if we deduce all template arguments for the
19544 enclosing call through other arguments. */
19548 else if (TREE_CODE (arg
) != OVERLOAD
19549 && TREE_CODE (arg
) != FUNCTION_DECL
)
19550 /* If ARG is, for example, "(0, &f)" then its type will be unknown
19551 -- but the deduction does not succeed because the expression is
19552 not just the function on its own. */
19555 for (lkp_iterator
iter (arg
); iter
; ++iter
)
19558 if (try_one_overload (tparms
, targs
, tempargs
, parm
, TREE_TYPE (fn
),
19559 strict
, sub_strict
, addr_p
, explain_p
)
19560 && (!goodfn
|| !decls_match (goodfn
, fn
)))
19567 /* [temp.deduct.type] A template-argument can be deduced from a pointer
19568 to function or pointer to member function argument if the set of
19569 overloaded functions does not contain function templates and at most
19570 one of a set of overloaded functions provides a unique match.
19572 So if we found multiple possibilities, we return success but don't
19573 deduce anything. */
19577 int i
= TREE_VEC_LENGTH (targs
);
19579 if (TREE_VEC_ELT (tempargs
, i
))
19581 tree old
= TREE_VEC_ELT (targs
, i
);
19582 tree new_
= TREE_VEC_ELT (tempargs
, i
);
19583 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
19584 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
19585 /* Don't forget explicit template arguments in a pack. */
19586 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
19587 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
19588 TREE_VEC_ELT (targs
, i
) = new_
;
19597 /* Core DR 115: In contexts where deduction is done and fails, or in
19598 contexts where deduction is not done, if a template argument list is
19599 specified and it, along with any default template arguments, identifies
19600 a single function template specialization, then the template-id is an
19601 lvalue for the function template specialization. */
19604 resolve_nondeduced_context (tree orig_expr
, tsubst_flags_t complain
)
19606 tree expr
, offset
, baselink
;
19609 if (!type_unknown_p (orig_expr
))
19614 offset
= NULL_TREE
;
19615 baselink
= NULL_TREE
;
19617 if (TREE_CODE (expr
) == ADDR_EXPR
)
19619 expr
= TREE_OPERAND (expr
, 0);
19622 if (TREE_CODE (expr
) == OFFSET_REF
)
19625 expr
= TREE_OPERAND (expr
, 1);
19627 if (BASELINK_P (expr
))
19630 expr
= BASELINK_FUNCTIONS (expr
);
19633 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
19636 tree goodfn
= NULL_TREE
;
19638 /* If we got some explicit template args, we need to plug them into
19639 the affected templates before we try to unify, in case the
19640 explicit args will completely resolve the templates in question. */
19642 tree expl_subargs
= TREE_OPERAND (expr
, 1);
19643 tree arg
= TREE_OPERAND (expr
, 0);
19644 tree badfn
= NULL_TREE
;
19645 tree badargs
= NULL_TREE
;
19647 for (lkp_iterator
iter (arg
); iter
; ++iter
)
19650 tree subargs
, elem
;
19652 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
19655 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
19656 expl_subargs
, NULL_TREE
, tf_none
,
19657 /*require_all_args=*/true,
19658 /*use_default_args=*/true);
19659 if (subargs
!= error_mark_node
19660 && !any_dependent_template_arguments_p (subargs
))
19662 elem
= instantiate_template (fn
, subargs
, tf_none
);
19663 if (elem
== error_mark_node
)
19668 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
19677 mark_used (goodfn
);
19680 expr
= build_baselink (BASELINK_BINFO (baselink
),
19681 BASELINK_ACCESS_BINFO (baselink
),
19682 expr
, BASELINK_OPTYPE (baselink
));
19686 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
19687 expr
= build_offset_ref (base
, expr
, addr
, complain
);
19690 expr
= cp_build_addr_expr (expr
, complain
);
19693 else if (good
== 0 && badargs
&& (complain
& tf_error
))
19694 /* There were no good options and at least one bad one, so let the
19695 user know what the problem is. */
19696 instantiate_template (badfn
, badargs
, complain
);
19701 /* Subroutine of resolve_overloaded_unification; does deduction for a single
19702 overload. Fills TARGS with any deduced arguments, or error_mark_node if
19703 different overloads deduce different arguments for a given parm.
19704 ADDR_P is true if the expression for which deduction is being
19705 performed was of the form "& fn" rather than simply "fn".
19707 Returns 1 on success. */
19710 try_one_overload (tree tparms
,
19715 unification_kind_t strict
,
19724 if (arg
== error_mark_node
)
19727 /* [temp.deduct.type] A template-argument can be deduced from a pointer
19728 to function or pointer to member function argument if the set of
19729 overloaded functions does not contain function templates and at most
19730 one of a set of overloaded functions provides a unique match.
19732 So if this is a template, just return success. */
19734 if (uses_template_parms (arg
))
19737 if (TREE_CODE (arg
) == METHOD_TYPE
)
19738 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
19740 arg
= build_pointer_type (arg
);
19742 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
19744 /* We don't copy orig_targs for this because if we have already deduced
19745 some template args from previous args, unify would complain when we
19746 try to deduce a template parameter for the same argument, even though
19747 there isn't really a conflict. */
19748 nargs
= TREE_VEC_LENGTH (targs
);
19749 tempargs
= make_tree_vec (nargs
);
19751 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
19754 /* First make sure we didn't deduce anything that conflicts with
19755 explicitly specified args. */
19756 for (i
= nargs
; i
--; )
19758 tree elt
= TREE_VEC_ELT (tempargs
, i
);
19759 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
19763 else if (uses_template_parms (elt
))
19764 /* Since we're unifying against ourselves, we will fill in
19765 template args used in the function parm list with our own
19766 template parms. Discard them. */
19767 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
19768 else if (oldelt
&& ARGUMENT_PACK_P (oldelt
))
19770 /* Check that the argument at each index of the deduced argument pack
19771 is equivalent to the corresponding explicitly specified argument.
19772 We may have deduced more arguments than were explicitly specified,
19775 /* We used to assert ARGUMENT_PACK_INCOMPLETE_P (oldelt) here, but
19776 that's wrong if we deduce the same argument pack from multiple
19777 function arguments: it's only incomplete the first time. */
19779 tree explicit_pack
= ARGUMENT_PACK_ARGS (oldelt
);
19780 tree deduced_pack
= ARGUMENT_PACK_ARGS (elt
);
19782 if (TREE_VEC_LENGTH (deduced_pack
)
19783 < TREE_VEC_LENGTH (explicit_pack
))
19786 for (int j
= 0; j
< TREE_VEC_LENGTH (explicit_pack
); j
++)
19787 if (!template_args_equal (TREE_VEC_ELT (explicit_pack
, j
),
19788 TREE_VEC_ELT (deduced_pack
, j
)))
19791 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
19795 for (i
= nargs
; i
--; )
19797 tree elt
= TREE_VEC_ELT (tempargs
, i
);
19800 TREE_VEC_ELT (targs
, i
) = elt
;
19806 /* PARM is a template class (perhaps with unbound template
19807 parameters). ARG is a fully instantiated type. If ARG can be
19808 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
19809 TARGS are as for unify. */
19812 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
19815 tree copy_of_targs
;
19817 if (!CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
19819 else if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
19820 /* Matches anything. */;
19821 else if (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
19822 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
)))
19825 /* We need to make a new template argument vector for the call to
19826 unify. If we used TARGS, we'd clutter it up with the result of
19827 the attempted unification, even if this class didn't work out.
19828 We also don't want to commit ourselves to all the unifications
19829 we've already done, since unification is supposed to be done on
19830 an argument-by-argument basis. In other words, consider the
19831 following pathological case:
19833 template <int I, int J, int K>
19836 template <int I, int J>
19837 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
19839 template <int I, int J, int K>
19840 void f(S<I, J, K>, S<I, I, I>);
19849 Now, by the time we consider the unification involving `s2', we
19850 already know that we must have `f<0, 0, 0>'. But, even though
19851 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
19852 because there are two ways to unify base classes of S<0, 1, 2>
19853 with S<I, I, I>. If we kept the already deduced knowledge, we
19854 would reject the possibility I=1. */
19855 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
19857 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
19859 if (unify_bound_ttp_args (tparms
, copy_of_targs
, parm
, arg
, explain_p
))
19864 /* If unification failed, we're done. */
19865 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
19866 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
19872 /* Given a template type PARM and a class type ARG, find the unique
19873 base type in ARG that is an instance of PARM. We do not examine
19874 ARG itself; only its base-classes. If there is not exactly one
19875 appropriate base class, return NULL_TREE. PARM may be the type of
19876 a partial specialization, as well as a plain template type. Used
19879 static enum template_base_result
19880 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
19881 bool explain_p
, tree
*result
)
19883 tree rval
= NULL_TREE
;
19886 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
19888 binfo
= TYPE_BINFO (complete_type (arg
));
19891 /* The type could not be completed. */
19892 *result
= NULL_TREE
;
19893 return tbr_incomplete_type
;
19896 /* Walk in inheritance graph order. The search order is not
19897 important, and this avoids multiple walks of virtual bases. */
19898 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
19900 tree r
= try_class_unification (tparms
, targs
, parm
,
19901 BINFO_TYPE (binfo
), explain_p
);
19905 /* If there is more than one satisfactory baseclass, then:
19909 If they yield more than one possible deduced A, the type
19913 if (rval
&& !same_type_p (r
, rval
))
19915 *result
= NULL_TREE
;
19916 return tbr_ambiguous_baseclass
;
19924 return tbr_success
;
19927 /* Returns the level of DECL, which declares a template parameter. */
19930 template_decl_level (tree decl
)
19932 switch (TREE_CODE (decl
))
19935 case TEMPLATE_DECL
:
19936 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
19939 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
19942 gcc_unreachable ();
19947 /* Decide whether ARG can be unified with PARM, considering only the
19948 cv-qualifiers of each type, given STRICT as documented for unify.
19949 Returns nonzero iff the unification is OK on that basis. */
19952 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
19954 int arg_quals
= cp_type_quals (arg
);
19955 int parm_quals
= cp_type_quals (parm
);
19957 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
19958 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
19960 /* Although a CVR qualifier is ignored when being applied to a
19961 substituted template parameter ([8.3.2]/1 for example), that
19962 does not allow us to unify "const T" with "int&" because both
19963 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
19964 It is ok when we're allowing additional CV qualifiers
19965 at the outer level [14.8.2.1]/3,1st bullet. */
19966 if ((TREE_CODE (arg
) == REFERENCE_TYPE
19967 || TREE_CODE (arg
) == FUNCTION_TYPE
19968 || TREE_CODE (arg
) == METHOD_TYPE
)
19969 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
19972 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
19973 && (parm_quals
& TYPE_QUAL_RESTRICT
))
19977 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
19978 && (arg_quals
& parm_quals
) != parm_quals
)
19981 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
19982 && (parm_quals
& arg_quals
) != arg_quals
)
19988 /* Determines the LEVEL and INDEX for the template parameter PARM. */
19990 template_parm_level_and_index (tree parm
, int* level
, int* index
)
19992 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
19993 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
19994 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
19996 *index
= TEMPLATE_TYPE_IDX (parm
);
19997 *level
= TEMPLATE_TYPE_LEVEL (parm
);
20001 *index
= TEMPLATE_PARM_IDX (parm
);
20002 *level
= TEMPLATE_PARM_LEVEL (parm
);
20006 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
20008 if (unify (TP, TA, P, A, S, EP)) \
20012 /* Unifies the remaining arguments in PACKED_ARGS with the pack
20013 expansion at the end of PACKED_PARMS. Returns 0 if the type
20014 deduction succeeds, 1 otherwise. STRICT is the same as in
20015 fn_type_unification. CALL_ARGS_P is true iff PACKED_ARGS is actually a
20016 function call argument list. We'll need to adjust the arguments to make them
20017 types. SUBR tells us if this is from a recursive call to
20018 type_unification_real, or for comparing two template argument
20022 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
20023 tree packed_args
, unification_kind_t strict
,
20024 bool subr
, bool explain_p
)
20027 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
20028 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
20029 tree pack
, packs
= NULL_TREE
;
20030 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
20032 /* Add in any args remembered from an earlier partial instantiation. */
20033 targs
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (parm
), targs
);
20035 packed_args
= expand_template_argument_pack (packed_args
);
20037 int len
= TREE_VEC_LENGTH (packed_args
);
20039 /* Determine the parameter packs we will be deducing from the
20040 pattern, and record their current deductions. */
20041 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
20042 pack
; pack
= TREE_CHAIN (pack
))
20044 tree parm_pack
= TREE_VALUE (pack
);
20047 /* Determine the index and level of this parameter pack. */
20048 template_parm_level_and_index (parm_pack
, &level
, &idx
);
20050 /* Keep track of the parameter packs and their corresponding
20052 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
20053 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
20056 /* Loop through all of the arguments that have not yet been
20057 unified and unify each with the pattern. */
20058 for (i
= start
; i
< len
; i
++)
20061 bool any_explicit
= false;
20062 tree arg
= TREE_VEC_ELT (packed_args
, i
);
20064 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
20065 or the element of its argument pack at the current index if
20066 this argument was explicitly specified. */
20067 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
20071 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
20074 if (TREE_VALUE (pack
)
20075 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
20076 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
20078 any_explicit
= true;
20079 arg
= TREE_VEC_ELT (pargs
, i
- start
);
20081 TMPL_ARG (targs
, level
, idx
) = arg
;
20084 /* If we had explicit template arguments, substitute them into the
20085 pattern before deduction. */
20088 /* Some arguments might still be unspecified or dependent. */
20090 ++processing_template_decl
;
20091 dependent
= any_dependent_template_arguments_p (targs
);
20093 --processing_template_decl
;
20094 parm
= tsubst (pattern
, targs
,
20095 explain_p
? tf_warning_or_error
: tf_none
,
20098 --processing_template_decl
;
20099 if (parm
== error_mark_node
)
20105 /* Unify the pattern with the current argument. */
20106 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
20110 /* For each parameter pack, collect the deduced value. */
20111 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
20114 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
20116 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
20117 TMPL_ARG (targs
, level
, idx
);
20121 /* Verify that the results of unification with the parameter packs
20122 produce results consistent with what we've seen before, and make
20123 the deduced argument packs available. */
20124 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
20126 tree old_pack
= TREE_VALUE (pack
);
20127 tree new_args
= TREE_TYPE (pack
);
20128 int i
, len
= TREE_VEC_LENGTH (new_args
);
20130 bool nondeduced_p
= false;
20132 /* By default keep the original deduced argument pack.
20133 If necessary, more specific code is going to update the
20134 resulting deduced argument later down in this function. */
20135 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
20136 TMPL_ARG (targs
, level
, idx
) = old_pack
;
20138 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
20139 actually deduce anything. */
20140 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
20141 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
20142 nondeduced_p
= true;
20146 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
20148 /* If we had fewer function args than explicit template args,
20149 just use the explicits. */
20150 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
20151 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
20152 if (len
< explicit_len
)
20153 new_args
= explicit_args
;
20159 /* Build the deduced *_ARGUMENT_PACK. */
20160 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
20162 result
= make_node (NONTYPE_ARGUMENT_PACK
);
20163 TREE_CONSTANT (result
) = 1;
20166 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
20168 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
20170 /* Note the deduced argument packs for this parameter
20172 TMPL_ARG (targs
, level
, idx
) = result
;
20174 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
20175 && (ARGUMENT_PACK_ARGS (old_pack
)
20176 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
20178 /* We only had the explicitly-provided arguments before, but
20179 now we have a complete set of arguments. */
20180 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
20182 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
20183 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
20184 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
20188 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
20189 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
20191 if (!comp_template_args (old_args
, new_args
,
20192 &bad_old_arg
, &bad_new_arg
))
20193 /* Inconsistent unification of this parameter pack. */
20194 return unify_parameter_pack_inconsistent (explain_p
,
20200 return unify_success (explain_p
);
20203 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
20204 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
20205 parameters and return value are as for unify. */
20208 unify_array_domain (tree tparms
, tree targs
,
20209 tree parm_dom
, tree arg_dom
,
20217 /* Our representation of array types uses "N - 1" as the
20218 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
20219 not an integer constant. We cannot unify arbitrarily
20220 complex expressions, so we eliminate the MINUS_EXPRs
20222 parm_max
= TYPE_MAX_VALUE (parm_dom
);
20223 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
20226 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
20227 parm_max
= TREE_OPERAND (parm_max
, 0);
20229 arg_max
= TYPE_MAX_VALUE (arg_dom
);
20230 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
20233 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
20234 trying to unify the type of a variable with the type
20235 of a template parameter. For example:
20237 template <unsigned int N>
20238 void f (char (&) [N]);
20245 Here, the type of the ARG will be "int [g(i)]", and
20246 may be a SAVE_EXPR, etc. */
20247 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
20248 return unify_vla_arg (explain_p
, arg_dom
);
20249 arg_max
= TREE_OPERAND (arg_max
, 0);
20252 /* If only one of the bounds used a MINUS_EXPR, compensate
20253 by adding one to the other bound. */
20254 if (parm_cst
&& !arg_cst
)
20255 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
20259 else if (arg_cst
&& !parm_cst
)
20260 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
20265 return unify (tparms
, targs
, parm_max
, arg_max
,
20266 UNIFY_ALLOW_INTEGER
, explain_p
);
20269 /* Returns whether T, a P or A in unify, is a type, template or expression. */
20271 enum pa_kind_t
{ pa_type
, pa_tmpl
, pa_expr
};
20276 if (PACK_EXPANSION_P (t
))
20277 t
= PACK_EXPANSION_PATTERN (t
);
20278 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
20279 || TREE_CODE (t
) == UNBOUND_CLASS_TEMPLATE
20280 || DECL_TYPE_TEMPLATE_P (t
))
20282 else if (TYPE_P (t
))
20288 /* Deduce the value of template parameters. TPARMS is the (innermost)
20289 set of template parameters to a template. TARGS is the bindings
20290 for those template parameters, as determined thus far; TARGS may
20291 include template arguments for outer levels of template parameters
20292 as well. PARM is a parameter to a template function, or a
20293 subcomponent of that parameter; ARG is the corresponding argument.
20294 This function attempts to match PARM with ARG in a manner
20295 consistent with the existing assignments in TARGS. If more values
20296 are deduced, then TARGS is updated.
20298 Returns 0 if the type deduction succeeds, 1 otherwise. The
20299 parameter STRICT is a bitwise or of the following flags:
20302 Require an exact match between PARM and ARG.
20303 UNIFY_ALLOW_MORE_CV_QUAL:
20304 Allow the deduced ARG to be more cv-qualified (by qualification
20305 conversion) than ARG.
20306 UNIFY_ALLOW_LESS_CV_QUAL:
20307 Allow the deduced ARG to be less cv-qualified than ARG.
20308 UNIFY_ALLOW_DERIVED:
20309 Allow the deduced ARG to be a template base class of ARG,
20310 or a pointer to a template base class of the type pointed to by
20312 UNIFY_ALLOW_INTEGER:
20313 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
20314 case for more information.
20315 UNIFY_ALLOW_OUTER_LEVEL:
20316 This is the outermost level of a deduction. Used to determine validity
20317 of qualification conversions. A valid qualification conversion must
20318 have const qualified pointers leading up to the inner type which
20319 requires additional CV quals, except at the outer level, where const
20320 is not required [conv.qual]. It would be normal to set this flag in
20321 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
20322 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
20323 This is the outermost level of a deduction, and PARM can be more CV
20324 qualified at this point.
20325 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
20326 This is the outermost level of a deduction, and PARM can be less CV
20327 qualified at this point. */
20330 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
20336 int strict_in
= strict
;
20337 tsubst_flags_t complain
= (explain_p
20338 ? tf_warning_or_error
20341 /* I don't think this will do the right thing with respect to types.
20342 But the only case I've seen it in so far has been array bounds, where
20343 signedness is the only information lost, and I think that will be
20345 while (CONVERT_EXPR_P (parm
))
20346 parm
= TREE_OPERAND (parm
, 0);
20348 if (arg
== error_mark_node
)
20349 return unify_invalid (explain_p
);
20350 if (arg
== unknown_type_node
20351 || arg
== init_list_type_node
)
20352 /* We can't deduce anything from this, but we might get all the
20353 template args from other function args. */
20354 return unify_success (explain_p
);
20356 if (parm
== any_targ_node
|| arg
== any_targ_node
)
20357 return unify_success (explain_p
);
20359 /* If PARM uses template parameters, then we can't bail out here,
20360 even if ARG == PARM, since we won't record unifications for the
20361 template parameters. We might need them if we're trying to
20362 figure out which of two things is more specialized. */
20363 if (arg
== parm
&& !uses_template_parms (parm
))
20364 return unify_success (explain_p
);
20366 /* Handle init lists early, so the rest of the function can assume
20367 we're dealing with a type. */
20368 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
20372 tree orig_parm
= parm
;
20374 /* Replace T with std::initializer_list<T> for deduction. */
20375 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
20376 && flag_deduce_init_list
)
20377 parm
= listify (parm
);
20379 if (!is_std_init_list (parm
)
20380 && TREE_CODE (parm
) != ARRAY_TYPE
)
20381 /* We can only deduce from an initializer list argument if the
20382 parameter is std::initializer_list or an array; otherwise this
20383 is a non-deduced context. */
20384 return unify_success (explain_p
);
20386 if (TREE_CODE (parm
) == ARRAY_TYPE
)
20387 elttype
= TREE_TYPE (parm
);
20390 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
20391 /* Deduction is defined in terms of a single type, so just punt
20392 on the (bizarre) std::initializer_list<T...>. */
20393 if (PACK_EXPANSION_P (elttype
))
20394 return unify_success (explain_p
);
20397 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
20399 int elt_strict
= strict
;
20401 if (elt
== error_mark_node
)
20402 return unify_invalid (explain_p
);
20404 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
20406 tree type
= TREE_TYPE (elt
);
20407 if (type
== error_mark_node
)
20408 return unify_invalid (explain_p
);
20409 /* It should only be possible to get here for a call. */
20410 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
20411 elt_strict
|= maybe_adjust_types_for_deduction
20412 (DEDUCE_CALL
, &elttype
, &type
, elt
);
20416 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
20420 if (TREE_CODE (parm
) == ARRAY_TYPE
20421 && deducible_array_bound (TYPE_DOMAIN (parm
)))
20423 /* Also deduce from the length of the initializer list. */
20424 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
20425 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
20426 if (idx
== error_mark_node
)
20427 return unify_invalid (explain_p
);
20428 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
20432 /* If the std::initializer_list<T> deduction worked, replace the
20433 deduced A with std::initializer_list<A>. */
20434 if (orig_parm
!= parm
)
20436 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
20437 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
20438 targ
= listify (targ
);
20439 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
20441 return unify_success (explain_p
);
20444 /* If parm and arg aren't the same kind of thing (template, type, or
20445 expression), fail early. */
20446 if (pa_kind (parm
) != pa_kind (arg
))
20447 return unify_invalid (explain_p
);
20449 /* Immediately reject some pairs that won't unify because of
20450 cv-qualification mismatches. */
20451 if (TREE_CODE (arg
) == TREE_CODE (parm
)
20453 /* It is the elements of the array which hold the cv quals of an array
20454 type, and the elements might be template type parms. We'll check
20455 when we recurse. */
20456 && TREE_CODE (arg
) != ARRAY_TYPE
20457 /* We check the cv-qualifiers when unifying with template type
20458 parameters below. We want to allow ARG `const T' to unify with
20459 PARM `T' for example, when computing which of two templates
20460 is more specialized, for example. */
20461 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
20462 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
20463 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
20465 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
20466 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
20467 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
20468 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
20469 strict
&= ~UNIFY_ALLOW_DERIVED
;
20470 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
20471 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
20473 switch (TREE_CODE (parm
))
20475 case TYPENAME_TYPE
:
20477 case UNBOUND_CLASS_TEMPLATE
:
20478 /* In a type which contains a nested-name-specifier, template
20479 argument values cannot be deduced for template parameters used
20480 within the nested-name-specifier. */
20481 return unify_success (explain_p
);
20483 case TEMPLATE_TYPE_PARM
:
20484 case TEMPLATE_TEMPLATE_PARM
:
20485 case BOUND_TEMPLATE_TEMPLATE_PARM
:
20486 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
20487 if (error_operand_p (tparm
))
20488 return unify_invalid (explain_p
);
20490 if (TEMPLATE_TYPE_LEVEL (parm
)
20491 != template_decl_level (tparm
))
20492 /* The PARM is not one we're trying to unify. Just check
20493 to see if it matches ARG. */
20495 if (TREE_CODE (arg
) == TREE_CODE (parm
)
20496 && (is_auto (parm
) ? is_auto (arg
)
20497 : same_type_p (parm
, arg
)))
20498 return unify_success (explain_p
);
20500 return unify_type_mismatch (explain_p
, parm
, arg
);
20502 idx
= TEMPLATE_TYPE_IDX (parm
);
20503 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
20504 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
20505 if (error_operand_p (tparm
))
20506 return unify_invalid (explain_p
);
20508 /* Check for mixed types and values. */
20509 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
20510 && TREE_CODE (tparm
) != TYPE_DECL
)
20511 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
20512 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
20513 gcc_unreachable ();
20515 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20517 if ((strict_in
& UNIFY_ALLOW_DERIVED
)
20518 && CLASS_TYPE_P (arg
))
20520 /* First try to match ARG directly. */
20521 tree t
= try_class_unification (tparms
, targs
, parm
, arg
,
20525 /* Otherwise, look for a suitable base of ARG, as below. */
20526 enum template_base_result r
;
20527 r
= get_template_base (tparms
, targs
, parm
, arg
,
20530 return unify_no_common_base (explain_p
, r
, parm
, arg
);
20534 /* ARG must be constructed from a template class or a template
20535 template parameter. */
20536 else if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
20537 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
20538 return unify_template_deduction_failure (explain_p
, parm
, arg
);
20540 /* Deduce arguments T, i from TT<T> or TT<i>. */
20541 if (unify_bound_ttp_args (tparms
, targs
, parm
, arg
, explain_p
))
20544 arg
= TYPE_TI_TEMPLATE (arg
);
20546 /* Fall through to deduce template name. */
20549 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
20550 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20552 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
20554 /* Simple cases: Value already set, does match or doesn't. */
20555 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
20556 return unify_success (explain_p
);
20558 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
20562 /* If PARM is `const T' and ARG is only `int', we don't have
20563 a match unless we are allowing additional qualification.
20564 If ARG is `const int' and PARM is just `T' that's OK;
20565 that binds `const int' to `T'. */
20566 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
20568 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
20570 /* Consider the case where ARG is `const volatile int' and
20571 PARM is `const T'. Then, T should be `volatile int'. */
20572 arg
= cp_build_qualified_type_real
20573 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
20574 if (arg
== error_mark_node
)
20575 return unify_invalid (explain_p
);
20577 /* Simple cases: Value already set, does match or doesn't. */
20578 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
20579 return unify_success (explain_p
);
20581 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
20583 /* Make sure that ARG is not a variable-sized array. (Note
20584 that were talking about variable-sized arrays (like
20585 `int[n]'), rather than arrays of unknown size (like
20586 `int[]').) We'll get very confused by such a type since
20587 the bound of the array is not constant, and therefore
20588 not mangleable. Besides, such types are not allowed in
20589 ISO C++, so we can do as we please here. We do allow
20590 them for 'auto' deduction, since that isn't ABI-exposed. */
20591 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
20592 return unify_vla_arg (explain_p
, arg
);
20594 /* Strip typedefs as in convert_template_argument. */
20595 arg
= canonicalize_type_argument (arg
, tf_none
);
20598 /* If ARG is a parameter pack or an expansion, we cannot unify
20599 against it unless PARM is also a parameter pack. */
20600 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
20601 && !template_parameter_pack_p (parm
))
20602 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
20604 /* If the argument deduction results is a METHOD_TYPE,
20605 then there is a problem.
20606 METHOD_TYPE doesn't map to any real C++ type the result of
20607 the deduction can not be of that type. */
20608 if (TREE_CODE (arg
) == METHOD_TYPE
)
20609 return unify_method_type_error (explain_p
, arg
);
20611 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
20612 return unify_success (explain_p
);
20614 case TEMPLATE_PARM_INDEX
:
20615 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
20616 if (error_operand_p (tparm
))
20617 return unify_invalid (explain_p
);
20619 if (TEMPLATE_PARM_LEVEL (parm
)
20620 != template_decl_level (tparm
))
20622 /* The PARM is not one we're trying to unify. Just check
20623 to see if it matches ARG. */
20624 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
20625 && cp_tree_equal (parm
, arg
));
20627 unify_expression_unequal (explain_p
, parm
, arg
);
20631 idx
= TEMPLATE_PARM_IDX (parm
);
20632 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
20636 int x
= !cp_tree_equal (targ
, arg
);
20638 unify_inconsistency (explain_p
, parm
, targ
, arg
);
20642 /* [temp.deduct.type] If, in the declaration of a function template
20643 with a non-type template-parameter, the non-type
20644 template-parameter is used in an expression in the function
20645 parameter-list and, if the corresponding template-argument is
20646 deduced, the template-argument type shall match the type of the
20647 template-parameter exactly, except that a template-argument
20648 deduced from an array bound may be of any integral type.
20649 The non-type parameter might use already deduced type parameters. */
20650 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
20651 if (tree a
= type_uses_auto (tparm
))
20653 tparm
= do_auto_deduction (tparm
, arg
, a
, complain
, adc_unify
);
20654 if (tparm
== error_mark_node
)
20658 if (!TREE_TYPE (arg
))
20659 /* Template-parameter dependent expression. Just accept it for now.
20660 It will later be processed in convert_template_argument. */
20662 else if (same_type_p (non_reference (TREE_TYPE (arg
)),
20663 non_reference (tparm
)))
20665 else if ((strict
& UNIFY_ALLOW_INTEGER
)
20666 && CP_INTEGRAL_TYPE_P (tparm
))
20667 /* Convert the ARG to the type of PARM; the deduced non-type
20668 template argument must exactly match the types of the
20669 corresponding parameter. */
20670 arg
= fold (build_nop (tparm
, arg
));
20671 else if (uses_template_parms (tparm
))
20673 /* We haven't deduced the type of this parameter yet. */
20674 if (cxx_dialect
>= cxx1z
20675 /* We deduce from array bounds in try_array_deduction. */
20676 && !(strict
& UNIFY_ALLOW_INTEGER
))
20678 /* Deduce it from the non-type argument. */
20679 tree atype
= TREE_TYPE (arg
);
20680 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
20682 UNIFY_ALLOW_NONE
, explain_p
);
20685 /* Try again later. */
20686 return unify_success (explain_p
);
20689 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
20691 /* If ARG is a parameter pack or an expansion, we cannot unify
20692 against it unless PARM is also a parameter pack. */
20693 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
20694 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
20695 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
20698 bool removed_attr
= false;
20699 arg
= strip_typedefs_expr (arg
, &removed_attr
);
20701 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
20702 return unify_success (explain_p
);
20706 /* A pointer-to-member constant can be unified only with
20707 another constant. */
20708 if (TREE_CODE (arg
) != PTRMEM_CST
)
20709 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
20711 /* Just unify the class member. It would be useless (and possibly
20712 wrong, depending on the strict flags) to unify also
20713 PTRMEM_CST_CLASS, because we want to be sure that both parm and
20714 arg refer to the same variable, even if through different
20715 classes. For instance:
20717 struct A { int x; };
20720 Unification of &A::x and &B::x must succeed. */
20721 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
20722 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
20727 if (!TYPE_PTR_P (arg
))
20728 return unify_type_mismatch (explain_p
, parm
, arg
);
20730 /* [temp.deduct.call]
20732 A can be another pointer or pointer to member type that can
20733 be converted to the deduced A via a qualification
20734 conversion (_conv.qual_).
20736 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
20737 This will allow for additional cv-qualification of the
20738 pointed-to types if appropriate. */
20740 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
20741 /* The derived-to-base conversion only persists through one
20742 level of pointers. */
20743 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
20745 return unify (tparms
, targs
, TREE_TYPE (parm
),
20746 TREE_TYPE (arg
), strict
, explain_p
);
20749 case REFERENCE_TYPE
:
20750 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
20751 return unify_type_mismatch (explain_p
, parm
, arg
);
20752 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
20753 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
20756 if (TREE_CODE (arg
) != ARRAY_TYPE
)
20757 return unify_type_mismatch (explain_p
, parm
, arg
);
20758 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
20759 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
20760 return unify_type_mismatch (explain_p
, parm
, arg
);
20761 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
20762 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
20763 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
20764 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
20765 TYPE_DOMAIN (arg
), explain_p
);
20766 return unify_success (explain_p
);
20773 case ENUMERAL_TYPE
:
20776 if (TREE_CODE (arg
) != TREE_CODE (parm
))
20777 return unify_type_mismatch (explain_p
, parm
, arg
);
20779 /* We have already checked cv-qualification at the top of the
20781 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
20782 return unify_type_mismatch (explain_p
, parm
, arg
);
20784 /* As far as unification is concerned, this wins. Later checks
20785 will invalidate it if necessary. */
20786 return unify_success (explain_p
);
20788 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
20789 /* Type INTEGER_CST can come from ordinary constant template args. */
20791 while (CONVERT_EXPR_P (arg
))
20792 arg
= TREE_OPERAND (arg
, 0);
20794 if (TREE_CODE (arg
) != INTEGER_CST
)
20795 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
20796 return (tree_int_cst_equal (parm
, arg
)
20797 ? unify_success (explain_p
)
20798 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
20802 int i
, len
, argslen
;
20803 int parm_variadic_p
= 0;
20805 if (TREE_CODE (arg
) != TREE_VEC
)
20806 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
20808 len
= TREE_VEC_LENGTH (parm
);
20809 argslen
= TREE_VEC_LENGTH (arg
);
20811 /* Check for pack expansions in the parameters. */
20812 for (i
= 0; i
< len
; ++i
)
20814 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
20817 /* We can unify against something with a trailing
20819 parm_variadic_p
= 1;
20821 /* [temp.deduct.type]/9: If the template argument list of
20822 P contains a pack expansion that is not the last
20823 template argument, the entire template argument list
20824 is a non-deduced context. */
20825 return unify_success (explain_p
);
20829 /* If we don't have enough arguments to satisfy the parameters
20830 (not counting the pack expression at the end), or we have
20831 too many arguments for a parameter list that doesn't end in
20832 a pack expression, we can't unify. */
20833 if (parm_variadic_p
20834 ? argslen
< len
- parm_variadic_p
20836 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
20838 /* Unify all of the parameters that precede the (optional)
20839 pack expression. */
20840 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
20842 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
20843 TREE_VEC_ELT (parm
, i
),
20844 TREE_VEC_ELT (arg
, i
),
20845 UNIFY_ALLOW_NONE
, explain_p
);
20847 if (parm_variadic_p
)
20848 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
20850 /*subr=*/true, explain_p
);
20851 return unify_success (explain_p
);
20856 if (TREE_CODE (arg
) != TREE_CODE (parm
))
20857 return unify_type_mismatch (explain_p
, parm
, arg
);
20859 if (TYPE_PTRMEMFUNC_P (parm
))
20861 if (!TYPE_PTRMEMFUNC_P (arg
))
20862 return unify_type_mismatch (explain_p
, parm
, arg
);
20864 return unify (tparms
, targs
,
20865 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
20866 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
20867 strict
, explain_p
);
20869 else if (TYPE_PTRMEMFUNC_P (arg
))
20870 return unify_type_mismatch (explain_p
, parm
, arg
);
20872 if (CLASSTYPE_TEMPLATE_INFO (parm
))
20874 tree t
= NULL_TREE
;
20876 if (strict_in
& UNIFY_ALLOW_DERIVED
)
20878 /* First, we try to unify the PARM and ARG directly. */
20879 t
= try_class_unification (tparms
, targs
,
20880 parm
, arg
, explain_p
);
20884 /* Fallback to the special case allowed in
20885 [temp.deduct.call]:
20887 If P is a class, and P has the form
20888 template-id, then A can be a derived class of
20889 the deduced A. Likewise, if P is a pointer to
20890 a class of the form template-id, A can be a
20891 pointer to a derived class pointed to by the
20893 enum template_base_result r
;
20894 r
= get_template_base (tparms
, targs
, parm
, arg
,
20899 /* Don't give the derived diagnostic if we're
20900 already dealing with the same template. */
20902 = (CLASSTYPE_TEMPLATE_INFO (arg
)
20903 && (CLASSTYPE_TI_TEMPLATE (parm
)
20904 == CLASSTYPE_TI_TEMPLATE (arg
)));
20905 return unify_no_common_base (explain_p
&& !same_template
,
20910 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
20911 && (CLASSTYPE_TI_TEMPLATE (parm
)
20912 == CLASSTYPE_TI_TEMPLATE (arg
)))
20913 /* Perhaps PARM is something like S<U> and ARG is S<int>.
20914 Then, we should unify `int' and `U'. */
20917 /* There's no chance of unification succeeding. */
20918 return unify_type_mismatch (explain_p
, parm
, arg
);
20920 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
20921 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
20923 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
20924 return unify_type_mismatch (explain_p
, parm
, arg
);
20925 return unify_success (explain_p
);
20928 case FUNCTION_TYPE
:
20930 unsigned int nargs
;
20935 if (TREE_CODE (arg
) != TREE_CODE (parm
))
20936 return unify_type_mismatch (explain_p
, parm
, arg
);
20938 /* CV qualifications for methods can never be deduced, they must
20939 match exactly. We need to check them explicitly here,
20940 because type_unification_real treats them as any other
20941 cv-qualified parameter. */
20942 if (TREE_CODE (parm
) == METHOD_TYPE
20943 && (!check_cv_quals_for_unify
20945 class_of_this_parm (arg
),
20946 class_of_this_parm (parm
))))
20947 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
20948 if (TREE_CODE (arg
) == FUNCTION_TYPE
20949 && type_memfn_quals (parm
) != type_memfn_quals (arg
))
20950 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
20951 if (type_memfn_rqual (parm
) != type_memfn_rqual (arg
))
20952 return unify_type_mismatch (explain_p
, parm
, arg
);
20954 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
20955 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
20957 nargs
= list_length (TYPE_ARG_TYPES (arg
));
20958 args
= XALLOCAVEC (tree
, nargs
);
20959 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
20960 a
!= NULL_TREE
&& a
!= void_list_node
;
20961 a
= TREE_CHAIN (a
), ++i
)
20962 args
[i
] = TREE_VALUE (a
);
20965 if (type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
20966 args
, nargs
, 1, DEDUCE_EXACT
,
20967 LOOKUP_NORMAL
, NULL
, explain_p
))
20970 if (flag_noexcept_type
)
20972 tree pspec
= TYPE_RAISES_EXCEPTIONS (parm
);
20973 tree aspec
= canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (arg
));
20974 if (pspec
== NULL_TREE
) pspec
= noexcept_false_spec
;
20975 if (aspec
== NULL_TREE
) aspec
= noexcept_false_spec
;
20976 if (TREE_PURPOSE (pspec
) && TREE_PURPOSE (aspec
)
20977 && uses_template_parms (TREE_PURPOSE (pspec
)))
20978 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_PURPOSE (pspec
),
20979 TREE_PURPOSE (aspec
),
20980 UNIFY_ALLOW_NONE
, explain_p
);
20981 else if (nothrow_spec_p (pspec
) && !nothrow_spec_p (aspec
))
20982 return unify_type_mismatch (explain_p
, parm
, arg
);
20989 /* Unify a pointer to member with a pointer to member function, which
20990 deduces the type of the member as a function type. */
20991 if (TYPE_PTRMEMFUNC_P (arg
))
20993 /* Check top-level cv qualifiers */
20994 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
20995 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
20997 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
20998 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
20999 UNIFY_ALLOW_NONE
, explain_p
);
21001 /* Determine the type of the function we are unifying against. */
21002 tree fntype
= static_fn_type (arg
);
21004 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
21007 if (TREE_CODE (arg
) != OFFSET_TYPE
)
21008 return unify_type_mismatch (explain_p
, parm
, arg
);
21009 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
21010 TYPE_OFFSET_BASETYPE (arg
),
21011 UNIFY_ALLOW_NONE
, explain_p
);
21012 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
21013 strict
, explain_p
);
21016 if (DECL_TEMPLATE_PARM_P (parm
))
21017 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
21018 if (arg
!= scalar_constant_value (parm
))
21019 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
21020 return unify_success (explain_p
);
21023 case TEMPLATE_DECL
:
21024 /* Matched cases are handled by the ARG == PARM test above. */
21025 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
21028 /* We might get a variable as a non-type template argument in parm if the
21029 corresponding parameter is type-dependent. Make any necessary
21030 adjustments based on whether arg is a reference. */
21031 if (CONSTANT_CLASS_P (arg
))
21032 parm
= fold_non_dependent_expr (parm
);
21033 else if (REFERENCE_REF_P (arg
))
21035 tree sub
= TREE_OPERAND (arg
, 0);
21037 if (TREE_CODE (sub
) == ADDR_EXPR
)
21038 arg
= TREE_OPERAND (sub
, 0);
21040 /* Now use the normal expression code to check whether they match. */
21043 case TYPE_ARGUMENT_PACK
:
21044 case NONTYPE_ARGUMENT_PACK
:
21045 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
21046 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
21049 case DECLTYPE_TYPE
:
21050 case UNDERLYING_TYPE
:
21051 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
21052 or UNDERLYING_TYPE nodes. */
21053 return unify_success (explain_p
);
21056 /* Unification fails if we hit an error node. */
21057 return unify_invalid (explain_p
);
21060 if (REFERENCE_REF_P (parm
))
21062 bool pexp
= PACK_EXPANSION_P (arg
);
21064 arg
= PACK_EXPANSION_PATTERN (arg
);
21065 if (REFERENCE_REF_P (arg
))
21066 arg
= TREE_OPERAND (arg
, 0);
21068 arg
= make_pack_expansion (arg
);
21069 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
21070 strict
, explain_p
);
21075 /* An unresolved overload is a nondeduced context. */
21076 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
21077 return unify_success (explain_p
);
21078 gcc_assert (EXPR_P (parm
) || TREE_CODE (parm
) == TRAIT_EXPR
);
21080 /* We must be looking at an expression. This can happen with
21084 void foo(S<I>, S<I + 2>);
21086 This is a "nondeduced context":
21090 The nondeduced contexts are:
21092 --A type that is a template-id in which one or more of
21093 the template-arguments is an expression that references
21094 a template-parameter.
21096 In these cases, we assume deduction succeeded, but don't
21097 actually infer any unifications. */
21099 if (!uses_template_parms (parm
)
21100 && !template_args_equal (parm
, arg
))
21101 return unify_expression_unequal (explain_p
, parm
, arg
);
21103 return unify_success (explain_p
);
21106 #undef RECUR_AND_CHECK_FAILURE
21108 /* Note that DECL can be defined in this translation unit, if
21112 mark_definable (tree decl
)
21115 DECL_NOT_REALLY_EXTERN (decl
) = 1;
21116 FOR_EACH_CLONE (clone
, decl
)
21117 DECL_NOT_REALLY_EXTERN (clone
) = 1;
21120 /* Called if RESULT is explicitly instantiated, or is a member of an
21121 explicitly instantiated class. */
21124 mark_decl_instantiated (tree result
, int extern_p
)
21126 SET_DECL_EXPLICIT_INSTANTIATION (result
);
21128 /* If this entity has already been written out, it's too late to
21129 make any modifications. */
21130 if (TREE_ASM_WRITTEN (result
))
21133 /* For anonymous namespace we don't need to do anything. */
21134 if (decl_anon_ns_mem_p (result
))
21136 gcc_assert (!TREE_PUBLIC (result
));
21140 if (TREE_CODE (result
) != FUNCTION_DECL
)
21141 /* The TREE_PUBLIC flag for function declarations will have been
21142 set correctly by tsubst. */
21143 TREE_PUBLIC (result
) = 1;
21145 /* This might have been set by an earlier implicit instantiation. */
21146 DECL_COMDAT (result
) = 0;
21149 DECL_NOT_REALLY_EXTERN (result
) = 0;
21152 mark_definable (result
);
21153 mark_needed (result
);
21154 /* Always make artificials weak. */
21155 if (DECL_ARTIFICIAL (result
) && flag_weak
)
21156 comdat_linkage (result
);
21157 /* For WIN32 we also want to put explicit instantiations in
21158 linkonce sections. */
21159 else if (TREE_PUBLIC (result
))
21160 maybe_make_one_only (result
);
21163 /* If EXTERN_P, then this function will not be emitted -- unless
21164 followed by an explicit instantiation, at which point its linkage
21165 will be adjusted. If !EXTERN_P, then this function will be
21166 emitted here. In neither circumstance do we want
21167 import_export_decl to adjust the linkage. */
21168 DECL_INTERFACE_KNOWN (result
) = 1;
21171 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
21172 important template arguments. If any are missing, we check whether
21173 they're important by using error_mark_node for substituting into any
21174 args that were used for partial ordering (the ones between ARGS and END)
21175 and seeing if it bubbles up. */
21178 check_undeduced_parms (tree targs
, tree args
, tree end
)
21180 bool found
= false;
21182 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
21183 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
21186 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
21190 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
21191 if (substed
== error_mark_node
)
21197 /* Given two function templates PAT1 and PAT2, return:
21199 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
21200 -1 if PAT2 is more specialized than PAT1.
21201 0 if neither is more specialized.
21203 LEN indicates the number of parameters we should consider
21204 (defaulted parameters should not be considered).
21206 The 1998 std underspecified function template partial ordering, and
21207 DR214 addresses the issue. We take pairs of arguments, one from
21208 each of the templates, and deduce them against each other. One of
21209 the templates will be more specialized if all the *other*
21210 template's arguments deduce against its arguments and at least one
21211 of its arguments *does* *not* deduce against the other template's
21212 corresponding argument. Deduction is done as for class templates.
21213 The arguments used in deduction have reference and top level cv
21214 qualifiers removed. Iff both arguments were originally reference
21215 types *and* deduction succeeds in both directions, an lvalue reference
21216 wins against an rvalue reference and otherwise the template
21217 with the more cv-qualified argument wins for that pairing (if
21218 neither is more cv-qualified, they both are equal). Unlike regular
21219 deduction, after all the arguments have been deduced in this way,
21220 we do *not* verify the deduced template argument values can be
21221 substituted into non-deduced contexts.
21223 The logic can be a bit confusing here, because we look at deduce1 and
21224 targs1 to see if pat2 is at least as specialized, and vice versa; if we
21225 can find template arguments for pat1 to make arg1 look like arg2, that
21226 means that arg2 is at least as specialized as arg1. */
21229 more_specialized_fn (tree pat1
, tree pat2
, int len
)
21231 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
21232 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
21233 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
21234 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
21235 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
21236 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
21237 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
21238 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
21239 tree origs1
, origs2
;
21240 bool lose1
= false;
21241 bool lose2
= false;
21243 /* Remove the this parameter from non-static member functions. If
21244 one is a non-static member function and the other is not a static
21245 member function, remove the first parameter from that function
21246 also. This situation occurs for operator functions where we
21247 locate both a member function (with this pointer) and non-member
21248 operator (with explicit first operand). */
21249 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
21251 len
--; /* LEN is the number of significant arguments for DECL1 */
21252 args1
= TREE_CHAIN (args1
);
21253 if (!DECL_STATIC_FUNCTION_P (decl2
))
21254 args2
= TREE_CHAIN (args2
);
21256 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
21258 args2
= TREE_CHAIN (args2
);
21259 if (!DECL_STATIC_FUNCTION_P (decl1
))
21262 args1
= TREE_CHAIN (args1
);
21266 /* If only one is a conversion operator, they are unordered. */
21267 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
21270 /* Consider the return type for a conversion function */
21271 if (DECL_CONV_FN_P (decl1
))
21273 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
21274 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
21278 processing_template_decl
++;
21284 /* Stop when an ellipsis is seen. */
21285 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
21287 tree arg1
= TREE_VALUE (args1
);
21288 tree arg2
= TREE_VALUE (args2
);
21289 int deduce1
, deduce2
;
21295 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
21296 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
21298 /* When both arguments are pack expansions, we need only
21299 unify the patterns themselves. */
21300 arg1
= PACK_EXPANSION_PATTERN (arg1
);
21301 arg2
= PACK_EXPANSION_PATTERN (arg2
);
21303 /* This is the last comparison we need to do. */
21307 /* DR 1847: If a particular P contains no template-parameters that
21308 participate in template argument deduction, that P is not used to
21309 determine the ordering. */
21310 if (!uses_deducible_template_parms (arg1
)
21311 && !uses_deducible_template_parms (arg2
))
21314 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
21316 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
21317 arg1
= TREE_TYPE (arg1
);
21318 quals1
= cp_type_quals (arg1
);
21321 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
21323 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
21324 arg2
= TREE_TYPE (arg2
);
21325 quals2
= cp_type_quals (arg2
);
21328 arg1
= TYPE_MAIN_VARIANT (arg1
);
21329 arg2
= TYPE_MAIN_VARIANT (arg2
);
21331 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
21333 int i
, len2
= remaining_arguments (args2
);
21334 tree parmvec
= make_tree_vec (1);
21335 tree argvec
= make_tree_vec (len2
);
21338 /* Setup the parameter vector, which contains only ARG1. */
21339 TREE_VEC_ELT (parmvec
, 0) = arg1
;
21341 /* Setup the argument vector, which contains the remaining
21343 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
21344 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
21346 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
21347 argvec
, DEDUCE_EXACT
,
21348 /*subr=*/true, /*explain_p=*/false)
21351 /* We cannot deduce in the other direction, because ARG1 is
21352 a pack expansion but ARG2 is not. */
21355 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
21357 int i
, len1
= remaining_arguments (args1
);
21358 tree parmvec
= make_tree_vec (1);
21359 tree argvec
= make_tree_vec (len1
);
21362 /* Setup the parameter vector, which contains only ARG1. */
21363 TREE_VEC_ELT (parmvec
, 0) = arg2
;
21365 /* Setup the argument vector, which contains the remaining
21367 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
21368 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
21370 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
21371 argvec
, DEDUCE_EXACT
,
21372 /*subr=*/true, /*explain_p=*/false)
21375 /* We cannot deduce in the other direction, because ARG2 is
21376 a pack expansion but ARG1 is not.*/
21382 /* The normal case, where neither argument is a pack
21384 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
21385 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
21387 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
21388 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
21392 /* If we couldn't deduce arguments for tparms1 to make arg1 match
21393 arg2, then arg2 is not as specialized as arg1. */
21399 /* "If, for a given type, deduction succeeds in both directions
21400 (i.e., the types are identical after the transformations above)
21401 and both P and A were reference types (before being replaced with
21402 the type referred to above):
21403 - if the type from the argument template was an lvalue reference and
21404 the type from the parameter template was not, the argument type is
21405 considered to be more specialized than the other; otherwise,
21406 - if the type from the argument template is more cv-qualified
21407 than the type from the parameter template (as described above),
21408 the argument type is considered to be more specialized than the other;
21410 - neither type is more specialized than the other." */
21412 if (deduce1
&& deduce2
)
21414 if (ref1
&& ref2
&& ref1
!= ref2
)
21421 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
21423 if ((quals1
& quals2
) == quals2
)
21425 if ((quals1
& quals2
) == quals1
)
21430 if (lose1
&& lose2
)
21431 /* We've failed to deduce something in either direction.
21432 These must be unordered. */
21437 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
21438 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
21439 /* We have already processed all of the arguments in our
21440 handing of the pack expansion type. */
21443 args1
= TREE_CHAIN (args1
);
21444 args2
= TREE_CHAIN (args2
);
21447 /* "In most cases, all template parameters must have values in order for
21448 deduction to succeed, but for partial ordering purposes a template
21449 parameter may remain without a value provided it is not used in the
21450 types being used for partial ordering."
21452 Thus, if we are missing any of the targs1 we need to substitute into
21453 origs1, then pat2 is not as specialized as pat1. This can happen when
21454 there is a nondeduced context. */
21455 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
21457 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
21460 processing_template_decl
--;
21462 /* If both deductions succeed, the partial ordering selects the more
21463 constrained template. */
21464 if (!lose1
&& !lose2
)
21466 tree c1
= get_constraints (DECL_TEMPLATE_RESULT (pat1
));
21467 tree c2
= get_constraints (DECL_TEMPLATE_RESULT (pat2
));
21468 lose1
= !subsumes_constraints (c1
, c2
);
21469 lose2
= !subsumes_constraints (c2
, c1
);
21472 /* All things being equal, if the next argument is a pack expansion
21473 for one function but not for the other, prefer the
21474 non-variadic function. FIXME this is bogus; see c++/41958. */
21476 && args1
&& TREE_VALUE (args1
)
21477 && args2
&& TREE_VALUE (args2
))
21479 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
21480 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
21483 if (lose1
== lose2
)
21491 /* Determine which of two partial specializations of TMPL is more
21494 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
21495 to the first partial specialization. The TREE_PURPOSE is the
21496 innermost set of template parameters for the partial
21497 specialization. PAT2 is similar, but for the second template.
21499 Return 1 if the first partial specialization is more specialized;
21500 -1 if the second is more specialized; 0 if neither is more
21503 See [temp.class.order] for information about determining which of
21504 two templates is more specialized. */
21507 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
21511 bool any_deductions
= false;
21513 tree tmpl1
= TREE_VALUE (pat1
);
21514 tree tmpl2
= TREE_VALUE (pat2
);
21515 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
21516 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
21518 /* Just like what happens for functions, if we are ordering between
21519 different template specializations, we may encounter dependent
21520 types in the arguments, and we need our dependency check functions
21521 to behave correctly. */
21522 ++processing_template_decl
;
21523 targs
= get_partial_spec_bindings (tmpl
, tmpl1
, specargs2
);
21527 any_deductions
= true;
21530 targs
= get_partial_spec_bindings (tmpl
, tmpl2
, specargs1
);
21534 any_deductions
= true;
21536 --processing_template_decl
;
21538 /* If both deductions succeed, the partial ordering selects the more
21539 constrained template. */
21540 if (!winner
&& any_deductions
)
21541 return more_constrained (tmpl1
, tmpl2
);
21543 /* In the case of a tie where at least one of the templates
21544 has a parameter pack at the end, the template with the most
21545 non-packed parameters wins. */
21548 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
21549 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
21551 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
21552 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
21553 int len1
= TREE_VEC_LENGTH (args1
);
21554 int len2
= TREE_VEC_LENGTH (args2
);
21556 /* We don't count the pack expansion at the end. */
21557 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
21559 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
21564 else if (len1
< len2
)
21571 /* Return the template arguments that will produce the function signature
21572 DECL from the function template FN, with the explicit template
21573 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
21574 also match. Return NULL_TREE if no satisfactory arguments could be
21578 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
21580 int ntparms
= DECL_NTPARMS (fn
);
21581 tree targs
= make_tree_vec (ntparms
);
21582 tree decl_type
= TREE_TYPE (decl
);
21583 tree decl_arg_types
;
21585 unsigned int nargs
, ix
;
21588 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
21590 /* Never do unification on the 'this' parameter. */
21591 decl_arg_types
= skip_artificial_parms_for (decl
,
21592 TYPE_ARG_TYPES (decl_type
));
21594 nargs
= list_length (decl_arg_types
);
21595 args
= XALLOCAVEC (tree
, nargs
);
21596 for (arg
= decl_arg_types
, ix
= 0;
21597 arg
!= NULL_TREE
&& arg
!= void_list_node
;
21598 arg
= TREE_CHAIN (arg
), ++ix
)
21599 args
[ix
] = TREE_VALUE (arg
);
21601 if (fn_type_unification (fn
, explicit_args
, targs
,
21603 (check_rettype
|| DECL_CONV_FN_P (fn
)
21604 ? TREE_TYPE (decl_type
) : NULL_TREE
),
21605 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
21607 == error_mark_node
)
21613 /* Return the innermost template arguments that, when applied to a partial
21614 specialization SPEC_TMPL of TMPL, yield the ARGS.
21616 For example, suppose we have:
21618 template <class T, class U> struct S {};
21619 template <class T> struct S<T*, int> {};
21621 Then, suppose we want to get `S<double*, int>'. SPEC_TMPL will be the
21622 partial specialization and the ARGS will be {double*, int}. The resulting
21623 vector will be {double}, indicating that `T' is bound to `double'. */
21626 get_partial_spec_bindings (tree tmpl
, tree spec_tmpl
, tree args
)
21628 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
21630 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (spec_tmpl
)));
21631 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
21633 tree innermost_deduced_args
;
21635 innermost_deduced_args
= make_tree_vec (ntparms
);
21636 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
21638 deduced_args
= copy_node (args
);
21639 SET_TMPL_ARGS_LEVEL (deduced_args
,
21640 TMPL_ARGS_DEPTH (deduced_args
),
21641 innermost_deduced_args
);
21644 deduced_args
= innermost_deduced_args
;
21646 bool tried_array_deduction
= (cxx_dialect
< cxx1z
);
21648 if (unify (tparms
, deduced_args
,
21649 INNERMOST_TEMPLATE_ARGS (spec_args
),
21650 INNERMOST_TEMPLATE_ARGS (args
),
21651 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
21654 for (i
= 0; i
< ntparms
; ++i
)
21655 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
21657 if (!tried_array_deduction
)
21659 try_array_deduction (tparms
, innermost_deduced_args
,
21660 INNERMOST_TEMPLATE_ARGS (spec_args
));
21661 tried_array_deduction
= true;
21662 if (TREE_VEC_ELT (innermost_deduced_args
, i
))
21668 tree tinst
= build_tree_list (spec_tmpl
, deduced_args
);
21669 if (!push_tinst_level (tinst
))
21671 excessive_deduction_depth
= true;
21675 /* Verify that nondeduced template arguments agree with the type
21676 obtained from argument deduction.
21680 struct A { typedef int X; };
21681 template <class T, class U> struct C {};
21682 template <class T> struct C<T, typename T::X> {};
21684 Then with the instantiation `C<A, int>', we can deduce that
21685 `T' is `A' but unify () does not check whether `typename T::X'
21687 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
21689 if (spec_args
!= error_mark_node
)
21690 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
21691 INNERMOST_TEMPLATE_ARGS (spec_args
),
21692 tmpl
, tf_none
, false, false);
21694 pop_tinst_level ();
21696 if (spec_args
== error_mark_node
21697 /* We only need to check the innermost arguments; the other
21698 arguments will always agree. */
21699 || !comp_template_args_porder (INNERMOST_TEMPLATE_ARGS (spec_args
),
21700 INNERMOST_TEMPLATE_ARGS (args
)))
21703 /* Now that we have bindings for all of the template arguments,
21704 ensure that the arguments deduced for the template template
21705 parameters have compatible template parameter lists. See the use
21706 of template_template_parm_bindings_ok_p in fn_type_unification
21707 for more information. */
21708 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
21711 return deduced_args
;
21714 // Compare two function templates T1 and T2 by deducing bindings
21715 // from one against the other. If both deductions succeed, compare
21716 // constraints to see which is more constrained.
21718 more_specialized_inst (tree t1
, tree t2
)
21723 if (get_bindings (t1
, DECL_TEMPLATE_RESULT (t2
), NULL_TREE
, true))
21729 if (get_bindings (t2
, DECL_TEMPLATE_RESULT (t1
), NULL_TREE
, true))
21735 // If both deductions succeed, then one may be more constrained.
21736 if (count
== 2 && fate
== 0)
21737 fate
= more_constrained (t1
, t2
);
21742 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
21743 Return the TREE_LIST node with the most specialized template, if
21744 any. If there is no most specialized template, the error_mark_node
21747 Note that this function does not look at, or modify, the
21748 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
21749 returned is one of the elements of INSTANTIATIONS, callers may
21750 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
21751 and retrieve it from the value returned. */
21754 most_specialized_instantiation (tree templates
)
21758 ++processing_template_decl
;
21761 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
21763 gcc_assert (TREE_VALUE (champ
) != TREE_VALUE (fn
));
21764 int fate
= more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
));
21769 /* Equally specialized, move to next function. If there
21770 is no next function, nothing's most specialized. */
21771 fn
= TREE_CHAIN (fn
);
21779 /* Now verify that champ is better than everything earlier in the
21780 instantiation list. */
21781 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
)) {
21782 if (more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
)) != 1)
21789 processing_template_decl
--;
21792 return error_mark_node
;
21797 /* If DECL is a specialization of some template, return the most
21798 general such template. Otherwise, returns NULL_TREE.
21800 For example, given:
21802 template <class T> struct S { template <class U> void f(U); };
21804 if TMPL is `template <class U> void S<int>::f(U)' this will return
21805 the full template. This function will not trace past partial
21806 specializations, however. For example, given in addition:
21808 template <class T> struct S<T*> { template <class U> void f(U); };
21810 if TMPL is `template <class U> void S<int*>::f(U)' this will return
21811 `template <class T> template <class U> S<T*>::f(U)'. */
21814 most_general_template (tree decl
)
21816 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
21818 if (tree tinfo
= get_template_info (decl
))
21819 decl
= TI_TEMPLATE (tinfo
);
21820 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
21821 template friend, or a FIELD_DECL for a capture pack. */
21822 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
21826 /* Look for more and more general templates. */
21827 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
21829 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
21830 (See cp-tree.h for details.) */
21831 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
21834 if (CLASS_TYPE_P (TREE_TYPE (decl
))
21835 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
21836 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
21839 /* Stop if we run into an explicitly specialized class template. */
21840 if (!DECL_NAMESPACE_SCOPE_P (decl
)
21841 && DECL_CONTEXT (decl
)
21842 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
21845 decl
= DECL_TI_TEMPLATE (decl
);
21851 /* Return the most specialized of the template partial specializations
21852 which can produce TARGET, a specialization of some class or variable
21853 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
21854 a TEMPLATE_DECL node corresponding to the partial specialization, while
21855 the TREE_PURPOSE is the set of template arguments that must be
21856 substituted into the template pattern in order to generate TARGET.
21858 If the choice of partial specialization is ambiguous, a diagnostic
21859 is issued, and the error_mark_node is returned. If there are no
21860 partial specializations matching TARGET, then NULL_TREE is
21861 returned, indicating that the primary template should be used. */
21864 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
21866 tree list
= NULL_TREE
;
21871 tree outer_args
= NULL_TREE
;
21874 if (TYPE_P (target
))
21876 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
21877 tmpl
= TI_TEMPLATE (tinfo
);
21878 args
= TI_ARGS (tinfo
);
21880 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
21882 tmpl
= TREE_OPERAND (target
, 0);
21883 args
= TREE_OPERAND (target
, 1);
21885 else if (VAR_P (target
))
21887 tree tinfo
= DECL_TEMPLATE_INFO (target
);
21888 tmpl
= TI_TEMPLATE (tinfo
);
21889 args
= TI_ARGS (tinfo
);
21892 gcc_unreachable ();
21894 tree main_tmpl
= most_general_template (tmpl
);
21896 /* For determining which partial specialization to use, only the
21897 innermost args are interesting. */
21898 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
21900 outer_args
= strip_innermost_template_args (args
, 1);
21901 args
= INNERMOST_TEMPLATE_ARGS (args
);
21904 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
21907 tree spec_tmpl
= TREE_VALUE (t
);
21911 /* Substitute in the template args from the enclosing class. */
21912 ++processing_template_decl
;
21913 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
21914 --processing_template_decl
;
21917 if (spec_tmpl
== error_mark_node
)
21918 return error_mark_node
;
21920 spec_args
= get_partial_spec_bindings (tmpl
, spec_tmpl
, args
);
21924 spec_args
= add_to_template_args (outer_args
, spec_args
);
21926 /* Keep the candidate only if the constraints are satisfied,
21927 or if we're not compiling with concepts. */
21929 || constraints_satisfied_p (spec_tmpl
, spec_args
))
21931 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
21932 TREE_TYPE (list
) = TREE_TYPE (t
);
21940 ambiguous_p
= false;
21943 t
= TREE_CHAIN (t
);
21944 for (; t
; t
= TREE_CHAIN (t
))
21946 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
21953 t
= TREE_CHAIN (t
);
21956 ambiguous_p
= true;
21965 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
21967 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
21970 ambiguous_p
= true;
21978 char *spaces
= NULL
;
21979 if (!(complain
& tf_error
))
21980 return error_mark_node
;
21981 if (TYPE_P (target
))
21982 error ("ambiguous template instantiation for %q#T", target
);
21984 error ("ambiguous template instantiation for %q#D", target
);
21985 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
21986 for (t
= list
; t
; t
= TREE_CHAIN (t
))
21988 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
21989 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
21990 "%s %#qS", spaces
? spaces
: str
, subst
);
21991 spaces
= spaces
? spaces
: get_spaces (str
);
21994 return error_mark_node
;
22000 /* Explicitly instantiate DECL. */
22003 do_decl_instantiation (tree decl
, tree storage
)
22005 tree result
= NULL_TREE
;
22008 if (!decl
|| decl
== error_mark_node
)
22009 /* An error occurred, for which grokdeclarator has already issued
22010 an appropriate message. */
22012 else if (! DECL_LANG_SPECIFIC (decl
))
22014 error ("explicit instantiation of non-template %q#D", decl
);
22018 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
22019 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
22021 if (VAR_P (decl
) && !var_templ
)
22023 /* There is an asymmetry here in the way VAR_DECLs and
22024 FUNCTION_DECLs are handled by grokdeclarator. In the case of
22025 the latter, the DECL we get back will be marked as a
22026 template instantiation, and the appropriate
22027 DECL_TEMPLATE_INFO will be set up. This does not happen for
22028 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
22029 should handle VAR_DECLs as it currently handles
22031 if (!DECL_CLASS_SCOPE_P (decl
))
22033 error ("%qD is not a static data member of a class template", decl
);
22036 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
22037 if (!result
|| !VAR_P (result
))
22039 error ("no matching template for %qD found", decl
);
22042 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
22044 error ("type %qT for explicit instantiation %qD does not match "
22045 "declared type %qT", TREE_TYPE (result
), decl
,
22050 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
22052 error ("explicit instantiation of %q#D", decl
);
22058 /* Check for various error cases. Note that if the explicit
22059 instantiation is valid the RESULT will currently be marked as an
22060 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
22061 until we get here. */
22063 if (DECL_TEMPLATE_SPECIALIZATION (result
))
22065 /* DR 259 [temp.spec].
22067 Both an explicit instantiation and a declaration of an explicit
22068 specialization shall not appear in a program unless the explicit
22069 instantiation follows a declaration of the explicit specialization.
22071 For a given set of template parameters, if an explicit
22072 instantiation of a template appears after a declaration of an
22073 explicit specialization for that template, the explicit
22074 instantiation has no effect. */
22077 else if (DECL_EXPLICIT_INSTANTIATION (result
))
22081 No program shall explicitly instantiate any template more
22084 We check DECL_NOT_REALLY_EXTERN so as not to complain when
22085 the first instantiation was `extern' and the second is not,
22086 and EXTERN_P for the opposite case. */
22087 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
22088 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
22089 /* If an "extern" explicit instantiation follows an ordinary
22090 explicit instantiation, the template is instantiated. */
22094 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
22096 error ("no matching template for %qD found", result
);
22099 else if (!DECL_TEMPLATE_INFO (result
))
22101 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
22105 if (storage
== NULL_TREE
)
22107 else if (storage
== ridpointers
[(int) RID_EXTERN
])
22109 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
22110 pedwarn (input_location
, OPT_Wpedantic
,
22111 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
22116 error ("storage class %qD applied to template instantiation", storage
);
22118 check_explicit_instantiation_namespace (result
);
22119 mark_decl_instantiated (result
, extern_p
);
22121 instantiate_decl (result
, /*defer_ok=*/true,
22122 /*expl_inst_class_mem_p=*/false);
22126 mark_class_instantiated (tree t
, int extern_p
)
22128 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
22129 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
22130 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
22131 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
22134 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
22135 rest_of_type_compilation (t
, 1);
22139 /* Called from do_type_instantiation through binding_table_foreach to
22140 do recursive instantiation for the type bound in ENTRY. */
22142 bt_instantiate_type_proc (binding_entry entry
, void *data
)
22144 tree storage
= *(tree
*) data
;
22146 if (MAYBE_CLASS_TYPE_P (entry
->type
)
22147 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
22148 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
22151 /* Perform an explicit instantiation of template class T. STORAGE, if
22152 non-null, is the RID for extern, inline or static. COMPLAIN is
22153 nonzero if this is called from the parser, zero if called recursively,
22154 since the standard is unclear (as detailed below). */
22157 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
22162 int previous_instantiation_extern_p
= 0;
22164 if (TREE_CODE (t
) == TYPE_DECL
)
22167 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
22170 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
22172 error ("explicit instantiation of non-class template %qD", tmpl
);
22174 error ("explicit instantiation of non-template type %qT", t
);
22180 if (!COMPLETE_TYPE_P (t
))
22182 if (complain
& tf_error
)
22183 error ("explicit instantiation of %q#T before definition of template",
22188 if (storage
!= NULL_TREE
)
22190 if (!in_system_header_at (input_location
))
22192 if (storage
== ridpointers
[(int) RID_EXTERN
])
22194 if (cxx_dialect
== cxx98
)
22195 pedwarn (input_location
, OPT_Wpedantic
,
22196 "ISO C++ 1998 forbids the use of %<extern%> on "
22197 "explicit instantiations");
22200 pedwarn (input_location
, OPT_Wpedantic
,
22201 "ISO C++ forbids the use of %qE"
22202 " on explicit instantiations", storage
);
22205 if (storage
== ridpointers
[(int) RID_INLINE
])
22207 else if (storage
== ridpointers
[(int) RID_EXTERN
])
22209 else if (storage
== ridpointers
[(int) RID_STATIC
])
22213 error ("storage class %qD applied to template instantiation",
22219 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
22221 /* DR 259 [temp.spec].
22223 Both an explicit instantiation and a declaration of an explicit
22224 specialization shall not appear in a program unless the explicit
22225 instantiation follows a declaration of the explicit specialization.
22227 For a given set of template parameters, if an explicit
22228 instantiation of a template appears after a declaration of an
22229 explicit specialization for that template, the explicit
22230 instantiation has no effect. */
22233 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
22237 No program shall explicitly instantiate any template more
22240 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
22241 instantiation was `extern'. If EXTERN_P then the second is.
22242 These cases are OK. */
22243 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
22245 if (!previous_instantiation_extern_p
&& !extern_p
22246 && (complain
& tf_error
))
22247 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
22249 /* If we've already instantiated the template, just return now. */
22250 if (!CLASSTYPE_INTERFACE_ONLY (t
))
22254 check_explicit_instantiation_namespace (TYPE_NAME (t
));
22255 mark_class_instantiated (t
, extern_p
);
22260 /* In contrast to implicit instantiation, where only the
22261 declarations, and not the definitions, of members are
22262 instantiated, we have here:
22266 The explicit instantiation of a class template specialization
22267 implies the instantiation of all of its members not
22268 previously explicitly specialized in the translation unit
22269 containing the explicit instantiation.
22271 Of course, we can't instantiate member template classes, since we
22272 don't have any arguments for them. Note that the standard is
22273 unclear on whether the instantiation of the members are
22274 *explicit* instantiations or not. However, the most natural
22275 interpretation is that it should be an explicit
22277 for (tree fld
= TYPE_FIELDS (t
); fld
; fld
= DECL_CHAIN (fld
))
22279 || (TREE_CODE (fld
) == FUNCTION_DECL
22281 && user_provided_p (fld
)))
22282 && DECL_TEMPLATE_INSTANTIATION (fld
))
22284 mark_decl_instantiated (fld
, extern_p
);
22286 instantiate_decl (fld
, /*defer_ok=*/true,
22287 /*expl_inst_class_mem_p=*/true);
22290 if (CLASSTYPE_NESTED_UTDS (t
))
22291 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
22292 bt_instantiate_type_proc
, &storage
);
22295 /* Given a function DECL, which is a specialization of TMPL, modify
22296 DECL to be a re-instantiation of TMPL with the same template
22297 arguments. TMPL should be the template into which tsubst'ing
22298 should occur for DECL, not the most general template.
22300 One reason for doing this is a scenario like this:
22303 void f(const T&, int i);
22305 void g() { f(3, 7); }
22308 void f(const T& t, const int i) { }
22310 Note that when the template is first instantiated, with
22311 instantiate_template, the resulting DECL will have no name for the
22312 first parameter, and the wrong type for the second. So, when we go
22313 to instantiate the DECL, we regenerate it. */
22316 regenerate_decl_from_template (tree decl
, tree tmpl
, tree args
)
22318 /* The arguments used to instantiate DECL, from the most general
22322 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
22324 /* Make sure that we can see identifiers, and compute access
22326 push_access_scope (decl
);
22328 if (TREE_CODE (decl
) == FUNCTION_DECL
)
22336 args_depth
= TMPL_ARGS_DEPTH (args
);
22337 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
22338 if (args_depth
> parms_depth
)
22339 args
= get_innermost_template_args (args
, parms_depth
);
22341 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
22342 args
, tf_error
, NULL_TREE
,
22343 /*defer_ok*/false);
22344 if (specs
&& specs
!= error_mark_node
)
22345 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
22348 /* Merge parameter declarations. */
22349 decl_parm
= skip_artificial_parms_for (decl
,
22350 DECL_ARGUMENTS (decl
));
22352 = skip_artificial_parms_for (code_pattern
,
22353 DECL_ARGUMENTS (code_pattern
));
22354 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
22359 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
22360 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
22361 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
22363 parm_type
= type_decays_to (parm_type
);
22364 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
22365 TREE_TYPE (decl_parm
) = parm_type
;
22366 attributes
= DECL_ATTRIBUTES (pattern_parm
);
22367 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
22369 DECL_ATTRIBUTES (decl_parm
) = attributes
;
22370 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
22372 decl_parm
= DECL_CHAIN (decl_parm
);
22373 pattern_parm
= DECL_CHAIN (pattern_parm
);
22375 /* Merge any parameters that match with the function parameter
22377 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
22380 tree expanded_types
;
22381 /* Expand the TYPE_PACK_EXPANSION that provides the types for
22382 the parameters in this function parameter pack. */
22383 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
22384 args
, tf_error
, NULL_TREE
);
22385 len
= TREE_VEC_LENGTH (expanded_types
);
22386 for (i
= 0; i
< len
; i
++)
22391 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
22392 /* Rename the parameter to include the index. */
22393 DECL_NAME (decl_parm
) =
22394 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
22395 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
22396 parm_type
= type_decays_to (parm_type
);
22397 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
22398 TREE_TYPE (decl_parm
) = parm_type
;
22399 attributes
= DECL_ATTRIBUTES (pattern_parm
);
22400 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
22402 DECL_ATTRIBUTES (decl_parm
) = attributes
;
22403 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
22405 decl_parm
= DECL_CHAIN (decl_parm
);
22408 /* Merge additional specifiers from the CODE_PATTERN. */
22409 if (DECL_DECLARED_INLINE_P (code_pattern
)
22410 && !DECL_DECLARED_INLINE_P (decl
))
22411 DECL_DECLARED_INLINE_P (decl
) = 1;
22413 else if (VAR_P (decl
))
22415 DECL_INITIAL (decl
) =
22416 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
22417 tf_error
, DECL_TI_TEMPLATE (decl
),
22418 /*integral_constant_expression_p=*/false);
22419 if (VAR_HAD_UNKNOWN_BOUND (decl
))
22420 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
22421 tf_error
, DECL_TI_TEMPLATE (decl
));
22424 gcc_unreachable ();
22426 pop_access_scope (decl
);
22429 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
22430 substituted to get DECL. */
22433 template_for_substitution (tree decl
)
22435 tree tmpl
= DECL_TI_TEMPLATE (decl
);
22437 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
22438 for the instantiation. This is not always the most general
22439 template. Consider, for example:
22442 struct S { template <class U> void f();
22443 template <> void f<int>(); };
22445 and an instantiation of S<double>::f<int>. We want TD to be the
22446 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
22447 while (/* An instantiation cannot have a definition, so we need a
22448 more general template. */
22449 DECL_TEMPLATE_INSTANTIATION (tmpl
)
22450 /* We must also deal with friend templates. Given:
22452 template <class T> struct S {
22453 template <class U> friend void f() {};
22456 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
22457 so far as the language is concerned, but that's still
22458 where we get the pattern for the instantiation from. On
22459 other hand, if the definition comes outside the class, say:
22461 template <class T> struct S {
22462 template <class U> friend void f();
22464 template <class U> friend void f() {}
22466 we don't need to look any further. That's what the check for
22467 DECL_INITIAL is for. */
22468 || (TREE_CODE (decl
) == FUNCTION_DECL
22469 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
22470 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
22472 /* The present template, TD, should not be a definition. If it
22473 were a definition, we should be using it! Note that we
22474 cannot restructure the loop to just keep going until we find
22475 a template with a definition, since that might go too far if
22476 a specialization was declared, but not defined. */
22478 /* Fetch the more general template. */
22479 tmpl
= DECL_TI_TEMPLATE (tmpl
);
22485 /* Returns true if we need to instantiate this template instance even if we
22486 know we aren't going to emit it. */
22489 always_instantiate_p (tree decl
)
22491 /* We always instantiate inline functions so that we can inline them. An
22492 explicit instantiation declaration prohibits implicit instantiation of
22493 non-inline functions. With high levels of optimization, we would
22494 normally inline non-inline functions -- but we're not allowed to do
22495 that for "extern template" functions. Therefore, we check
22496 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
22497 return ((TREE_CODE (decl
) == FUNCTION_DECL
22498 && (DECL_DECLARED_INLINE_P (decl
)
22499 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
22500 /* And we need to instantiate static data members so that
22501 their initializers are available in integral constant
22504 && decl_maybe_constant_var_p (decl
)));
22507 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
22508 instantiate it now, modifying TREE_TYPE (fn). Returns false on
22509 error, true otherwise. */
22512 maybe_instantiate_noexcept (tree fn
, tsubst_flags_t complain
)
22514 tree fntype
, spec
, noex
, clone
;
22516 /* Don't instantiate a noexcept-specification from template context. */
22517 if (processing_template_decl
)
22520 if (DECL_CLONED_FUNCTION_P (fn
))
22521 fn
= DECL_CLONED_FUNCTION (fn
);
22522 fntype
= TREE_TYPE (fn
);
22523 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
22525 if (!spec
|| !TREE_PURPOSE (spec
))
22528 noex
= TREE_PURPOSE (spec
);
22530 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
22532 static hash_set
<tree
>* fns
= new hash_set
<tree
>;
22533 bool added
= false;
22534 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
22535 spec
= get_defaulted_eh_spec (fn
, complain
);
22536 else if (!(added
= !fns
->add (fn
)))
22538 /* If hash_set::add returns true, the element was already there. */
22539 location_t loc
= EXPR_LOC_OR_LOC (DEFERRED_NOEXCEPT_PATTERN (noex
),
22540 DECL_SOURCE_LOCATION (fn
));
22542 "exception specification of %qD depends on itself",
22544 spec
= noexcept_false_spec
;
22546 else if (push_tinst_level (fn
))
22548 push_access_scope (fn
);
22549 push_deferring_access_checks (dk_no_deferred
);
22550 input_location
= DECL_SOURCE_LOCATION (fn
);
22551 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
22552 DEFERRED_NOEXCEPT_ARGS (noex
),
22553 tf_warning_or_error
, fn
,
22554 /*function_p=*/false,
22555 /*integral_constant_expression_p=*/true);
22556 pop_deferring_access_checks ();
22557 pop_access_scope (fn
);
22558 pop_tinst_level ();
22559 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
22560 if (spec
== error_mark_node
)
22561 spec
= noexcept_false_spec
;
22564 spec
= noexcept_false_spec
;
22569 if (spec
== error_mark_node
)
22572 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
22575 FOR_EACH_CLONE (clone
, fn
)
22577 if (TREE_TYPE (clone
) == fntype
)
22578 TREE_TYPE (clone
) = TREE_TYPE (fn
);
22580 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
22586 /* Produce the definition of D, a _DECL generated from a template. If
22587 DEFER_OK is true, then we don't have to actually do the
22588 instantiation now; we just have to do it sometime. Normally it is
22589 an error if this is an explicit instantiation but D is undefined.
22590 EXPL_INST_CLASS_MEM_P is true iff D is a member of an explicitly
22591 instantiated class template. */
22594 instantiate_decl (tree d
, bool defer_ok
, bool expl_inst_class_mem_p
)
22596 tree tmpl
= DECL_TI_TEMPLATE (d
);
22603 bool pattern_defined
;
22604 location_t saved_loc
= input_location
;
22605 int saved_unevaluated_operand
= cp_unevaluated_operand
;
22606 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
22610 /* This function should only be used to instantiate templates for
22611 functions and static member variables. */
22612 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
22614 /* A concept is never instantiated. */
22615 gcc_assert (!DECL_DECLARED_CONCEPT_P (d
));
22617 /* Variables are never deferred; if instantiation is required, they
22618 are instantiated right away. That allows for better code in the
22619 case that an expression refers to the value of the variable --
22620 if the variable has a constant value the referring expression can
22621 take advantage of that fact. */
22625 /* Don't instantiate cloned functions. Instead, instantiate the
22626 functions they cloned. */
22627 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
22628 d
= DECL_CLONED_FUNCTION (d
);
22630 if (DECL_TEMPLATE_INSTANTIATED (d
)
22631 || (TREE_CODE (d
) == FUNCTION_DECL
22632 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
22633 || DECL_TEMPLATE_SPECIALIZATION (d
))
22634 /* D has already been instantiated or explicitly specialized, so
22635 there's nothing for us to do here.
22637 It might seem reasonable to check whether or not D is an explicit
22638 instantiation, and, if so, stop here. But when an explicit
22639 instantiation is deferred until the end of the compilation,
22640 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
22641 the instantiation. */
22644 /* Check to see whether we know that this template will be
22645 instantiated in some other file, as with "extern template"
22647 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
22649 /* In general, we do not instantiate such templates. */
22650 if (external_p
&& !always_instantiate_p (d
))
22653 gen_tmpl
= most_general_template (tmpl
);
22654 gen_args
= DECL_TI_ARGS (d
);
22656 if (tmpl
!= gen_tmpl
)
22657 /* We should already have the extra args. */
22658 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
22659 == TMPL_ARGS_DEPTH (gen_args
));
22660 /* And what's in the hash table should match D. */
22661 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
22662 || spec
== NULL_TREE
);
22664 /* This needs to happen before any tsubsting. */
22665 if (! push_tinst_level (d
))
22668 timevar_push (TV_TEMPLATE_INST
);
22670 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
22671 for the instantiation. */
22672 td
= template_for_substitution (d
);
22677 /* Look up an explicit specialization, if any. */
22678 tree tid
= lookup_template_variable (gen_tmpl
, gen_args
);
22679 tree elt
= most_specialized_partial_spec (tid
, tf_warning_or_error
);
22680 if (elt
&& elt
!= error_mark_node
)
22682 td
= TREE_VALUE (elt
);
22683 args
= TREE_PURPOSE (elt
);
22687 code_pattern
= DECL_TEMPLATE_RESULT (td
);
22689 /* We should never be trying to instantiate a member of a class
22690 template or partial specialization. */
22691 gcc_assert (d
!= code_pattern
);
22693 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
22694 || DECL_TEMPLATE_SPECIALIZATION (td
))
22695 /* In the case of a friend template whose definition is provided
22696 outside the class, we may have too many arguments. Drop the
22697 ones we don't need. The same is true for specializations. */
22698 args
= get_innermost_template_args
22699 (args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
22701 if (TREE_CODE (d
) == FUNCTION_DECL
)
22703 deleted_p
= DECL_DELETED_FN (code_pattern
);
22704 pattern_defined
= ((DECL_SAVED_TREE (code_pattern
) != NULL_TREE
22705 && DECL_INITIAL (code_pattern
) != error_mark_node
)
22706 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
22712 if (DECL_CLASS_SCOPE_P (code_pattern
))
22713 pattern_defined
= (! DECL_IN_AGGR_P (code_pattern
)
22714 || DECL_INLINE_VAR_P (code_pattern
));
22716 pattern_defined
= ! DECL_EXTERNAL (code_pattern
);
22719 /* We may be in the middle of deferred access check. Disable it now. */
22720 push_deferring_access_checks (dk_no_deferred
);
22722 /* Unless an explicit instantiation directive has already determined
22723 the linkage of D, remember that a definition is available for
22725 if (pattern_defined
22726 && !DECL_INTERFACE_KNOWN (d
)
22727 && !DECL_NOT_REALLY_EXTERN (d
))
22728 mark_definable (d
);
22730 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
22731 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
22732 input_location
= DECL_SOURCE_LOCATION (d
);
22734 /* If D is a member of an explicitly instantiated class template,
22735 and no definition is available, treat it like an implicit
22737 if (!pattern_defined
&& expl_inst_class_mem_p
22738 && DECL_EXPLICIT_INSTANTIATION (d
))
22740 /* Leave linkage flags alone on instantiations with anonymous
22742 if (TREE_PUBLIC (d
))
22744 DECL_NOT_REALLY_EXTERN (d
) = 0;
22745 DECL_INTERFACE_KNOWN (d
) = 0;
22747 SET_DECL_IMPLICIT_INSTANTIATION (d
);
22750 /* Defer all other templates, unless we have been explicitly
22751 forbidden from doing so. */
22752 if (/* If there is no definition, we cannot instantiate the
22755 /* If it's OK to postpone instantiation, do so. */
22757 /* If this is a static data member that will be defined
22758 elsewhere, we don't want to instantiate the entire data
22759 member, but we do want to instantiate the initializer so that
22760 we can substitute that elsewhere. */
22761 || (external_p
&& VAR_P (d
))
22762 /* Handle here a deleted function too, avoid generating
22763 its body (c++/61080). */
22766 /* The definition of the static data member is now required so
22767 we must substitute the initializer. */
22769 && !DECL_INITIAL (d
)
22770 && DECL_INITIAL (code_pattern
))
22774 bool const_init
= false;
22775 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
22777 ns
= decl_namespace_context (d
);
22778 push_nested_namespace (ns
);
22780 push_nested_class (DECL_CONTEXT (d
));
22781 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
22783 tf_warning_or_error
, NULL_TREE
,
22784 /*integral_constant_expression_p=*/false);
22785 /* If instantiating the initializer involved instantiating this
22786 again, don't call cp_finish_decl twice. */
22787 if (!DECL_INITIAL (d
))
22789 /* Make sure the initializer is still constant, in case of
22790 circular dependency (template/instantiate6.C). */
22792 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
22793 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
22794 /*asmspec_tree=*/NULL_TREE
,
22795 LOOKUP_ONLYCONVERTING
);
22798 pop_nested_class ();
22799 pop_nested_namespace (ns
);
22802 /* We restore the source position here because it's used by
22803 add_pending_template. */
22804 input_location
= saved_loc
;
22806 if (at_eof
&& !pattern_defined
22807 && DECL_EXPLICIT_INSTANTIATION (d
)
22808 && DECL_NOT_REALLY_EXTERN (d
))
22811 The definition of a non-exported function template, a
22812 non-exported member function template, or a non-exported
22813 member function or static data member of a class template
22814 shall be present in every translation unit in which it is
22815 explicitly instantiated. */
22816 permerror (input_location
, "explicit instantiation of %qD "
22817 "but no definition available", d
);
22819 /* If we're in unevaluated context, we just wanted to get the
22820 constant value; this isn't an odr use, so don't queue
22821 a full instantiation. */
22822 if (cp_unevaluated_operand
!= 0)
22824 /* ??? Historically, we have instantiated inline functions, even
22825 when marked as "extern template". */
22826 if (!(external_p
&& VAR_P (d
)))
22827 add_pending_template (d
);
22830 /* Tell the repository that D is available in this translation unit
22831 -- and see if it is supposed to be instantiated here. */
22832 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
22834 /* In a PCH file, despite the fact that the repository hasn't
22835 requested instantiation in the PCH it is still possible that
22836 an instantiation will be required in a file that includes the
22839 add_pending_template (d
);
22840 /* Instantiate inline functions so that the inliner can do its
22841 job, even though we'll not be emitting a copy of this
22843 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
22847 bool push_to_top
, nested
;
22849 fn_context
= decl_function_context (d
);
22850 nested
= current_function_decl
!= NULL_TREE
;
22851 push_to_top
= !(nested
&& fn_context
== current_function_decl
);
22853 vec
<tree
> omp_privatization_save
;
22855 save_omp_privatization_clauses (omp_privatization_save
);
22858 push_to_top_level ();
22861 push_function_context ();
22862 cp_unevaluated_operand
= 0;
22863 c_inhibit_evaluation_warnings
= 0;
22866 /* Mark D as instantiated so that recursive calls to
22867 instantiate_decl do not try to instantiate it again. */
22868 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
22870 /* Regenerate the declaration in case the template has been modified
22871 by a subsequent redeclaration. */
22872 regenerate_decl_from_template (d
, td
, args
);
22874 /* We already set the file and line above. Reset them now in case
22875 they changed as a result of calling regenerate_decl_from_template. */
22876 input_location
= DECL_SOURCE_LOCATION (d
);
22881 bool const_init
= false;
22883 /* Clear out DECL_RTL; whatever was there before may not be right
22884 since we've reset the type of the declaration. */
22885 SET_DECL_RTL (d
, NULL
);
22886 DECL_IN_AGGR_P (d
) = 0;
22888 /* The initializer is placed in DECL_INITIAL by
22889 regenerate_decl_from_template so we don't need to
22890 push/pop_access_scope again here. Pull it out so that
22891 cp_finish_decl can process it. */
22892 init
= DECL_INITIAL (d
);
22893 DECL_INITIAL (d
) = NULL_TREE
;
22894 DECL_INITIALIZED_P (d
) = 0;
22896 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
22897 initializer. That function will defer actual emission until
22898 we have a chance to determine linkage. */
22899 DECL_EXTERNAL (d
) = 0;
22901 /* Enter the scope of D so that access-checking works correctly. */
22902 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
22904 push_nested_class (DECL_CONTEXT (d
));
22906 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
22907 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
22910 pop_nested_class ();
22912 if (variable_template_p (gen_tmpl
))
22913 note_variable_template_instantiation (d
);
22915 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
22916 synthesize_method (d
);
22917 else if (TREE_CODE (d
) == FUNCTION_DECL
)
22919 hash_map
<tree
, tree
> *saved_local_specializations
;
22922 tree block
= NULL_TREE
;
22923 tree lambda_ctx
= NULL_TREE
;
22925 /* Save away the current list, in case we are instantiating one
22926 template from within the body of another. */
22927 saved_local_specializations
= local_specializations
;
22929 /* Set up the list of local specializations. */
22930 local_specializations
= new hash_map
<tree
, tree
>;
22932 /* Set up context. */
22933 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
22934 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
22935 block
= push_stmt_list ();
22938 if (push_to_top
&& LAMBDA_FUNCTION_P (d
))
22940 /* When instantiating a lambda's templated function
22941 operator, we need to push the non-lambda class scope
22942 of the lambda itself so that the nested function
22943 stack is sufficiently correct to deal with this
22945 lambda_ctx
= DECL_CONTEXT (d
);
22947 lambda_ctx
= decl_type_context (TYPE_NAME (lambda_ctx
));
22948 while (lambda_ctx
&& LAMBDA_TYPE_P (lambda_ctx
));
22950 push_nested_class (lambda_ctx
);
22952 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
22955 /* Some typedefs referenced from within the template code need to be
22956 access checked at template instantiation time, i.e now. These
22957 types were added to the template at parsing time. Let's get those
22958 and perform the access checks then. */
22959 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (td
),
22962 /* Create substitution entries for the parameters. */
22963 tmpl_parm
= DECL_ARGUMENTS (code_pattern
);
22964 spec_parm
= DECL_ARGUMENTS (d
);
22965 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
22967 register_local_specialization (spec_parm
, tmpl_parm
);
22968 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
22969 tmpl_parm
= skip_artificial_parms_for (code_pattern
, tmpl_parm
);
22971 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
22973 if (!DECL_PACK_P (tmpl_parm
))
22975 register_local_specialization (spec_parm
, tmpl_parm
);
22976 spec_parm
= DECL_CHAIN (spec_parm
);
22980 /* Register the (value) argument pack as a specialization of
22981 TMPL_PARM, then move on. */
22982 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
22983 register_local_specialization (argpack
, tmpl_parm
);
22986 gcc_assert (!spec_parm
);
22988 /* Substitute into the body of the function. */
22989 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
22990 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
22991 tf_warning_or_error
, tmpl
);
22994 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
22995 tf_warning_or_error
, tmpl
,
22996 /*integral_constant_expression_p=*/false);
22998 /* Set the current input_location to the end of the function
22999 so that finish_function knows where we are. */
23001 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
23003 /* Remember if we saw an infinite loop in the template. */
23004 current_function_infinite_loop
23005 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
23008 /* We don't need the local specializations any more. */
23009 delete local_specializations
;
23010 local_specializations
= saved_local_specializations
;
23012 /* Finish the function. */
23013 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
23014 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
23015 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
23018 d
= finish_function (0);
23019 expand_or_defer_fn (d
);
23022 pop_nested_class ();
23024 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
23025 cp_check_omp_declare_reduction (d
);
23028 /* We're not deferring instantiation any more. */
23029 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
23032 pop_from_top_level ();
23034 pop_function_context ();
23037 restore_omp_privatization_clauses (omp_privatization_save
);
23040 pop_deferring_access_checks ();
23041 timevar_pop (TV_TEMPLATE_INST
);
23042 pop_tinst_level ();
23043 input_location
= saved_loc
;
23044 cp_unevaluated_operand
= saved_unevaluated_operand
;
23045 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
23050 /* Run through the list of templates that we wish we could
23051 instantiate, and instantiate any we can. RETRIES is the
23052 number of times we retry pending template instantiation. */
23055 instantiate_pending_templates (int retries
)
23058 location_t saved_loc
= input_location
;
23060 /* Instantiating templates may trigger vtable generation. This in turn
23061 may require further template instantiations. We place a limit here
23062 to avoid infinite loop. */
23063 if (pending_templates
&& retries
>= max_tinst_depth
)
23065 tree decl
= pending_templates
->tinst
->decl
;
23067 fatal_error (input_location
,
23068 "template instantiation depth exceeds maximum of %d"
23069 " instantiating %q+D, possibly from virtual table generation"
23070 " (use -ftemplate-depth= to increase the maximum)",
23071 max_tinst_depth
, decl
);
23072 if (TREE_CODE (decl
) == FUNCTION_DECL
)
23073 /* Pretend that we defined it. */
23074 DECL_INITIAL (decl
) = error_mark_node
;
23080 struct pending_template
**t
= &pending_templates
;
23081 struct pending_template
*last
= NULL
;
23085 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
23086 bool complete
= false;
23088 if (TYPE_P (instantiation
))
23090 if (!COMPLETE_TYPE_P (instantiation
))
23092 instantiate_class_template (instantiation
);
23093 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
23094 for (tree fld
= TYPE_FIELDS (instantiation
);
23095 fld
; fld
= TREE_CHAIN (fld
))
23097 || (TREE_CODE (fld
) == FUNCTION_DECL
23098 && !DECL_ARTIFICIAL (fld
)))
23099 && DECL_TEMPLATE_INSTANTIATION (fld
))
23100 instantiate_decl (fld
,
23101 /*defer_ok=*/false,
23102 /*expl_inst_class_mem_p=*/false);
23104 if (COMPLETE_TYPE_P (instantiation
))
23108 complete
= COMPLETE_TYPE_P (instantiation
);
23112 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
23113 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
23116 = instantiate_decl (instantiation
,
23117 /*defer_ok=*/false,
23118 /*expl_inst_class_mem_p=*/false);
23119 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
23123 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
23124 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
23128 /* If INSTANTIATION has been instantiated, then we don't
23129 need to consider it again in the future. */
23137 current_tinst_level
= NULL
;
23139 last_pending_template
= last
;
23141 while (reconsider
);
23143 input_location
= saved_loc
;
23146 /* Substitute ARGVEC into T, which is a list of initializers for
23147 either base class or a non-static data member. The TREE_PURPOSEs
23148 are DECLs, and the TREE_VALUEs are the initializer values. Used by
23149 instantiate_decl. */
23152 tsubst_initializer_list (tree t
, tree argvec
)
23154 tree inits
= NULL_TREE
;
23156 for (; t
; t
= TREE_CHAIN (t
))
23160 tree expanded_bases
= NULL_TREE
;
23161 tree expanded_arguments
= NULL_TREE
;
23164 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
23169 /* Expand the base class expansion type into separate base
23171 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
23172 tf_warning_or_error
,
23174 if (expanded_bases
== error_mark_node
)
23177 /* We'll be building separate TREE_LISTs of arguments for
23179 len
= TREE_VEC_LENGTH (expanded_bases
);
23180 expanded_arguments
= make_tree_vec (len
);
23181 for (i
= 0; i
< len
; i
++)
23182 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
23184 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
23185 expand each argument in the TREE_VALUE of t. */
23186 expr
= make_node (EXPR_PACK_EXPANSION
);
23187 PACK_EXPANSION_LOCAL_P (expr
) = true;
23188 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
23189 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
23191 if (TREE_VALUE (t
) == void_type_node
)
23192 /* VOID_TYPE_NODE is used to indicate
23193 value-initialization. */
23195 for (i
= 0; i
< len
; i
++)
23196 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
23200 /* Substitute parameter packs into each argument in the
23202 in_base_initializer
= 1;
23203 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
23205 tree expanded_exprs
;
23207 /* Expand the argument. */
23208 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
23210 = tsubst_pack_expansion (expr
, argvec
,
23211 tf_warning_or_error
,
23213 if (expanded_exprs
== error_mark_node
)
23216 /* Prepend each of the expanded expressions to the
23217 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
23218 for (i
= 0; i
< len
; i
++)
23220 TREE_VEC_ELT (expanded_arguments
, i
) =
23221 tree_cons (NULL_TREE
,
23222 TREE_VEC_ELT (expanded_exprs
, i
),
23223 TREE_VEC_ELT (expanded_arguments
, i
));
23226 in_base_initializer
= 0;
23228 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
23229 since we built them backwards. */
23230 for (i
= 0; i
< len
; i
++)
23232 TREE_VEC_ELT (expanded_arguments
, i
) =
23233 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
23238 for (i
= 0; i
< len
; ++i
)
23240 if (expanded_bases
)
23242 decl
= TREE_VEC_ELT (expanded_bases
, i
);
23243 decl
= expand_member_init (decl
);
23244 init
= TREE_VEC_ELT (expanded_arguments
, i
);
23249 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
23250 tf_warning_or_error
, NULL_TREE
);
23252 decl
= expand_member_init (decl
);
23253 if (decl
&& !DECL_P (decl
))
23254 in_base_initializer
= 1;
23256 init
= TREE_VALUE (t
);
23258 if (init
!= void_type_node
)
23259 init
= tsubst_expr (init
, argvec
,
23260 tf_warning_or_error
, NULL_TREE
,
23261 /*integral_constant_expression_p=*/false);
23262 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
23263 /* If we had an initializer but it instantiated to nothing,
23264 value-initialize the object. This will only occur when
23265 the initializer was a pack expansion where the parameter
23266 packs used in that expansion were of length zero. */
23267 init
= void_type_node
;
23268 in_base_initializer
= 0;
23273 init
= build_tree_list (decl
, init
);
23274 TREE_CHAIN (init
) = inits
;
23282 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
23285 set_current_access_from_decl (tree decl
)
23287 if (TREE_PRIVATE (decl
))
23288 current_access_specifier
= access_private_node
;
23289 else if (TREE_PROTECTED (decl
))
23290 current_access_specifier
= access_protected_node
;
23292 current_access_specifier
= access_public_node
;
23295 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
23296 is the instantiation (which should have been created with
23297 start_enum) and ARGS are the template arguments to use. */
23300 tsubst_enum (tree tag
, tree newtag
, tree args
)
23304 if (SCOPED_ENUM_P (newtag
))
23305 begin_scope (sk_scoped_enum
, newtag
);
23307 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
23312 decl
= TREE_VALUE (e
);
23313 /* Note that in a template enum, the TREE_VALUE is the
23314 CONST_DECL, not the corresponding INTEGER_CST. */
23315 value
= tsubst_expr (DECL_INITIAL (decl
),
23316 args
, tf_warning_or_error
, NULL_TREE
,
23317 /*integral_constant_expression_p=*/true);
23319 /* Give this enumeration constant the correct access. */
23320 set_current_access_from_decl (decl
);
23322 /* Actually build the enumerator itself. Here we're assuming that
23323 enumerators can't have dependent attributes. */
23324 build_enumerator (DECL_NAME (decl
), value
, newtag
,
23325 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
23328 if (SCOPED_ENUM_P (newtag
))
23331 finish_enum_value_list (newtag
);
23332 finish_enum (newtag
);
23334 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
23335 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
23338 /* DECL is a FUNCTION_DECL that is a template specialization. Return
23339 its type -- but without substituting the innermost set of template
23340 arguments. So, innermost set of template parameters will appear in
23344 get_mostly_instantiated_function_type (tree decl
)
23346 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
23347 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
23350 /* Return truthvalue if we're processing a template different from
23351 the last one involved in diagnostics. */
23353 problematic_instantiation_changed (void)
23355 return current_tinst_level
!= last_error_tinst_level
;
23358 /* Remember current template involved in diagnostics. */
23360 record_last_problematic_instantiation (void)
23362 last_error_tinst_level
= current_tinst_level
;
23365 struct tinst_level
*
23366 current_instantiation (void)
23368 return current_tinst_level
;
23371 /* Return TRUE if current_function_decl is being instantiated, false
23375 instantiating_current_function_p (void)
23377 return (current_instantiation ()
23378 && current_instantiation ()->decl
== current_function_decl
);
23381 /* [temp.param] Check that template non-type parm TYPE is of an allowable
23382 type. Return zero for ok, nonzero for disallowed. Issue error and
23383 warning messages under control of COMPLAIN. */
23386 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
23388 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
23390 else if (POINTER_TYPE_P (type
))
23392 else if (TYPE_PTRMEM_P (type
))
23394 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
23396 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
23398 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
23400 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
23402 /* A bound template template parm could later be instantiated to have a valid
23403 nontype parm type via an alias template. */
23404 else if (cxx_dialect
>= cxx11
23405 && TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
23408 if (complain
& tf_error
)
23410 if (type
== error_mark_node
)
23411 inform (input_location
, "invalid template non-type parameter");
23413 error ("%q#T is not a valid type for a template non-type parameter",
23419 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
23420 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
23423 dependent_type_p_r (tree type
)
23429 A type is dependent if it is:
23431 -- a template parameter. Template template parameters are types
23432 for us (since TYPE_P holds true for them) so we handle
23434 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
23435 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
23437 /* -- a qualified-id with a nested-name-specifier which contains a
23438 class-name that names a dependent type or whose unqualified-id
23439 names a dependent type. */
23440 if (TREE_CODE (type
) == TYPENAME_TYPE
)
23443 /* An alias template specialization can be dependent even if the
23444 resulting type is not. */
23445 if (dependent_alias_template_spec_p (type
))
23448 /* -- a cv-qualified type where the cv-unqualified type is
23450 No code is necessary for this bullet; the code below handles
23451 cv-qualified types, and we don't want to strip aliases with
23452 TYPE_MAIN_VARIANT because of DR 1558. */
23453 /* -- a compound type constructed from any dependent type. */
23454 if (TYPE_PTRMEM_P (type
))
23455 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
23456 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
23458 else if (TYPE_PTR_P (type
)
23459 || TREE_CODE (type
) == REFERENCE_TYPE
)
23460 return dependent_type_p (TREE_TYPE (type
));
23461 else if (TREE_CODE (type
) == FUNCTION_TYPE
23462 || TREE_CODE (type
) == METHOD_TYPE
)
23466 if (dependent_type_p (TREE_TYPE (type
)))
23468 for (arg_type
= TYPE_ARG_TYPES (type
);
23470 arg_type
= TREE_CHAIN (arg_type
))
23471 if (dependent_type_p (TREE_VALUE (arg_type
)))
23473 if (cxx_dialect
>= cxx1z
)
23475 /* A value-dependent noexcept-specifier makes the type dependent. */
23476 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
23477 if (spec
&& TREE_PURPOSE (spec
)
23478 && value_dependent_expression_p (TREE_PURPOSE (spec
)))
23483 /* -- an array type constructed from any dependent type or whose
23484 size is specified by a constant expression that is
23487 We checked for type- and value-dependence of the bounds in
23488 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
23489 if (TREE_CODE (type
) == ARRAY_TYPE
)
23491 if (TYPE_DOMAIN (type
)
23492 && dependent_type_p (TYPE_DOMAIN (type
)))
23494 return dependent_type_p (TREE_TYPE (type
));
23497 /* -- a template-id in which either the template name is a template
23499 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
23501 /* ... or any of the template arguments is a dependent type or
23502 an expression that is type-dependent or value-dependent. */
23503 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
23504 && (any_dependent_template_arguments_p
23505 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
23508 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
23509 dependent; if the argument of the `typeof' expression is not
23510 type-dependent, then it should already been have resolved. */
23511 if (TREE_CODE (type
) == TYPEOF_TYPE
23512 || TREE_CODE (type
) == DECLTYPE_TYPE
23513 || TREE_CODE (type
) == UNDERLYING_TYPE
)
23516 /* A template argument pack is dependent if any of its packed
23518 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
23520 tree args
= ARGUMENT_PACK_ARGS (type
);
23521 int i
, len
= TREE_VEC_LENGTH (args
);
23522 for (i
= 0; i
< len
; ++i
)
23523 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
23527 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
23528 be template parameters. */
23529 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
23532 if (any_dependent_type_attributes_p (TYPE_ATTRIBUTES (type
)))
23535 /* The standard does not specifically mention types that are local
23536 to template functions or local classes, but they should be
23537 considered dependent too. For example:
23539 template <int I> void f() {
23544 The size of `E' cannot be known until the value of `I' has been
23545 determined. Therefore, `E' must be considered dependent. */
23546 scope
= TYPE_CONTEXT (type
);
23547 if (scope
&& TYPE_P (scope
))
23548 return dependent_type_p (scope
);
23549 /* Don't use type_dependent_expression_p here, as it can lead
23550 to infinite recursion trying to determine whether a lambda
23551 nested in a lambda is dependent (c++/47687). */
23552 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
23553 && DECL_LANG_SPECIFIC (scope
)
23554 && DECL_TEMPLATE_INFO (scope
)
23555 && (any_dependent_template_arguments_p
23556 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
23559 /* Other types are non-dependent. */
23563 /* Returns TRUE if TYPE is dependent, in the sense of
23564 [temp.dep.type]. Note that a NULL type is considered dependent. */
23567 dependent_type_p (tree type
)
23569 /* If there are no template parameters in scope, then there can't be
23570 any dependent types. */
23571 if (!processing_template_decl
)
23573 /* If we are not processing a template, then nobody should be
23574 providing us with a dependent type. */
23576 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
23580 /* If the type is NULL, we have not computed a type for the entity
23581 in question; in that case, the type is dependent. */
23585 /* Erroneous types can be considered non-dependent. */
23586 if (type
== error_mark_node
)
23589 /* Getting here with global_type_node means we improperly called this
23590 function on the TREE_TYPE of an IDENTIFIER_NODE. */
23591 gcc_checking_assert (type
!= global_type_node
);
23593 /* If we have not already computed the appropriate value for TYPE,
23595 if (!TYPE_DEPENDENT_P_VALID (type
))
23597 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
23598 TYPE_DEPENDENT_P_VALID (type
) = 1;
23601 return TYPE_DEPENDENT_P (type
);
23604 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
23605 lookup. In other words, a dependent type that is not the current
23609 dependent_scope_p (tree scope
)
23611 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
23612 && !currently_open_class (scope
));
23615 /* T is a SCOPE_REF; return whether we need to consider it
23616 instantiation-dependent so that we can check access at instantiation
23617 time even though we know which member it resolves to. */
23620 instantiation_dependent_scope_ref_p (tree t
)
23622 if (DECL_P (TREE_OPERAND (t
, 1))
23623 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
23624 && accessible_in_template_p (TREE_OPERAND (t
, 0),
23625 TREE_OPERAND (t
, 1)))
23631 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
23632 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
23635 /* Note that this predicate is not appropriate for general expressions;
23636 only constant expressions (that satisfy potential_constant_expression)
23637 can be tested for value dependence. */
23640 value_dependent_expression_p (tree expression
)
23642 if (!processing_template_decl
|| expression
== NULL_TREE
)
23645 /* A name declared with a dependent type. */
23646 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
23649 switch (TREE_CODE (expression
))
23652 /* A dependent member function of the current instantiation. */
23653 return dependent_type_p (BINFO_TYPE (BASELINK_BINFO (expression
)));
23655 case FUNCTION_DECL
:
23656 /* A dependent member function of the current instantiation. */
23657 if (DECL_CLASS_SCOPE_P (expression
)
23658 && dependent_type_p (DECL_CONTEXT (expression
)))
23662 case IDENTIFIER_NODE
:
23663 /* A name that has not been looked up -- must be dependent. */
23666 case TEMPLATE_PARM_INDEX
:
23667 /* A non-type template parm. */
23671 /* A non-type template parm. */
23672 if (DECL_TEMPLATE_PARM_P (expression
))
23674 return value_dependent_expression_p (DECL_INITIAL (expression
));
23677 /* A constant with literal type and is initialized
23678 with an expression that is value-dependent.
23680 Note that a non-dependent parenthesized initializer will have
23681 already been replaced with its constant value, so if we see
23682 a TREE_LIST it must be dependent. */
23683 if (DECL_INITIAL (expression
)
23684 && decl_constant_var_p (expression
)
23685 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
23686 /* cp_finish_decl doesn't fold reference initializers. */
23687 || TREE_CODE (TREE_TYPE (expression
)) == REFERENCE_TYPE
23688 || type_dependent_expression_p (DECL_INITIAL (expression
))
23689 || value_dependent_expression_p (DECL_INITIAL (expression
))))
23691 if (DECL_HAS_VALUE_EXPR_P (expression
))
23693 tree value_expr
= DECL_VALUE_EXPR (expression
);
23694 if (type_dependent_expression_p (value_expr
))
23699 case DYNAMIC_CAST_EXPR
:
23700 case STATIC_CAST_EXPR
:
23701 case CONST_CAST_EXPR
:
23702 case REINTERPRET_CAST_EXPR
:
23704 /* These expressions are value-dependent if the type to which
23705 the cast occurs is dependent or the expression being casted
23706 is value-dependent. */
23708 tree type
= TREE_TYPE (expression
);
23710 if (dependent_type_p (type
))
23713 /* A functional cast has a list of operands. */
23714 expression
= TREE_OPERAND (expression
, 0);
23717 /* If there are no operands, it must be an expression such
23718 as "int()". This should not happen for aggregate types
23719 because it would form non-constant expressions. */
23720 gcc_assert (cxx_dialect
>= cxx11
23721 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
23726 if (TREE_CODE (expression
) == TREE_LIST
)
23727 return any_value_dependent_elements_p (expression
);
23729 return value_dependent_expression_p (expression
);
23733 if (SIZEOF_EXPR_TYPE_P (expression
))
23734 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
23738 /* A `sizeof' expression is value-dependent if the operand is
23739 type-dependent or is a pack expansion. */
23740 expression
= TREE_OPERAND (expression
, 0);
23741 if (PACK_EXPANSION_P (expression
))
23743 else if (TYPE_P (expression
))
23744 return dependent_type_p (expression
);
23745 return instantiation_dependent_uneval_expression_p (expression
);
23747 case AT_ENCODE_EXPR
:
23748 /* An 'encode' expression is value-dependent if the operand is
23750 expression
= TREE_OPERAND (expression
, 0);
23751 return dependent_type_p (expression
);
23753 case NOEXCEPT_EXPR
:
23754 expression
= TREE_OPERAND (expression
, 0);
23755 return instantiation_dependent_uneval_expression_p (expression
);
23758 /* All instantiation-dependent expressions should also be considered
23759 value-dependent. */
23760 return instantiation_dependent_scope_ref_p (expression
);
23762 case COMPONENT_REF
:
23763 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
23764 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
23766 case NONTYPE_ARGUMENT_PACK
:
23767 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
23768 is value-dependent. */
23770 tree values
= ARGUMENT_PACK_ARGS (expression
);
23771 int i
, len
= TREE_VEC_LENGTH (values
);
23773 for (i
= 0; i
< len
; ++i
)
23774 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
23782 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
23783 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
23784 || (type2
? dependent_type_p (type2
) : false));
23788 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
23789 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
23792 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
23793 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
23797 tree op
= TREE_OPERAND (expression
, 0);
23798 return (value_dependent_expression_p (op
)
23799 || has_value_dependent_address (op
));
23802 case REQUIRES_EXPR
:
23803 /* Treat all requires-expressions as value-dependent so
23804 we don't try to fold them. */
23808 return dependent_type_p (TREE_OPERAND (expression
, 0));
23812 if (value_dependent_expression_p (CALL_EXPR_FN (expression
)))
23814 tree fn
= get_callee_fndecl (expression
);
23816 nargs
= call_expr_nargs (expression
);
23817 for (i
= 0; i
< nargs
; ++i
)
23819 tree op
= CALL_EXPR_ARG (expression
, i
);
23820 /* In a call to a constexpr member function, look through the
23821 implicit ADDR_EXPR on the object argument so that it doesn't
23822 cause the call to be considered value-dependent. We also
23823 look through it in potential_constant_expression. */
23824 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
23825 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
23826 && TREE_CODE (op
) == ADDR_EXPR
)
23827 op
= TREE_OPERAND (op
, 0);
23828 if (value_dependent_expression_p (op
))
23834 case TEMPLATE_ID_EXPR
:
23835 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
23837 return type_dependent_expression_p (expression
)
23838 || variable_concept_p (TREE_OPERAND (expression
, 0));
23844 if (dependent_type_p (TREE_TYPE (expression
)))
23846 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
23847 if (value_dependent_expression_p (val
))
23853 /* Treat a GNU statement expression as dependent to avoid crashing
23854 under instantiate_non_dependent_expr; it can't be constant. */
23858 /* A constant expression is value-dependent if any subexpression is
23859 value-dependent. */
23860 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
23862 case tcc_reference
:
23864 case tcc_comparison
:
23866 case tcc_expression
:
23869 int i
, len
= cp_tree_operand_length (expression
);
23871 for (i
= 0; i
< len
; i
++)
23873 tree t
= TREE_OPERAND (expression
, i
);
23875 /* In some cases, some of the operands may be missing.
23876 (For example, in the case of PREDECREMENT_EXPR, the
23877 amount to increment by may be missing.) That doesn't
23878 make the expression dependent. */
23879 if (t
&& value_dependent_expression_p (t
))
23890 /* The expression is not value-dependent. */
23894 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
23895 [temp.dep.expr]. Note that an expression with no type is
23896 considered dependent. Other parts of the compiler arrange for an
23897 expression with type-dependent subexpressions to have no type, so
23898 this function doesn't have to be fully recursive. */
23901 type_dependent_expression_p (tree expression
)
23903 if (!processing_template_decl
)
23906 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
23909 /* An unresolved name is always dependent. */
23910 if (identifier_p (expression
)
23911 || TREE_CODE (expression
) == USING_DECL
23912 || TREE_CODE (expression
) == WILDCARD_DECL
)
23915 /* A fold expression is type-dependent. */
23916 if (TREE_CODE (expression
) == UNARY_LEFT_FOLD_EXPR
23917 || TREE_CODE (expression
) == UNARY_RIGHT_FOLD_EXPR
23918 || TREE_CODE (expression
) == BINARY_LEFT_FOLD_EXPR
23919 || TREE_CODE (expression
) == BINARY_RIGHT_FOLD_EXPR
)
23922 /* Some expression forms are never type-dependent. */
23923 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
23924 || TREE_CODE (expression
) == SIZEOF_EXPR
23925 || TREE_CODE (expression
) == ALIGNOF_EXPR
23926 || TREE_CODE (expression
) == AT_ENCODE_EXPR
23927 || TREE_CODE (expression
) == NOEXCEPT_EXPR
23928 || TREE_CODE (expression
) == TRAIT_EXPR
23929 || TREE_CODE (expression
) == TYPEID_EXPR
23930 || TREE_CODE (expression
) == DELETE_EXPR
23931 || TREE_CODE (expression
) == VEC_DELETE_EXPR
23932 || TREE_CODE (expression
) == THROW_EXPR
23933 || TREE_CODE (expression
) == REQUIRES_EXPR
)
23936 /* The types of these expressions depends only on the type to which
23937 the cast occurs. */
23938 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
23939 || TREE_CODE (expression
) == STATIC_CAST_EXPR
23940 || TREE_CODE (expression
) == CONST_CAST_EXPR
23941 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
23942 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
23943 || TREE_CODE (expression
) == CAST_EXPR
)
23944 return dependent_type_p (TREE_TYPE (expression
));
23946 /* The types of these expressions depends only on the type created
23947 by the expression. */
23948 if (TREE_CODE (expression
) == NEW_EXPR
23949 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
23951 /* For NEW_EXPR tree nodes created inside a template, either
23952 the object type itself or a TREE_LIST may appear as the
23954 tree type
= TREE_OPERAND (expression
, 1);
23955 if (TREE_CODE (type
) == TREE_LIST
)
23956 /* This is an array type. We need to check array dimensions
23958 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
23959 || value_dependent_expression_p
23960 (TREE_OPERAND (TREE_VALUE (type
), 1));
23962 return dependent_type_p (type
);
23965 if (TREE_CODE (expression
) == SCOPE_REF
)
23967 tree scope
= TREE_OPERAND (expression
, 0);
23968 tree name
= TREE_OPERAND (expression
, 1);
23970 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
23971 contains an identifier associated by name lookup with one or more
23972 declarations declared with a dependent type, or...a
23973 nested-name-specifier or qualified-id that names a member of an
23974 unknown specialization. */
23975 return (type_dependent_expression_p (name
)
23976 || dependent_scope_p (scope
));
23979 if (TREE_CODE (expression
) == TEMPLATE_DECL
23980 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
23981 return uses_outer_template_parms (expression
);
23983 if (TREE_CODE (expression
) == STMT_EXPR
)
23984 expression
= stmt_expr_value_expr (expression
);
23986 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
23991 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
23993 if (type_dependent_expression_p (elt
))
23999 /* A static data member of the current instantiation with incomplete
24000 array type is type-dependent, as the definition and specializations
24001 can have different bounds. */
24002 if (VAR_P (expression
)
24003 && DECL_CLASS_SCOPE_P (expression
)
24004 && dependent_type_p (DECL_CONTEXT (expression
))
24005 && VAR_HAD_UNKNOWN_BOUND (expression
))
24008 /* An array of unknown bound depending on a variadic parameter, eg:
24010 template<typename... Args>
24011 void foo (Args... args)
24013 int arr[] = { args... };
24016 template<int... vals>
24019 int arr[] = { vals... };
24022 If the array has no length and has an initializer, it must be that
24023 we couldn't determine its length in cp_complete_array_type because
24024 it is dependent. */
24025 if (VAR_P (expression
)
24026 && TREE_TYPE (expression
) != NULL_TREE
24027 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
24028 && !TYPE_DOMAIN (TREE_TYPE (expression
))
24029 && DECL_INITIAL (expression
))
24032 /* A function or variable template-id is type-dependent if it has any
24033 dependent template arguments. */
24034 if (VAR_OR_FUNCTION_DECL_P (expression
)
24035 && DECL_LANG_SPECIFIC (expression
)
24036 && DECL_TEMPLATE_INFO (expression
))
24038 /* Consider the innermost template arguments, since those are the ones
24039 that come from the template-id; the template arguments for the
24040 enclosing class do not make it type-dependent unless they are used in
24041 the type of the decl. */
24042 if (PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (expression
))
24043 && (any_dependent_template_arguments_p
24044 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
24047 /* Otherwise, if the decl isn't from a dependent scope, it can't be
24048 type-dependent. Checking this is important for functions with auto
24049 return type, which looks like a dependent type. */
24050 if (TREE_CODE (expression
) == FUNCTION_DECL
24051 && (!DECL_CLASS_SCOPE_P (expression
)
24052 || !dependent_type_p (DECL_CONTEXT (expression
)))
24053 && (!DECL_FRIEND_CONTEXT (expression
)
24054 || !dependent_type_p (DECL_FRIEND_CONTEXT (expression
)))
24055 && !DECL_LOCAL_FUNCTION_P (expression
))
24057 gcc_assert (!dependent_type_p (TREE_TYPE (expression
))
24058 || undeduced_auto_decl (expression
));
24063 /* Always dependent, on the number of arguments if nothing else. */
24064 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
24067 if (TREE_TYPE (expression
) == unknown_type_node
)
24069 if (TREE_CODE (expression
) == ADDR_EXPR
)
24070 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
24071 if (TREE_CODE (expression
) == COMPONENT_REF
24072 || TREE_CODE (expression
) == OFFSET_REF
)
24074 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
24076 expression
= TREE_OPERAND (expression
, 1);
24077 if (identifier_p (expression
))
24080 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
24081 if (TREE_CODE (expression
) == SCOPE_REF
)
24084 if (BASELINK_P (expression
))
24086 if (BASELINK_OPTYPE (expression
)
24087 && dependent_type_p (BASELINK_OPTYPE (expression
)))
24089 expression
= BASELINK_FUNCTIONS (expression
);
24092 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
24094 if (any_dependent_template_arguments_p
24095 (TREE_OPERAND (expression
, 1)))
24097 expression
= TREE_OPERAND (expression
, 0);
24098 if (identifier_p (expression
))
24102 gcc_assert (TREE_CODE (expression
) == OVERLOAD
24103 || TREE_CODE (expression
) == FUNCTION_DECL
);
24105 for (lkp_iterator
iter (expression
); iter
; ++iter
)
24106 if (type_dependent_expression_p (*iter
))
24112 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
24114 /* Dependent type attributes might not have made it from the decl to
24116 if (DECL_P (expression
)
24117 && any_dependent_type_attributes_p (DECL_ATTRIBUTES (expression
)))
24120 return (dependent_type_p (TREE_TYPE (expression
)));
24123 /* [temp.dep.expr]/5: A class member access expression (5.2.5) is
24124 type-dependent if the expression refers to a member of the current
24125 instantiation and the type of the referenced member is dependent, or the
24126 class member access expression refers to a member of an unknown
24129 This function returns true if the OBJECT in such a class member access
24130 expression is of an unknown specialization. */
24133 type_dependent_object_expression_p (tree object
)
24135 /* An IDENTIFIER_NODE can sometimes have a TREE_TYPE, but it's still
24137 if (TREE_CODE (object
) == IDENTIFIER_NODE
)
24139 tree scope
= TREE_TYPE (object
);
24140 return (!scope
|| dependent_scope_p (scope
));
24143 /* walk_tree callback function for instantiation_dependent_expression_p,
24144 below. Returns non-zero if a dependent subexpression is found. */
24147 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
24152 /* We don't have to worry about decltype currently because decltype
24153 of an instantiation-dependent expr is a dependent type. This
24154 might change depending on the resolution of DR 1172. */
24155 *walk_subtrees
= false;
24158 enum tree_code code
= TREE_CODE (*tp
);
24161 /* Don't treat an argument list as dependent just because it has no
24167 case TEMPLATE_PARM_INDEX
:
24170 /* Handle expressions with type operands. */
24174 case AT_ENCODE_EXPR
:
24176 tree op
= TREE_OPERAND (*tp
, 0);
24177 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
24178 op
= TREE_TYPE (op
);
24181 if (dependent_type_p (op
))
24185 *walk_subtrees
= false;
24192 case COMPONENT_REF
:
24193 if (identifier_p (TREE_OPERAND (*tp
, 1)))
24194 /* In a template, finish_class_member_access_expr creates a
24195 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
24196 type-dependent, so that we can check access control at
24197 instantiation time (PR 42277). See also Core issue 1273. */
24202 if (instantiation_dependent_scope_ref_p (*tp
))
24207 /* Treat statement-expressions as dependent. */
24211 /* Treat requires-expressions as dependent. */
24212 case REQUIRES_EXPR
:
24216 /* Treat calls to function concepts as dependent. */
24217 if (function_concept_check_p (*tp
))
24221 case TEMPLATE_ID_EXPR
:
24222 /* And variable concepts. */
24223 if (variable_concept_p (TREE_OPERAND (*tp
, 0)))
24231 if (type_dependent_expression_p (*tp
))
24237 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
24238 sense defined by the ABI:
24240 "An expression is instantiation-dependent if it is type-dependent
24241 or value-dependent, or it has a subexpression that is type-dependent
24242 or value-dependent."
24244 Except don't actually check value-dependence for unevaluated expressions,
24245 because in sizeof(i) we don't care about the value of i. Checking
24246 type-dependence will in turn check value-dependence of array bounds/template
24247 arguments as needed. */
24250 instantiation_dependent_uneval_expression_p (tree expression
)
24254 if (!processing_template_decl
)
24257 if (expression
== error_mark_node
)
24260 result
= cp_walk_tree_without_duplicates (&expression
,
24261 instantiation_dependent_r
, NULL
);
24262 return result
!= NULL_TREE
;
24265 /* As above, but also check value-dependence of the expression as a whole. */
24268 instantiation_dependent_expression_p (tree expression
)
24270 return (instantiation_dependent_uneval_expression_p (expression
)
24271 || value_dependent_expression_p (expression
));
24274 /* Like type_dependent_expression_p, but it also works while not processing
24275 a template definition, i.e. during substitution or mangling. */
24278 type_dependent_expression_p_push (tree expr
)
24281 ++processing_template_decl
;
24282 b
= type_dependent_expression_p (expr
);
24283 --processing_template_decl
;
24287 /* Returns TRUE if ARGS contains a type-dependent expression. */
24290 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
24295 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
24297 if (type_dependent_expression_p (arg
))
24303 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
24304 expressions) contains any type-dependent expressions. */
24307 any_type_dependent_elements_p (const_tree list
)
24309 for (; list
; list
= TREE_CHAIN (list
))
24310 if (type_dependent_expression_p (TREE_VALUE (list
)))
24316 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
24317 expressions) contains any value-dependent expressions. */
24320 any_value_dependent_elements_p (const_tree list
)
24322 for (; list
; list
= TREE_CHAIN (list
))
24323 if (value_dependent_expression_p (TREE_VALUE (list
)))
24329 /* Returns TRUE if the ARG (a template argument) is dependent. */
24332 dependent_template_arg_p (tree arg
)
24334 if (!processing_template_decl
)
24337 /* Assume a template argument that was wrongly written by the user
24338 is dependent. This is consistent with what
24339 any_dependent_template_arguments_p [that calls this function]
24341 if (!arg
|| arg
== error_mark_node
)
24344 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
24345 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
24347 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
24349 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
24351 if (DECL_TEMPLATE_PARM_P (arg
))
24353 /* A member template of a dependent class is not necessarily
24354 type-dependent, but it is a dependent template argument because it
24355 will be a member of an unknown specialization to that template. */
24356 tree scope
= CP_DECL_CONTEXT (arg
);
24357 return TYPE_P (scope
) && dependent_type_p (scope
);
24359 else if (ARGUMENT_PACK_P (arg
))
24361 tree args
= ARGUMENT_PACK_ARGS (arg
);
24362 int i
, len
= TREE_VEC_LENGTH (args
);
24363 for (i
= 0; i
< len
; ++i
)
24365 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
24371 else if (TYPE_P (arg
))
24372 return dependent_type_p (arg
);
24374 return (type_dependent_expression_p (arg
)
24375 || value_dependent_expression_p (arg
));
24378 /* Returns true if ARGS (a collection of template arguments) contains
24379 any types that require structural equality testing. */
24382 any_template_arguments_need_structural_equality_p (tree args
)
24389 if (args
== error_mark_node
)
24392 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
24394 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
24395 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
24397 tree arg
= TREE_VEC_ELT (level
, j
);
24398 tree packed_args
= NULL_TREE
;
24401 if (ARGUMENT_PACK_P (arg
))
24403 /* Look inside the argument pack. */
24404 packed_args
= ARGUMENT_PACK_ARGS (arg
);
24405 len
= TREE_VEC_LENGTH (packed_args
);
24408 for (k
= 0; k
< len
; ++k
)
24411 arg
= TREE_VEC_ELT (packed_args
, k
);
24413 if (error_operand_p (arg
))
24415 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
24417 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
24419 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
24420 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
24429 /* Returns true if ARGS (a collection of template arguments) contains
24430 any dependent arguments. */
24433 any_dependent_template_arguments_p (const_tree args
)
24440 if (args
== error_mark_node
)
24443 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
24445 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
24446 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
24447 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
24454 /* Returns TRUE if the template TMPL is type-dependent. */
24457 dependent_template_p (tree tmpl
)
24459 if (TREE_CODE (tmpl
) == OVERLOAD
)
24461 for (lkp_iterator
iter (tmpl
); iter
; ++iter
)
24462 if (dependent_template_p (*iter
))
24467 /* Template template parameters are dependent. */
24468 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
24469 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
24471 /* So are names that have not been looked up. */
24472 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
24477 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
24480 dependent_template_id_p (tree tmpl
, tree args
)
24482 return (dependent_template_p (tmpl
)
24483 || any_dependent_template_arguments_p (args
));
24486 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
24490 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
24494 if (!processing_template_decl
)
24497 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
24499 tree decl
= TREE_VEC_ELT (declv
, i
);
24500 tree init
= TREE_VEC_ELT (initv
, i
);
24501 tree cond
= TREE_VEC_ELT (condv
, i
);
24502 tree incr
= TREE_VEC_ELT (incrv
, i
);
24504 if (type_dependent_expression_p (decl
)
24505 || TREE_CODE (decl
) == SCOPE_REF
)
24508 if (init
&& type_dependent_expression_p (init
))
24511 if (type_dependent_expression_p (cond
))
24514 if (COMPARISON_CLASS_P (cond
)
24515 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
24516 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
24519 if (TREE_CODE (incr
) == MODOP_EXPR
)
24521 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
24522 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
24525 else if (type_dependent_expression_p (incr
))
24527 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
24529 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
24531 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
24533 tree t
= TREE_OPERAND (incr
, 1);
24534 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
24535 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
24544 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
24545 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
24546 no such TYPE can be found. Note that this function peers inside
24547 uninstantiated templates and therefore should be used only in
24548 extremely limited situations. ONLY_CURRENT_P restricts this
24549 peering to the currently open classes hierarchy (which is required
24550 when comparing types). */
24553 resolve_typename_type (tree type
, bool only_current_p
)
24562 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
24564 scope
= TYPE_CONTEXT (type
);
24565 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
24566 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
24567 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
24568 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
24569 identifier of the TYPENAME_TYPE anymore.
24570 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
24571 TYPENAME_TYPE instead, we avoid messing up with a possible
24572 typedef variant case. */
24573 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
24575 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
24576 it first before we can figure out what NAME refers to. */
24577 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
24579 if (TYPENAME_IS_RESOLVING_P (scope
))
24580 /* Given a class template A with a dependent base with nested type C,
24581 typedef typename A::C::C C will land us here, as trying to resolve
24582 the initial A::C leads to the local C typedef, which leads back to
24583 A::C::C. So we break the recursion now. */
24586 scope
= resolve_typename_type (scope
, only_current_p
);
24588 /* If we don't know what SCOPE refers to, then we cannot resolve the
24590 if (!CLASS_TYPE_P (scope
))
24592 /* If this is a typedef, we don't want to look inside (c++/11987). */
24593 if (typedef_variant_p (type
))
24595 /* If SCOPE isn't the template itself, it will not have a valid
24596 TYPE_FIELDS list. */
24597 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
24598 /* scope is either the template itself or a compatible instantiation
24599 like X<T>, so look up the name in the original template. */
24600 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
24601 /* We shouldn't have built a TYPENAME_TYPE with a non-dependent scope. */
24602 gcc_checking_assert (uses_template_parms (scope
));
24603 /* If scope has no fields, it can't be a current instantiation. Check this
24604 before currently_open_class to avoid infinite recursion (71515). */
24605 if (!TYPE_FIELDS (scope
))
24607 /* If the SCOPE is not the current instantiation, there's no reason
24608 to look inside it. */
24609 if (only_current_p
&& !currently_open_class (scope
))
24611 /* Enter the SCOPE so that name lookup will be resolved as if we
24612 were in the class definition. In particular, SCOPE will no
24613 longer be considered a dependent type. */
24614 pushed_scope
= push_scope (scope
);
24615 /* Look up the declaration. */
24616 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
24617 tf_warning_or_error
);
24619 result
= NULL_TREE
;
24621 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
24622 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
24623 tree fullname
= TYPENAME_TYPE_FULLNAME (type
);
24626 else if (identifier_p (fullname
)
24627 && TREE_CODE (decl
) == TYPE_DECL
)
24629 result
= TREE_TYPE (decl
);
24630 if (result
== error_mark_node
)
24631 result
= NULL_TREE
;
24633 else if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
24634 && DECL_CLASS_TEMPLATE_P (decl
))
24636 /* Obtain the template and the arguments. */
24637 tree tmpl
= TREE_OPERAND (fullname
, 0);
24638 if (TREE_CODE (tmpl
) == IDENTIFIER_NODE
)
24640 /* We get here with a plain identifier because a previous tentative
24641 parse of the nested-name-specifier as part of a ptr-operator saw
24642 ::template X<A>. The use of ::template is necessary in a
24643 ptr-operator, but wrong in a declarator-id.
24645 [temp.names]: In a qualified-id of a declarator-id, the keyword
24646 template shall not appear at the top level. */
24647 pedwarn (EXPR_LOC_OR_LOC (fullname
, input_location
), OPT_Wpedantic
,
24648 "keyword %<template%> not allowed in declarator-id");
24651 tree args
= TREE_OPERAND (fullname
, 1);
24652 /* Instantiate the template. */
24653 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
24654 /*entering_scope=*/true,
24655 tf_error
| tf_user
);
24656 if (result
== error_mark_node
)
24657 result
= NULL_TREE
;
24660 /* Leave the SCOPE. */
24662 pop_scope (pushed_scope
);
24664 /* If we failed to resolve it, return the original typename. */
24668 /* If lookup found a typename type, resolve that too. */
24669 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
24671 /* Ill-formed programs can cause infinite recursion here, so we
24672 must catch that. */
24673 TYPENAME_IS_RESOLVING_P (result
) = 1;
24674 result
= resolve_typename_type (result
, only_current_p
);
24675 TYPENAME_IS_RESOLVING_P (result
) = 0;
24678 /* Qualify the resulting type. */
24679 quals
= cp_type_quals (type
);
24681 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
24686 /* EXPR is an expression which is not type-dependent. Return a proxy
24687 for EXPR that can be used to compute the types of larger
24688 expressions containing EXPR. */
24691 build_non_dependent_expr (tree expr
)
24695 /* When checking, try to get a constant value for all non-dependent
24696 expressions in order to expose bugs in *_dependent_expression_p
24697 and constexpr. This can affect code generation, see PR70704, so
24698 only do this for -fchecking=2. */
24699 if (flag_checking
> 1
24700 && cxx_dialect
>= cxx11
24701 /* Don't do this during nsdmi parsing as it can lead to
24702 unexpected recursive instantiations. */
24703 && !parsing_nsdmi ()
24704 /* Don't do this during concept expansion either and for
24705 the same reason. */
24706 && !expanding_concept ())
24707 fold_non_dependent_expr (expr
);
24709 /* Preserve OVERLOADs; the functions must be available to resolve
24712 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
24713 inner_expr
= stmt_expr_value_expr (inner_expr
);
24714 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
24715 inner_expr
= TREE_OPERAND (inner_expr
, 0);
24716 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
24717 inner_expr
= TREE_OPERAND (inner_expr
, 1);
24718 if (is_overloaded_fn (inner_expr
)
24719 || TREE_CODE (inner_expr
) == OFFSET_REF
)
24721 /* There is no need to return a proxy for a variable. */
24724 /* Preserve string constants; conversions from string constants to
24725 "char *" are allowed, even though normally a "const char *"
24726 cannot be used to initialize a "char *". */
24727 if (TREE_CODE (expr
) == STRING_CST
)
24729 /* Preserve void and arithmetic constants, as an optimization -- there is no
24730 reason to create a new node. */
24731 if (TREE_CODE (expr
) == VOID_CST
24732 || TREE_CODE (expr
) == INTEGER_CST
24733 || TREE_CODE (expr
) == REAL_CST
)
24735 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
24736 There is at least one place where we want to know that a
24737 particular expression is a throw-expression: when checking a ?:
24738 expression, there are special rules if the second or third
24739 argument is a throw-expression. */
24740 if (TREE_CODE (expr
) == THROW_EXPR
)
24743 /* Don't wrap an initializer list, we need to be able to look inside. */
24744 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
24747 /* Don't wrap a dummy object, we need to be able to test for it. */
24748 if (is_dummy_object (expr
))
24751 if (TREE_CODE (expr
) == COND_EXPR
)
24752 return build3 (COND_EXPR
,
24754 TREE_OPERAND (expr
, 0),
24755 (TREE_OPERAND (expr
, 1)
24756 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
24757 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
24758 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
24759 if (TREE_CODE (expr
) == COMPOUND_EXPR
24760 && !COMPOUND_EXPR_OVERLOADED (expr
))
24761 return build2 (COMPOUND_EXPR
,
24763 TREE_OPERAND (expr
, 0),
24764 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
24766 /* If the type is unknown, it can't really be non-dependent */
24767 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
24769 /* Otherwise, build a NON_DEPENDENT_EXPR. */
24770 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
24773 /* ARGS is a vector of expressions as arguments to a function call.
24774 Replace the arguments with equivalent non-dependent expressions.
24775 This modifies ARGS in place. */
24778 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
24783 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
24785 tree newarg
= build_non_dependent_expr (arg
);
24787 (*args
)[ix
] = newarg
;
24791 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
24792 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
24793 parms. If set_canonical is true, we set TYPE_CANONICAL on it. */
24796 make_auto_1 (tree name
, bool set_canonical
)
24798 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
24799 TYPE_NAME (au
) = build_decl (input_location
,
24800 TYPE_DECL
, name
, au
);
24801 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
24802 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
24803 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
24804 TYPE_NAME (au
), NULL_TREE
);
24806 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
24807 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
24808 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
24814 make_decltype_auto (void)
24816 return make_auto_1 (decltype_auto_identifier
, true);
24822 return make_auto_1 (auto_identifier
, true);
24825 /* Return a C++17 deduction placeholder for class template TMPL. */
24828 make_template_placeholder (tree tmpl
)
24830 tree t
= make_auto_1 (DECL_NAME (tmpl
), true);
24831 CLASS_PLACEHOLDER_TEMPLATE (t
) = tmpl
;
24835 /* True iff T is a C++17 class template deduction placeholder. */
24838 template_placeholder_p (tree t
)
24840 return is_auto (t
) && CLASS_PLACEHOLDER_TEMPLATE (t
);
24843 /* Make a "constrained auto" type-specifier. This is an
24844 auto type with constraints that must be associated after
24845 deduction. The constraint is formed from the given
24846 CONC and its optional sequence of arguments, which are
24847 non-null if written as partial-concept-id. */
24850 make_constrained_auto (tree con
, tree args
)
24852 tree type
= make_auto_1 (auto_identifier
, false);
24854 /* Build the constraint. */
24855 tree tmpl
= DECL_TI_TEMPLATE (con
);
24856 tree expr
= VAR_P (con
) ? tmpl
: ovl_make (tmpl
);
24857 expr
= build_concept_check (expr
, type
, args
);
24859 tree constr
= normalize_expression (expr
);
24860 PLACEHOLDER_TYPE_CONSTRAINTS (type
) = constr
;
24862 /* Our canonical type depends on the constraint. */
24863 TYPE_CANONICAL (type
) = canonical_type_parameter (type
);
24865 /* Attach the constraint to the type declaration. */
24866 tree decl
= TYPE_NAME (type
);
24870 /* Given type ARG, return std::initializer_list<ARG>. */
24875 tree std_init_list
= get_namespace_binding (std_node
, init_list_identifier
);
24877 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
24879 gcc_rich_location
richloc (input_location
);
24880 maybe_add_include_fixit (&richloc
, "<initializer_list>");
24881 error_at_rich_loc (&richloc
,
24882 "deducing from brace-enclosed initializer list"
24883 " requires #include <initializer_list>");
24885 return error_mark_node
;
24887 tree argvec
= make_tree_vec (1);
24888 TREE_VEC_ELT (argvec
, 0) = arg
;
24890 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
24891 NULL_TREE
, 0, tf_warning_or_error
);
24894 /* Replace auto in TYPE with std::initializer_list<auto>. */
24897 listify_autos (tree type
, tree auto_node
)
24899 tree init_auto
= listify (auto_node
);
24900 tree argvec
= make_tree_vec (1);
24901 TREE_VEC_ELT (argvec
, 0) = init_auto
;
24902 if (processing_template_decl
)
24903 argvec
= add_to_template_args (current_template_args (), argvec
);
24904 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
24907 /* Hash traits for hashing possibly constrained 'auto'
24908 TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
24910 struct auto_hash
: default_hash_traits
<tree
>
24912 static inline hashval_t
hash (tree
);
24913 static inline bool equal (tree
, tree
);
24916 /* Hash the 'auto' T. */
24919 auto_hash::hash (tree t
)
24921 if (tree c
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
24922 /* Matching constrained-type-specifiers denote the same template
24923 parameter, so hash the constraint. */
24924 return hash_placeholder_constraint (c
);
24926 /* But unconstrained autos are all separate, so just hash the pointer. */
24927 return iterative_hash_object (t
, 0);
24930 /* Compare two 'auto's. */
24933 auto_hash::equal (tree t1
, tree t2
)
24938 tree c1
= PLACEHOLDER_TYPE_CONSTRAINTS (t1
);
24939 tree c2
= PLACEHOLDER_TYPE_CONSTRAINTS (t2
);
24941 /* Two unconstrained autos are distinct. */
24945 return equivalent_placeholder_constraints (c1
, c2
);
24948 /* for_each_template_parm callback for extract_autos: if t is a (possibly
24949 constrained) auto, add it to the vector. */
24952 extract_autos_r (tree t
, void *data
)
24954 hash_table
<auto_hash
> &hash
= *(hash_table
<auto_hash
>*)data
;
24957 /* All the autos were built with index 0; fix that up now. */
24958 tree
*p
= hash
.find_slot (t
, INSERT
);
24961 /* If this is a repeated constrained-type-specifier, use the index we
24963 idx
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (*p
));
24966 /* Otherwise this is new, so use the current count. */
24968 idx
= hash
.elements () - 1;
24970 TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (t
)) = idx
;
24973 /* Always keep walking. */
24977 /* Return a TREE_VEC of the 'auto's used in type under the Concepts TS, which
24978 says they can appear anywhere in the type. */
24981 extract_autos (tree type
)
24983 hash_set
<tree
> visited
;
24984 hash_table
<auto_hash
> hash (2);
24986 for_each_template_parm (type
, extract_autos_r
, &hash
, &visited
, true);
24988 tree tree_vec
= make_tree_vec (hash
.elements());
24989 for (hash_table
<auto_hash
>::iterator iter
= hash
.begin();
24990 iter
!= hash
.end(); ++iter
)
24993 unsigned i
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (elt
));
24994 TREE_VEC_ELT (tree_vec
, i
)
24995 = build_tree_list (NULL_TREE
, TYPE_NAME (elt
));
25001 /* The stem for deduction guide names. */
25002 const char *const dguide_base
= "__dguide_";
25004 /* Return the name for a deduction guide for class template TMPL. */
25007 dguide_name (tree tmpl
)
25009 tree type
= (TYPE_P (tmpl
) ? tmpl
: TREE_TYPE (tmpl
));
25010 tree tname
= TYPE_IDENTIFIER (type
);
25011 char *buf
= (char *) alloca (1 + strlen (dguide_base
)
25012 + IDENTIFIER_LENGTH (tname
));
25013 memcpy (buf
, dguide_base
, strlen (dguide_base
));
25014 memcpy (buf
+ strlen (dguide_base
), IDENTIFIER_POINTER (tname
),
25015 IDENTIFIER_LENGTH (tname
) + 1);
25016 tree dname
= get_identifier (buf
);
25017 TREE_TYPE (dname
) = type
;
25021 /* True if NAME is the name of a deduction guide. */
25024 dguide_name_p (tree name
)
25026 return (TREE_TYPE (name
)
25027 && !strncmp (IDENTIFIER_POINTER (name
), dguide_base
,
25028 strlen (dguide_base
)));
25031 /* True if FN is a deduction guide. */
25034 deduction_guide_p (const_tree fn
)
25037 if (tree name
= DECL_NAME (fn
))
25038 return dguide_name_p (name
);
25042 /* True if FN is the copy deduction guide, i.e. A(A)->A. */
25045 copy_guide_p (const_tree fn
)
25047 gcc_assert (deduction_guide_p (fn
));
25048 if (!DECL_ARTIFICIAL (fn
))
25050 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (DECL_TI_TEMPLATE (fn
));
25051 return (TREE_CHAIN (parms
) == void_list_node
25052 && same_type_p (TREE_VALUE (parms
), TREE_TYPE (DECL_NAME (fn
))));
25055 /* True if FN is a guide generated from a constructor template. */
25058 template_guide_p (const_tree fn
)
25060 gcc_assert (deduction_guide_p (fn
));
25061 if (!DECL_ARTIFICIAL (fn
))
25063 if (tree ctor
= DECL_ABSTRACT_ORIGIN (fn
))
25065 tree tmpl
= DECL_TI_TEMPLATE (ctor
);
25066 return PRIMARY_TEMPLATE_P (tmpl
);
25071 /* OLDDECL is a _DECL for a template parameter. Return a similar parameter at
25072 LEVEL:INDEX, using tsubst_args and complain for substitution into non-type
25073 template parameter types. Note that the handling of template template
25074 parameters relies on current_template_parms being set appropriately for the
25078 rewrite_template_parm (tree olddecl
, unsigned index
, unsigned level
,
25079 tree tsubst_args
, tsubst_flags_t complain
)
25081 tree oldidx
= get_template_parm_index (olddecl
);
25084 if (TREE_CODE (olddecl
) == TYPE_DECL
25085 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
25087 tree oldtype
= TREE_TYPE (olddecl
);
25088 newtype
= cxx_make_type (TREE_CODE (oldtype
));
25089 TYPE_MAIN_VARIANT (newtype
) = newtype
;
25090 if (TREE_CODE (oldtype
) == TEMPLATE_TYPE_PARM
)
25091 TEMPLATE_TYPE_PARM_FOR_CLASS (newtype
)
25092 = TEMPLATE_TYPE_PARM_FOR_CLASS (oldtype
);
25095 newtype
= tsubst (TREE_TYPE (olddecl
), tsubst_args
,
25096 complain
, NULL_TREE
);
25099 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TREE_CODE (olddecl
),
25100 DECL_NAME (olddecl
), newtype
);
25101 SET_DECL_TEMPLATE_PARM_P (newdecl
);
25104 if (TREE_CODE (olddecl
) == TYPE_DECL
25105 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
25107 newidx
= TEMPLATE_TYPE_PARM_INDEX (newtype
)
25108 = build_template_parm_index (index
, level
, level
,
25110 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
25111 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
25112 TYPE_STUB_DECL (newtype
) = TYPE_NAME (newtype
) = newdecl
;
25113 TYPE_CANONICAL (newtype
) = canonical_type_parameter (newtype
);
25115 if (TREE_CODE (olddecl
) == TEMPLATE_DECL
)
25117 DECL_TEMPLATE_RESULT (newdecl
)
25118 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TYPE_DECL
,
25119 DECL_NAME (olddecl
), newtype
);
25120 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (newdecl
)) = true;
25121 // First create a copy (ttargs) of tsubst_args with an
25122 // additional level for the template template parameter's own
25123 // template parameters (ttparms).
25124 tree ttparms
= (INNERMOST_TEMPLATE_PARMS
25125 (DECL_TEMPLATE_PARMS (olddecl
)));
25126 const int depth
= TMPL_ARGS_DEPTH (tsubst_args
);
25127 tree ttargs
= make_tree_vec (depth
+ 1);
25128 for (int i
= 0; i
< depth
; ++i
)
25129 TREE_VEC_ELT (ttargs
, i
) = TREE_VEC_ELT (tsubst_args
, i
);
25130 TREE_VEC_ELT (ttargs
, depth
)
25131 = template_parms_level_to_args (ttparms
);
25132 // Substitute ttargs into ttparms to fix references to
25133 // other template parameters.
25134 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
25136 // Now substitute again with args based on tparms, to reduce
25137 // the level of the ttparms.
25138 ttargs
= current_template_args ();
25139 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
25141 // Finally, tack the adjusted parms onto tparms.
25142 ttparms
= tree_cons (size_int (depth
), ttparms
,
25143 current_template_parms
);
25144 DECL_TEMPLATE_PARMS (newdecl
) = ttparms
;
25149 tree oldconst
= TEMPLATE_PARM_DECL (oldidx
);
25151 = build_decl (DECL_SOURCE_LOCATION (oldconst
),
25152 TREE_CODE (oldconst
),
25153 DECL_NAME (oldconst
), newtype
);
25154 TREE_CONSTANT (newconst
) = TREE_CONSTANT (newdecl
)
25155 = TREE_READONLY (newconst
) = TREE_READONLY (newdecl
) = true;
25156 SET_DECL_TEMPLATE_PARM_P (newconst
);
25157 newidx
= build_template_parm_index (index
, level
, level
,
25158 newconst
, newtype
);
25159 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
25160 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
25161 DECL_INITIAL (newdecl
) = DECL_INITIAL (newconst
) = newidx
;
25167 /* Returns a C++17 class deduction guide template based on the constructor
25168 CTOR. As a special case, CTOR can be a RECORD_TYPE for an implicit default
25169 guide, or REFERENCE_TYPE for an implicit copy/move guide. */
25172 build_deduction_guide (tree ctor
, tree outer_args
, tsubst_flags_t complain
)
25174 tree type
, tparms
, targs
, fparms
, fargs
, ci
;
25175 bool memtmpl
= false;
25182 bool copy_p
= TREE_CODE (type
) == REFERENCE_TYPE
;
25185 type
= TREE_TYPE (type
);
25186 fparms
= tree_cons (NULL_TREE
, type
, void_list_node
);
25189 fparms
= void_list_node
;
25191 tree ctmpl
= CLASSTYPE_TI_TEMPLATE (type
);
25192 tparms
= DECL_TEMPLATE_PARMS (ctmpl
);
25193 targs
= CLASSTYPE_TI_ARGS (type
);
25196 loc
= DECL_SOURCE_LOCATION (ctmpl
);
25197 explicit_p
= false;
25201 ++processing_template_decl
;
25204 = (TREE_CODE (ctor
) == TEMPLATE_DECL
? ctor
25205 : DECL_TI_TEMPLATE (ctor
));
25207 fn_tmpl
= tsubst (fn_tmpl
, outer_args
, complain
, ctor
);
25208 ctor
= DECL_TEMPLATE_RESULT (fn_tmpl
);
25210 type
= DECL_CONTEXT (ctor
);
25212 tparms
= DECL_TEMPLATE_PARMS (fn_tmpl
);
25213 /* If type is a member class template, DECL_TI_ARGS (ctor) will have
25214 fully specialized args for the enclosing class. Strip those off, as
25215 the deduction guide won't have those template parameters. */
25216 targs
= get_innermost_template_args (DECL_TI_ARGS (ctor
),
25217 TMPL_PARMS_DEPTH (tparms
));
25218 /* Discard the 'this' parameter. */
25219 fparms
= FUNCTION_ARG_CHAIN (ctor
);
25220 fargs
= TREE_CHAIN (DECL_ARGUMENTS (ctor
));
25221 ci
= get_constraints (ctor
);
25222 loc
= DECL_SOURCE_LOCATION (ctor
);
25223 explicit_p
= DECL_NONCONVERTING_P (ctor
);
25225 if (PRIMARY_TEMPLATE_P (fn_tmpl
))
25229 /* For a member template constructor, we need to flatten the two
25230 template parameter lists into one, and then adjust the function
25231 signature accordingly. This gets...complicated. */
25232 tree save_parms
= current_template_parms
;
25234 /* For a member template we should have two levels of parms/args, one
25235 for the class and one for the constructor. We stripped
25236 specialized args for further enclosing classes above. */
25237 const int depth
= 2;
25238 gcc_assert (TMPL_ARGS_DEPTH (targs
) == depth
);
25240 /* Template args for translating references to the two-level template
25241 parameters into references to the one-level template parameters we
25243 tree tsubst_args
= copy_node (targs
);
25244 TMPL_ARGS_LEVEL (tsubst_args
, depth
)
25245 = copy_node (TMPL_ARGS_LEVEL (tsubst_args
, depth
));
25247 /* Template parms for the constructor template. */
25248 tree ftparms
= TREE_VALUE (tparms
);
25249 unsigned flen
= TREE_VEC_LENGTH (ftparms
);
25250 /* Template parms for the class template. */
25251 tparms
= TREE_CHAIN (tparms
);
25252 tree ctparms
= TREE_VALUE (tparms
);
25253 unsigned clen
= TREE_VEC_LENGTH (ctparms
);
25254 /* Template parms for the deduction guide start as a copy of the
25255 template parms for the class. We set current_template_parms for
25256 lookup_template_class_1. */
25257 current_template_parms
= tparms
= copy_node (tparms
);
25258 tree new_vec
= TREE_VALUE (tparms
) = make_tree_vec (flen
+ clen
);
25259 for (unsigned i
= 0; i
< clen
; ++i
)
25260 TREE_VEC_ELT (new_vec
, i
) = TREE_VEC_ELT (ctparms
, i
);
25262 /* Now we need to rewrite the constructor parms to append them to the
25264 for (unsigned i
= 0; i
< flen
; ++i
)
25266 unsigned index
= i
+ clen
;
25267 unsigned level
= 1;
25268 tree oldelt
= TREE_VEC_ELT (ftparms
, i
);
25269 tree olddecl
= TREE_VALUE (oldelt
);
25270 tree newdecl
= rewrite_template_parm (olddecl
, index
, level
,
25271 tsubst_args
, complain
);
25272 tree newdef
= tsubst_template_arg (TREE_PURPOSE (oldelt
),
25273 tsubst_args
, complain
, ctor
);
25274 tree list
= build_tree_list (newdef
, newdecl
);
25275 TEMPLATE_PARM_CONSTRAINTS (list
)
25276 = tsubst_constraint_info (TEMPLATE_PARM_CONSTRAINTS (oldelt
),
25277 tsubst_args
, complain
, ctor
);
25278 TREE_VEC_ELT (new_vec
, index
) = list
;
25279 TMPL_ARG (tsubst_args
, depth
, i
) = template_parm_to_arg (list
);
25282 /* Now we have a final set of template parms to substitute into the
25283 function signature. */
25284 targs
= template_parms_to_args (tparms
);
25285 fparms
= tsubst_arg_types (fparms
, tsubst_args
, NULL_TREE
,
25287 fargs
= tsubst (fargs
, tsubst_args
, complain
, ctor
);
25289 ci
= tsubst_constraint_info (ci
, tsubst_args
, complain
, ctor
);
25291 current_template_parms
= save_parms
;
25293 --processing_template_decl
;
25298 /* Copy the parms so we can set DECL_PRIMARY_TEMPLATE. */
25299 tparms
= copy_node (tparms
);
25300 INNERMOST_TEMPLATE_PARMS (tparms
)
25301 = copy_node (INNERMOST_TEMPLATE_PARMS (tparms
));
25304 tree fntype
= build_function_type (type
, fparms
);
25305 tree ded_fn
= build_lang_decl_loc (loc
,
25307 dguide_name (type
), fntype
);
25308 DECL_ARGUMENTS (ded_fn
) = fargs
;
25309 DECL_ARTIFICIAL (ded_fn
) = true;
25310 DECL_NONCONVERTING_P (ded_fn
) = explicit_p
;
25311 tree ded_tmpl
= build_template_decl (ded_fn
, tparms
, /*member*/false);
25312 DECL_ARTIFICIAL (ded_tmpl
) = true;
25313 DECL_TEMPLATE_RESULT (ded_tmpl
) = ded_fn
;
25314 TREE_TYPE (ded_tmpl
) = TREE_TYPE (ded_fn
);
25315 DECL_TEMPLATE_INFO (ded_fn
) = build_template_info (ded_tmpl
, targs
);
25316 DECL_PRIMARY_TEMPLATE (ded_tmpl
) = ded_tmpl
;
25318 DECL_ABSTRACT_ORIGIN (ded_fn
) = ctor
;
25320 set_constraints (ded_tmpl
, ci
);
25325 /* Deduce template arguments for the class template placeholder PTYPE for
25326 template TMPL based on the initializer INIT, and return the resulting
25330 do_class_deduction (tree ptype
, tree tmpl
, tree init
, int flags
,
25331 tsubst_flags_t complain
)
25333 if (!DECL_CLASS_TEMPLATE_P (tmpl
))
25335 /* We should have handled this in the caller. */
25336 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
))
25338 if (complain
& tf_error
)
25339 error ("non-class template %qT used without template arguments", tmpl
);
25340 return error_mark_node
;
25343 tree type
= TREE_TYPE (tmpl
);
25345 bool try_list_ctor
= false;
25347 vec
<tree
,va_gc
> *args
;
25348 if (init
== NULL_TREE
25349 || TREE_CODE (init
) == TREE_LIST
)
25350 args
= make_tree_vector_from_list (init
);
25351 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
25353 try_list_ctor
= TYPE_HAS_LIST_CTOR (type
);
25354 if (try_list_ctor
&& CONSTRUCTOR_NELTS (init
) == 1)
25356 /* As an exception, the first phase in 16.3.1.7 (considering the
25357 initializer list as a single argument) is omitted if the
25358 initializer list consists of a single expression of type cv U,
25359 where U is a specialization of C or a class derived from a
25360 specialization of C. */
25361 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
25362 tree etype
= TREE_TYPE (elt
);
25364 tree tparms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
25365 tree targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
25366 int err
= unify (tparms
, targs
, type
, etype
,
25367 UNIFY_ALLOW_DERIVED
, /*explain*/false);
25369 try_list_ctor
= false;
25372 if (try_list_ctor
|| is_std_init_list (type
))
25373 args
= make_tree_vector_single (init
);
25375 args
= make_tree_vector_from_ctor (init
);
25378 args
= make_tree_vector_single (init
);
25380 tree dname
= dguide_name (tmpl
);
25381 tree cands
= lookup_qualified_name (CP_DECL_CONTEXT (tmpl
), dname
,
25382 /*type*/false, /*complain*/false,
25384 bool elided
= false;
25385 if (cands
== error_mark_node
)
25388 /* Prune explicit deduction guides in copy-initialization context. */
25389 if (flags
& LOOKUP_ONLYCONVERTING
)
25391 for (lkp_iterator
iter (cands
); !elided
&& iter
; ++iter
)
25392 if (DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
25397 /* Found a nonconverting guide, prune the candidates. */
25398 tree pruned
= NULL_TREE
;
25399 for (lkp_iterator
iter (cands
); iter
; ++iter
)
25400 if (!DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
25401 pruned
= lookup_add (*iter
, pruned
);
25407 tree outer_args
= NULL_TREE
;
25408 if (DECL_CLASS_SCOPE_P (tmpl
)
25409 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (tmpl
)))
25411 outer_args
= CLASSTYPE_TI_ARGS (DECL_CONTEXT (tmpl
));
25412 type
= TREE_TYPE (most_general_template (tmpl
));
25415 bool saw_ctor
= false;
25416 if (CLASSTYPE_METHOD_VEC (type
))
25417 // FIXME cache artificial deduction guides
25418 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (type
));
25421 tree guide
= build_deduction_guide (*iter
, outer_args
, complain
);
25422 if ((flags
& LOOKUP_ONLYCONVERTING
)
25423 && DECL_NONCONVERTING_P (STRIP_TEMPLATE (guide
)))
25426 cands
= lookup_add (guide
, cands
);
25431 tree call
= error_mark_node
;
25433 /* If this is list-initialization and the class has a list constructor, first
25434 try deducing from the list as a single argument, as [over.match.list]. */
25435 tree list_cands
= NULL_TREE
;
25436 if (try_list_ctor
&& cands
)
25437 for (lkp_iterator
iter (cands
); iter
; ++iter
)
25440 if (is_list_ctor (dg
))
25441 list_cands
= lookup_add (dg
, list_cands
);
25445 ++cp_unevaluated_operand
;
25446 call
= build_new_function_call (list_cands
, &args
, tf_decltype
);
25447 --cp_unevaluated_operand
;
25449 if (call
== error_mark_node
)
25451 /* That didn't work, now try treating the list as a sequence of
25453 release_tree_vector (args
);
25454 args
= make_tree_vector_from_ctor (init
);
25458 /* Maybe generate an implicit deduction guide. */
25459 if (call
== error_mark_node
&& args
->length () < 2)
25461 tree gtype
= NULL_TREE
;
25463 if (args
->length () == 1)
25464 /* Generate a copy guide. */
25465 gtype
= build_reference_type (type
);
25466 else if (!saw_ctor
)
25467 /* Generate a default guide. */
25472 tree guide
= build_deduction_guide (gtype
, outer_args
, complain
);
25473 cands
= lookup_add (guide
, cands
);
25477 if (elided
&& !cands
)
25479 error ("cannot deduce template arguments for copy-initialization"
25480 " of %qT, as it has no non-explicit deduction guides or "
25481 "user-declared constructors", type
);
25482 return error_mark_node
;
25484 else if (!cands
&& call
== error_mark_node
)
25486 error ("cannot deduce template arguments of %qT, as it has no viable "
25487 "deduction guides", type
);
25488 return error_mark_node
;
25491 if (call
== error_mark_node
)
25493 ++cp_unevaluated_operand
;
25494 call
= build_new_function_call (cands
, &args
, tf_decltype
);
25495 --cp_unevaluated_operand
;
25498 if (call
== error_mark_node
&& (complain
& tf_warning_or_error
))
25500 error ("class template argument deduction failed:");
25502 ++cp_unevaluated_operand
;
25503 call
= build_new_function_call (cands
, &args
, complain
| tf_decltype
);
25504 --cp_unevaluated_operand
;
25507 inform (input_location
, "explicit deduction guides not considered "
25508 "for copy-initialization");
25511 release_tree_vector (args
);
25513 return cp_build_qualified_type (TREE_TYPE (call
), cp_type_quals (ptype
));
25516 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
25517 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
25520 do_auto_deduction (tree type
, tree init
, tree auto_node
)
25522 return do_auto_deduction (type
, init
, auto_node
,
25523 tf_warning_or_error
,
25527 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
25528 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
25529 The CONTEXT determines the context in which auto deduction is performed
25530 and is used to control error diagnostics. FLAGS are the LOOKUP_* flags.
25531 OUTER_TARGS are used during template argument deduction
25532 (context == adc_unify) to properly substitute the result, and is ignored
25535 For partial-concept-ids, extra args may be appended to the list of deduced
25536 template arguments prior to determining constraint satisfaction. */
25539 do_auto_deduction (tree type
, tree init
, tree auto_node
,
25540 tsubst_flags_t complain
, auto_deduction_context context
,
25541 tree outer_targs
, int flags
)
25545 if (init
== error_mark_node
)
25546 return error_mark_node
;
25548 if (init
&& type_dependent_expression_p (init
)
25549 && context
!= adc_unify
)
25550 /* Defining a subset of type-dependent expressions that we can deduce
25551 from ahead of time isn't worth the trouble. */
25554 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
25555 /* C++17 class template argument deduction. */
25556 return do_class_deduction (type
, tmpl
, init
, flags
, complain
);
25558 if (TREE_TYPE (init
) == NULL_TREE
)
25559 /* Nothing we can do with this, even in deduction context. */
25562 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
25563 with either a new invented type template parameter U or, if the
25564 initializer is a braced-init-list (8.5.4), with
25565 std::initializer_list<U>. */
25566 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
25568 if (!DIRECT_LIST_INIT_P (init
))
25569 type
= listify_autos (type
, auto_node
);
25570 else if (CONSTRUCTOR_NELTS (init
) == 1)
25571 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
25574 if (complain
& tf_warning_or_error
)
25576 if (permerror (input_location
, "direct-list-initialization of "
25577 "%<auto%> requires exactly one element"))
25578 inform (input_location
,
25579 "for deduction to %<std::initializer_list%>, use copy-"
25580 "list-initialization (i.e. add %<=%> before the %<{%>)");
25582 type
= listify_autos (type
, auto_node
);
25586 if (type
== error_mark_node
)
25587 return error_mark_node
;
25589 init
= resolve_nondeduced_context (init
, complain
);
25591 if (context
== adc_decomp_type
25592 && auto_node
== type
25593 && init
!= error_mark_node
25594 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
25595 /* [dcl.decomp]/1 - if decomposition declaration has no ref-qualifiers
25596 and initializer has array type, deduce cv-qualified array type. */
25597 return cp_build_qualified_type_real (TREE_TYPE (init
), TYPE_QUALS (type
),
25599 else if (AUTO_IS_DECLTYPE (auto_node
))
25601 bool id
= (DECL_P (init
)
25602 || ((TREE_CODE (init
) == COMPONENT_REF
25603 || TREE_CODE (init
) == SCOPE_REF
)
25604 && !REF_PARENTHESIZED_P (init
)));
25605 targs
= make_tree_vec (1);
25606 TREE_VEC_ELT (targs
, 0)
25607 = finish_decltype_type (init
, id
, tf_warning_or_error
);
25608 if (type
!= auto_node
)
25610 if (complain
& tf_error
)
25611 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
25612 return error_mark_node
;
25617 tree parms
= build_tree_list (NULL_TREE
, type
);
25621 tparms
= extract_autos (type
);
25624 tparms
= make_tree_vec (1);
25625 TREE_VEC_ELT (tparms
, 0)
25626 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
25629 targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
25630 int val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
25631 DEDUCE_CALL
, LOOKUP_NORMAL
,
25632 NULL
, /*explain_p=*/false);
25635 if (processing_template_decl
)
25636 /* Try again at instantiation time. */
25638 if (type
&& type
!= error_mark_node
25639 && (complain
& tf_error
))
25640 /* If type is error_mark_node a diagnostic must have been
25641 emitted by now. Also, having a mention to '<type error>'
25642 in the diagnostic is not really useful to the user. */
25644 if (cfun
&& auto_node
== current_function_auto_return_pattern
25645 && LAMBDA_FUNCTION_P (current_function_decl
))
25646 error ("unable to deduce lambda return type from %qE", init
);
25648 error ("unable to deduce %qT from %qE", type
, init
);
25649 type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
25650 DEDUCE_CALL
, LOOKUP_NORMAL
,
25651 NULL
, /*explain_p=*/true);
25653 return error_mark_node
;
25657 /* Check any placeholder constraints against the deduced type. */
25658 if (flag_concepts
&& !processing_template_decl
)
25659 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (auto_node
))
25661 /* Use the deduced type to check the associated constraints. If we
25662 have a partial-concept-id, rebuild the argument list so that
25663 we check using the extra arguments. */
25664 gcc_assert (TREE_CODE (constr
) == CHECK_CONSTR
);
25665 tree cargs
= CHECK_CONSTR_ARGS (constr
);
25666 if (TREE_VEC_LENGTH (cargs
) > 1)
25668 cargs
= copy_node (cargs
);
25669 TREE_VEC_ELT (cargs
, 0) = TREE_VEC_ELT (targs
, 0);
25673 if (!constraints_satisfied_p (constr
, cargs
))
25675 if (complain
& tf_warning_or_error
)
25679 case adc_unspecified
:
25681 error("placeholder constraints not satisfied");
25683 case adc_variable_type
:
25684 case adc_decomp_type
:
25685 error ("deduced initializer does not satisfy "
25686 "placeholder constraints");
25688 case adc_return_type
:
25689 error ("deduced return type does not satisfy "
25690 "placeholder constraints");
25692 case adc_requirement
:
25693 error ("deduced expression type does not satisfy "
25694 "placeholder constraints");
25697 diagnose_constraints (input_location
, constr
, targs
);
25699 return error_mark_node
;
25703 if (processing_template_decl
&& context
!= adc_unify
)
25704 outer_targs
= current_template_args ();
25705 targs
= add_to_template_args (outer_targs
, targs
);
25706 return tsubst (type
, targs
, complain
, NULL_TREE
);
25709 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
25713 splice_late_return_type (tree type
, tree late_return_type
)
25715 if (is_auto (type
))
25717 if (late_return_type
)
25718 return late_return_type
;
25720 tree idx
= get_template_parm_index (type
);
25721 if (TEMPLATE_PARM_LEVEL (idx
) <= processing_template_decl
)
25722 /* In an abbreviated function template we didn't know we were dealing
25723 with a function template when we saw the auto return type, so update
25724 it to have the correct level. */
25725 return make_auto_1 (TYPE_IDENTIFIER (type
), true);
25730 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
25731 'decltype(auto)' or a deduced class template. */
25734 is_auto (const_tree type
)
25736 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
25737 && (TYPE_IDENTIFIER (type
) == auto_identifier
25738 || TYPE_IDENTIFIER (type
) == decltype_auto_identifier
25739 || CLASS_PLACEHOLDER_TEMPLATE (type
)))
25745 /* for_each_template_parm callback for type_uses_auto. */
25748 is_auto_r (tree tp
, void */
*data*/
)
25750 return is_auto (tp
);
25753 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
25754 a use of `auto'. Returns NULL_TREE otherwise. */
25757 type_uses_auto (tree type
)
25759 if (type
== NULL_TREE
)
25761 else if (flag_concepts
)
25763 /* The Concepts TS allows multiple autos in one type-specifier; just
25764 return the first one we find, do_auto_deduction will collect all of
25766 if (uses_template_parms (type
))
25767 return for_each_template_parm (type
, is_auto_r
, /*data*/NULL
,
25768 /*visited*/NULL
, /*nondeduced*/true);
25773 return find_type_usage (type
, is_auto
);
25776 /* For a given template T, return the vector of typedefs referenced
25777 in T for which access check is needed at T instantiation time.
25778 T is either a FUNCTION_DECL or a RECORD_TYPE.
25779 Those typedefs were added to T by the function
25780 append_type_to_template_for_access_check. */
25782 vec
<qualified_typedef_usage_t
, va_gc
> *
25783 get_types_needing_access_check (tree t
)
25786 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
25788 if (!t
|| t
== error_mark_node
)
25791 if (!(ti
= get_template_info (t
)))
25794 if (CLASS_TYPE_P (t
)
25795 || TREE_CODE (t
) == FUNCTION_DECL
)
25797 if (!TI_TEMPLATE (ti
))
25800 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
25806 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
25807 tied to T. That list of typedefs will be access checked at
25808 T instantiation time.
25809 T is either a FUNCTION_DECL or a RECORD_TYPE.
25810 TYPE_DECL is a TYPE_DECL node representing a typedef.
25811 SCOPE is the scope through which TYPE_DECL is accessed.
25812 LOCATION is the location of the usage point of TYPE_DECL.
25814 This function is a subroutine of
25815 append_type_to_template_for_access_check. */
25818 append_type_to_template_for_access_check_1 (tree t
,
25821 location_t location
)
25823 qualified_typedef_usage_t typedef_usage
;
25826 if (!t
|| t
== error_mark_node
)
25829 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
25830 || CLASS_TYPE_P (t
))
25832 && TREE_CODE (type_decl
) == TYPE_DECL
25835 if (!(ti
= get_template_info (t
)))
25838 gcc_assert (TI_TEMPLATE (ti
));
25840 typedef_usage
.typedef_decl
= type_decl
;
25841 typedef_usage
.context
= scope
;
25842 typedef_usage
.locus
= location
;
25844 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
25847 /* Append TYPE_DECL to the template TEMPL.
25848 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
25849 At TEMPL instanciation time, TYPE_DECL will be checked to see
25850 if it can be accessed through SCOPE.
25851 LOCATION is the location of the usage point of TYPE_DECL.
25853 e.g. consider the following code snippet:
25860 template<class U> struct S
25862 C::myint mi; // <-- usage point of the typedef C::myint
25867 At S<char> instantiation time, we need to check the access of C::myint
25868 In other words, we need to check the access of the myint typedef through
25869 the C scope. For that purpose, this function will add the myint typedef
25870 and the scope C through which its being accessed to a list of typedefs
25871 tied to the template S. That list will be walked at template instantiation
25872 time and access check performed on each typedefs it contains.
25873 Note that this particular code snippet should yield an error because
25874 myint is private to C. */
25877 append_type_to_template_for_access_check (tree templ
,
25880 location_t location
)
25882 qualified_typedef_usage_t
*iter
;
25885 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
25887 /* Make sure we don't append the type to the template twice. */
25888 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
25889 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
25892 append_type_to_template_for_access_check_1 (templ
, type_decl
,
25896 /* Convert the generic type parameters in PARM that match the types given in the
25897 range [START_IDX, END_IDX) from the current_template_parms into generic type
25901 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
25903 tree current
= current_template_parms
;
25904 int depth
= TMPL_PARMS_DEPTH (current
);
25905 current
= INNERMOST_TEMPLATE_PARMS (current
);
25906 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
25908 for (int i
= 0; i
< start_idx
; ++i
)
25909 TREE_VEC_ELT (replacement
, i
)
25910 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
25912 for (int i
= start_idx
; i
< end_idx
; ++i
)
25914 /* Create a distinct parameter pack type from the current parm and add it
25915 to the replacement args to tsubst below into the generic function
25918 tree o
= TREE_TYPE (TREE_VALUE
25919 (TREE_VEC_ELT (current
, i
)));
25920 tree t
= copy_type (o
);
25921 TEMPLATE_TYPE_PARM_INDEX (t
)
25922 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
25924 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
25925 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
25926 TYPE_MAIN_VARIANT (t
) = t
;
25927 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
25928 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
25929 TREE_VEC_ELT (replacement
, i
) = t
;
25930 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
25933 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
25934 TREE_VEC_ELT (replacement
, i
)
25935 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
25937 /* If there are more levels then build up the replacement with the outer
25940 replacement
= add_to_template_args (template_parms_to_args
25941 (TREE_CHAIN (current_template_parms
)),
25944 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
25947 /* Entries in the decl_constraint hash table. */
25948 struct GTY((for_user
)) constr_entry
25954 /* Hashing function and equality for constraint entries. */
25955 struct constr_hasher
: ggc_ptr_hash
<constr_entry
>
25957 static hashval_t
hash (constr_entry
*e
)
25959 return (hashval_t
)DECL_UID (e
->decl
);
25962 static bool equal (constr_entry
*e1
, constr_entry
*e2
)
25964 return e1
->decl
== e2
->decl
;
25968 /* A mapping from declarations to constraint information. Note that
25969 both templates and their underlying declarations are mapped to the
25970 same constraint information.
25972 FIXME: This is defined in pt.c because garbage collection
25973 code is not being generated for constraint.cc. */
25975 static GTY (()) hash_table
<constr_hasher
> *decl_constraints
;
25977 /* Returns the template constraints of declaration T. If T is not
25978 constrained, return NULL_TREE. Note that T must be non-null. */
25981 get_constraints (tree t
)
25983 if (!flag_concepts
)
25986 gcc_assert (DECL_P (t
));
25987 if (TREE_CODE (t
) == TEMPLATE_DECL
)
25988 t
= DECL_TEMPLATE_RESULT (t
);
25989 constr_entry elt
= { t
, NULL_TREE
};
25990 constr_entry
* found
= decl_constraints
->find (&elt
);
25997 /* Associate the given constraint information CI with the declaration
25998 T. If T is a template, then the constraints are associated with
25999 its underlying declaration. Don't build associations if CI is
26003 set_constraints (tree t
, tree ci
)
26007 gcc_assert (t
&& flag_concepts
);
26008 if (TREE_CODE (t
) == TEMPLATE_DECL
)
26009 t
= DECL_TEMPLATE_RESULT (t
);
26010 gcc_assert (!get_constraints (t
));
26011 constr_entry elt
= {t
, ci
};
26012 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, INSERT
);
26013 constr_entry
* entry
= ggc_alloc
<constr_entry
> ();
26018 /* Remove the associated constraints of the declaration T. */
26021 remove_constraints (tree t
)
26023 gcc_assert (DECL_P (t
));
26024 if (TREE_CODE (t
) == TEMPLATE_DECL
)
26025 t
= DECL_TEMPLATE_RESULT (t
);
26027 constr_entry elt
= {t
, NULL_TREE
};
26028 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, NO_INSERT
);
26030 decl_constraints
->clear_slot (slot
);
26033 /* Memoized satisfaction results for declarations. This
26034 maps the pair (constraint_info, arguments) to the result computed
26035 by constraints_satisfied_p. */
26037 struct GTY((for_user
)) constraint_sat_entry
26044 /* Hashing function and equality for constraint entries. */
26046 struct constraint_sat_hasher
: ggc_ptr_hash
<constraint_sat_entry
>
26048 static hashval_t
hash (constraint_sat_entry
*e
)
26050 hashval_t val
= iterative_hash_object(e
->ci
, 0);
26051 return iterative_hash_template_arg (e
->args
, val
);
26054 static bool equal (constraint_sat_entry
*e1
, constraint_sat_entry
*e2
)
26056 return e1
->ci
== e2
->ci
&& comp_template_args (e1
->args
, e2
->args
);
26060 /* Memoized satisfaction results for concept checks. */
26062 struct GTY((for_user
)) concept_spec_entry
26069 /* Hashing function and equality for constraint entries. */
26071 struct concept_spec_hasher
: ggc_ptr_hash
<concept_spec_entry
>
26073 static hashval_t
hash (concept_spec_entry
*e
)
26075 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
26078 static bool equal (concept_spec_entry
*e1
, concept_spec_entry
*e2
)
26080 ++comparing_specializations
;
26081 bool eq
= e1
->tmpl
== e2
->tmpl
&& comp_template_args (e1
->args
, e2
->args
);
26082 --comparing_specializations
;
26087 static GTY (()) hash_table
<constraint_sat_hasher
> *constraint_memos
;
26088 static GTY (()) hash_table
<concept_spec_hasher
> *concept_memos
;
26090 /* Search for a memoized satisfaction result. Returns one of the
26091 truth value nodes if previously memoized, or NULL_TREE otherwise. */
26094 lookup_constraint_satisfaction (tree ci
, tree args
)
26096 constraint_sat_entry elt
= { ci
, args
, NULL_TREE
};
26097 constraint_sat_entry
* found
= constraint_memos
->find (&elt
);
26099 return found
->result
;
26104 /* Memoize the result of a satisfication test. Returns the saved result. */
26107 memoize_constraint_satisfaction (tree ci
, tree args
, tree result
)
26109 constraint_sat_entry elt
= {ci
, args
, result
};
26110 constraint_sat_entry
** slot
= constraint_memos
->find_slot (&elt
, INSERT
);
26111 constraint_sat_entry
* entry
= ggc_alloc
<constraint_sat_entry
> ();
26117 /* Search for a memoized satisfaction result for a concept. */
26120 lookup_concept_satisfaction (tree tmpl
, tree args
)
26122 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
26123 concept_spec_entry
* found
= concept_memos
->find (&elt
);
26125 return found
->result
;
26130 /* Memoize the result of a concept check. Returns the saved result. */
26133 memoize_concept_satisfaction (tree tmpl
, tree args
, tree result
)
26135 concept_spec_entry elt
= {tmpl
, args
, result
};
26136 concept_spec_entry
** slot
= concept_memos
->find_slot (&elt
, INSERT
);
26137 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
26143 static GTY (()) hash_table
<concept_spec_hasher
> *concept_expansions
;
26145 /* Returns a prior concept specialization. This returns the substituted
26146 and normalized constraints defined by the concept. */
26149 get_concept_expansion (tree tmpl
, tree args
)
26151 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
26152 concept_spec_entry
* found
= concept_expansions
->find (&elt
);
26154 return found
->result
;
26159 /* Save a concept expansion for later. */
26162 save_concept_expansion (tree tmpl
, tree args
, tree def
)
26164 concept_spec_entry elt
= {tmpl
, args
, def
};
26165 concept_spec_entry
** slot
= concept_expansions
->find_slot (&elt
, INSERT
);
26166 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
26173 hash_subsumption_args (tree t1
, tree t2
)
26175 gcc_assert (TREE_CODE (t1
) == CHECK_CONSTR
);
26176 gcc_assert (TREE_CODE (t2
) == CHECK_CONSTR
);
26178 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t1
), val
);
26179 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t1
), val
);
26180 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t2
), val
);
26181 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t2
), val
);
26185 /* Compare the constraints of two subsumption entries. The LEFT1 and
26186 LEFT2 arguments comprise the first subsumption pair and the RIGHT1
26187 and RIGHT2 arguments comprise the second. These are all CHECK_CONSTRs. */
26190 comp_subsumption_args (tree left1
, tree left2
, tree right1
, tree right2
)
26192 if (CHECK_CONSTR_CONCEPT (left1
) == CHECK_CONSTR_CONCEPT (right1
))
26193 if (CHECK_CONSTR_CONCEPT (left2
) == CHECK_CONSTR_CONCEPT (right2
))
26194 if (comp_template_args (CHECK_CONSTR_ARGS (left1
),
26195 CHECK_CONSTR_ARGS (right1
)))
26196 return comp_template_args (CHECK_CONSTR_ARGS (left2
),
26197 CHECK_CONSTR_ARGS (right2
));
26201 /* Key/value pair for learning and memoizing subsumption results. This
26202 associates a pair of check constraints (including arguments) with
26203 a boolean value indicating the result. */
26205 struct GTY((for_user
)) subsumption_entry
26212 /* Hashing function and equality for constraint entries. */
26214 struct subsumption_hasher
: ggc_ptr_hash
<subsumption_entry
>
26216 static hashval_t
hash (subsumption_entry
*e
)
26218 return hash_subsumption_args (e
->t1
, e
->t2
);
26221 static bool equal (subsumption_entry
*e1
, subsumption_entry
*e2
)
26223 ++comparing_specializations
;
26224 bool eq
= comp_subsumption_args(e1
->t1
, e1
->t2
, e2
->t1
, e2
->t2
);
26225 --comparing_specializations
;
26230 static GTY (()) hash_table
<subsumption_hasher
> *subsumption_table
;
26232 /* Search for a previously cached subsumption result. */
26235 lookup_subsumption_result (tree t1
, tree t2
)
26237 subsumption_entry elt
= { t1
, t2
, false };
26238 subsumption_entry
* found
= subsumption_table
->find (&elt
);
26240 return &found
->result
;
26245 /* Save a subsumption result. */
26248 save_subsumption_result (tree t1
, tree t2
, bool result
)
26250 subsumption_entry elt
= {t1
, t2
, result
};
26251 subsumption_entry
** slot
= subsumption_table
->find_slot (&elt
, INSERT
);
26252 subsumption_entry
* entry
= ggc_alloc
<subsumption_entry
> ();
26258 /* Set up the hash table for constraint association. */
26261 init_constraint_processing (void)
26263 if (!flag_concepts
)
26266 decl_constraints
= hash_table
<constr_hasher
>::create_ggc(37);
26267 constraint_memos
= hash_table
<constraint_sat_hasher
>::create_ggc(37);
26268 concept_memos
= hash_table
<concept_spec_hasher
>::create_ggc(37);
26269 concept_expansions
= hash_table
<concept_spec_hasher
>::create_ggc(37);
26270 subsumption_table
= hash_table
<subsumption_hasher
>::create_ggc(37);
26273 /* __integer_pack(N) in a pack expansion expands to a sequence of numbers from
26277 declare_integer_pack (void)
26279 tree ipfn
= push_library_fn (get_identifier ("__integer_pack"),
26280 build_function_type_list (integer_type_node
,
26283 NULL_TREE
, ECF_CONST
);
26284 DECL_DECLARED_CONSTEXPR_P (ipfn
) = true;
26285 DECL_BUILT_IN_CLASS (ipfn
) = BUILT_IN_FRONTEND
;
26288 /* Set up the hash tables for template instantiations. */
26291 init_template_processing (void)
26293 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
26294 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
26296 if (cxx_dialect
>= cxx11
)
26297 declare_integer_pack ();
26300 /* Print stats about the template hash tables for -fstats. */
26303 print_template_statistics (void)
26305 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
26306 "%f collisions\n", (long) decl_specializations
->size (),
26307 (long) decl_specializations
->elements (),
26308 decl_specializations
->collisions ());
26309 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
26310 "%f collisions\n", (long) type_specializations
->size (),
26311 (long) type_specializations
->elements (),
26312 type_specializations
->collisions ());
26315 #include "gt-cp-pt.h"