1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2015 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"
44 /* The type of functions taking a tree, and some additional data, and
46 typedef int (*tree_fn_t
) (tree
, void*);
48 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
49 instantiations have been deferred, either because their definitions
50 were not yet available, or because we were putting off doing the work. */
51 struct GTY ((chain_next ("%h.next"))) pending_template
{
52 struct pending_template
*next
;
53 struct tinst_level
*tinst
;
56 static GTY(()) struct pending_template
*pending_templates
;
57 static GTY(()) struct pending_template
*last_pending_template
;
59 int processing_template_parmlist
;
60 static int template_header_count
;
62 static GTY(()) tree saved_trees
;
63 static vec
<int> inline_parm_levels
;
65 static GTY(()) struct tinst_level
*current_tinst_level
;
67 static GTY(()) tree saved_access_scope
;
69 /* Live only within one (recursive) call to tsubst_expr. We use
70 this to pass the statement expression node from the STMT_EXPR
71 to the EXPR_STMT that is its result. */
72 static tree cur_stmt_expr
;
74 // -------------------------------------------------------------------------- //
75 // Local Specialization Stack
77 // Implementation of the RAII helper for creating new local
79 local_specialization_stack::local_specialization_stack ()
80 : saved (local_specializations
)
82 local_specializations
= new hash_map
<tree
, tree
>;
85 local_specialization_stack::~local_specialization_stack ()
87 delete local_specializations
;
88 local_specializations
= saved
;
91 /* True if we've recursed into fn_type_unification too many times. */
92 static bool excessive_deduction_depth
;
94 struct GTY((for_user
)) spec_entry
101 struct spec_hasher
: ggc_ptr_hash
<spec_entry
>
103 static hashval_t
hash (spec_entry
*);
104 static bool equal (spec_entry
*, spec_entry
*);
107 static GTY (()) hash_table
<spec_hasher
> *decl_specializations
;
109 static GTY (()) hash_table
<spec_hasher
> *type_specializations
;
111 /* Contains canonical template parameter types. The vector is indexed by
112 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
113 TREE_LIST, whose TREE_VALUEs contain the canonical template
114 parameters of various types and levels. */
115 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
117 #define UNIFY_ALLOW_NONE 0
118 #define UNIFY_ALLOW_MORE_CV_QUAL 1
119 #define UNIFY_ALLOW_LESS_CV_QUAL 2
120 #define UNIFY_ALLOW_DERIVED 4
121 #define UNIFY_ALLOW_INTEGER 8
122 #define UNIFY_ALLOW_OUTER_LEVEL 16
123 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
124 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
126 enum template_base_result
{
128 tbr_ambiguous_baseclass
,
132 static void push_access_scope (tree
);
133 static void pop_access_scope (tree
);
134 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
135 unification_kind_t
, int,
137 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
138 unification_kind_t
, int, bool, bool);
139 static int unify (tree
, tree
, tree
, tree
, int, bool);
140 static void add_pending_template (tree
);
141 static tree
reopen_tinst_level (struct tinst_level
*);
142 static tree
tsubst_initializer_list (tree
, tree
);
143 static tree
get_partial_spec_bindings (tree
, tree
, tree
, tree
);
144 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
146 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
148 static void tsubst_enum (tree
, tree
, tree
);
149 static tree
add_to_template_args (tree
, tree
);
150 static tree
add_outermost_template_args (tree
, tree
);
151 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
152 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
154 static int type_unification_real (tree
, tree
, tree
, const tree
*,
155 unsigned int, int, unification_kind_t
, int,
156 vec
<deferred_access_check
, va_gc
> **,
158 static void note_template_header (int);
159 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
160 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
161 static tree
convert_template_argument (tree
, tree
, tree
,
162 tsubst_flags_t
, int, tree
);
163 static tree
for_each_template_parm (tree
, tree_fn_t
, void*,
164 hash_set
<tree
> *, bool);
165 static tree
expand_template_argument_pack (tree
);
166 static tree
build_template_parm_index (int, int, int, tree
, tree
);
167 static bool inline_needs_template_parms (tree
, bool);
168 static void push_inline_template_parms_recursive (tree
, int);
169 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
170 static int mark_template_parm (tree
, void *);
171 static int template_parm_this_level_p (tree
, void *);
172 static tree
tsubst_friend_function (tree
, tree
);
173 static tree
tsubst_friend_class (tree
, tree
);
174 static int can_complete_type_without_circularity (tree
);
175 static tree
get_bindings (tree
, tree
, tree
, bool);
176 static int template_decl_level (tree
);
177 static int check_cv_quals_for_unify (int, tree
, tree
);
178 static void template_parm_level_and_index (tree
, int*, int*);
179 static int unify_pack_expansion (tree
, tree
, tree
,
180 tree
, unification_kind_t
, bool, bool);
181 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
182 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
183 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
184 static void regenerate_decl_from_template (tree
, tree
);
185 static tree
most_specialized_partial_spec (tree
, tsubst_flags_t
);
186 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
187 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
188 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
189 static bool check_specialization_scope (void);
190 static tree
process_partial_specialization (tree
);
191 static void set_current_access_from_decl (tree
);
192 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
194 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
195 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
197 static bool template_template_parm_bindings_ok_p (tree
, tree
);
198 static int template_args_equal (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
);
218 /* Make the current scope suitable for access checking when we are
219 processing T. T can be FUNCTION_DECL for instantiated function
220 template, VAR_DECL for static member variable, or TYPE_DECL for
221 alias template (needed by instantiate_decl). */
224 push_access_scope (tree t
)
226 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
227 || TREE_CODE (t
) == TYPE_DECL
);
229 if (DECL_FRIEND_CONTEXT (t
))
230 push_nested_class (DECL_FRIEND_CONTEXT (t
));
231 else if (DECL_CLASS_SCOPE_P (t
))
232 push_nested_class (DECL_CONTEXT (t
));
234 push_to_top_level ();
236 if (TREE_CODE (t
) == FUNCTION_DECL
)
238 saved_access_scope
= tree_cons
239 (NULL_TREE
, current_function_decl
, saved_access_scope
);
240 current_function_decl
= t
;
244 /* Restore the scope set up by push_access_scope. T is the node we
248 pop_access_scope (tree t
)
250 if (TREE_CODE (t
) == FUNCTION_DECL
)
252 current_function_decl
= TREE_VALUE (saved_access_scope
);
253 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
256 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
259 pop_from_top_level ();
262 /* Do any processing required when DECL (a member template
263 declaration) is finished. Returns the TEMPLATE_DECL corresponding
264 to DECL, unless it is a specialization, in which case the DECL
265 itself is returned. */
268 finish_member_template_decl (tree decl
)
270 if (decl
== error_mark_node
)
271 return error_mark_node
;
273 gcc_assert (DECL_P (decl
));
275 if (TREE_CODE (decl
) == TYPE_DECL
)
279 type
= TREE_TYPE (decl
);
280 if (type
== error_mark_node
)
281 return error_mark_node
;
282 if (MAYBE_CLASS_TYPE_P (type
)
283 && CLASSTYPE_TEMPLATE_INFO (type
)
284 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
286 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
287 check_member_template (tmpl
);
292 else if (TREE_CODE (decl
) == FIELD_DECL
)
293 error ("data member %qD cannot be a member template", decl
);
294 else if (DECL_TEMPLATE_INFO (decl
))
296 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
298 check_member_template (DECL_TI_TEMPLATE (decl
));
299 return DECL_TI_TEMPLATE (decl
);
305 error ("invalid member template declaration %qD", decl
);
307 return error_mark_node
;
310 /* Create a template info node. */
313 build_template_info (tree template_decl
, tree template_args
)
315 tree result
= make_node (TEMPLATE_INFO
);
316 TI_TEMPLATE (result
) = template_decl
;
317 TI_ARGS (result
) = template_args
;
321 /* Return the template info node corresponding to T, whatever T is. */
324 get_template_info (const_tree t
)
326 tree tinfo
= NULL_TREE
;
328 if (!t
|| t
== error_mark_node
)
331 if (TREE_CODE (t
) == NAMESPACE_DECL
)
334 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
335 tinfo
= DECL_TEMPLATE_INFO (t
);
337 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
340 if (OVERLOAD_TYPE_P (t
))
341 tinfo
= TYPE_TEMPLATE_INFO (t
);
342 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
343 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
348 /* Returns the template nesting level of the indicated class TYPE.
358 A<T>::B<U> has depth two, while A<T> has depth one.
359 Both A<T>::B<int> and A<int>::B<U> have depth one, if
360 they are instantiations, not specializations.
362 This function is guaranteed to return 0 if passed NULL_TREE so
363 that, for example, `template_class_depth (current_class_type)' is
367 template_class_depth (tree type
)
372 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
373 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
374 ? CP_DECL_CONTEXT (type
) : CP_TYPE_CONTEXT (type
))
376 tree tinfo
= get_template_info (type
);
378 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
379 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
386 /* Subroutine of maybe_begin_member_template_processing.
387 Returns true if processing DECL needs us to push template parms. */
390 inline_needs_template_parms (tree decl
, bool nsdmi
)
392 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
395 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
396 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
399 /* Subroutine of maybe_begin_member_template_processing.
400 Push the template parms in PARMS, starting from LEVELS steps into the
401 chain, and ending at the beginning, since template parms are listed
405 push_inline_template_parms_recursive (tree parmlist
, int levels
)
407 tree parms
= TREE_VALUE (parmlist
);
411 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
413 ++processing_template_decl
;
414 current_template_parms
415 = tree_cons (size_int (processing_template_decl
),
416 parms
, current_template_parms
);
417 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
419 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
421 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
423 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
425 if (error_operand_p (parm
))
428 gcc_assert (DECL_P (parm
));
430 switch (TREE_CODE (parm
))
438 /* Push the CONST_DECL. */
439 pushdecl (TEMPLATE_PARM_DECL (DECL_INITIAL (parm
)));
448 /* Restore the template parameter context for a member template, a
449 friend template defined in a class definition, or a non-template
450 member of template class. */
453 maybe_begin_member_template_processing (tree decl
)
457 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
461 tree ctx
= DECL_CONTEXT (decl
);
462 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
463 /* Disregard full specializations (c++/60999). */
464 && uses_template_parms (ctx
)
465 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
468 if (inline_needs_template_parms (decl
, nsdmi
))
470 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
471 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
473 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
476 parms
= TREE_CHAIN (parms
);
479 push_inline_template_parms_recursive (parms
, levels
);
482 /* Remember how many levels of template parameters we pushed so that
483 we can pop them later. */
484 inline_parm_levels
.safe_push (levels
);
487 /* Undo the effects of maybe_begin_member_template_processing. */
490 maybe_end_member_template_processing (void)
495 if (inline_parm_levels
.length () == 0)
498 last
= inline_parm_levels
.pop ();
499 for (i
= 0; i
< last
; ++i
)
501 --processing_template_decl
;
502 current_template_parms
= TREE_CHAIN (current_template_parms
);
507 /* Return a new template argument vector which contains all of ARGS,
508 but has as its innermost set of arguments the EXTRA_ARGS. */
511 add_to_template_args (tree args
, tree extra_args
)
518 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
521 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
522 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
524 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
525 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
527 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
528 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
533 /* Like add_to_template_args, but only the outermost ARGS are added to
534 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
535 (EXTRA_ARGS) levels are added. This function is used to combine
536 the template arguments from a partial instantiation with the
537 template arguments used to attain the full instantiation from the
538 partial instantiation. */
541 add_outermost_template_args (tree args
, tree extra_args
)
545 /* If there are more levels of EXTRA_ARGS than there are ARGS,
546 something very fishy is going on. */
547 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
549 /* If *all* the new arguments will be the EXTRA_ARGS, just return
551 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
554 /* For the moment, we make ARGS look like it contains fewer levels. */
555 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
557 new_args
= add_to_template_args (args
, extra_args
);
559 /* Now, we restore ARGS to its full dimensions. */
560 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
565 /* Return the N levels of innermost template arguments from the ARGS. */
568 get_innermost_template_args (tree args
, int n
)
576 /* If N is 1, just return the innermost set of template arguments. */
578 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
580 /* If we're not removing anything, just return the arguments we were
582 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
583 gcc_assert (extra_levels
>= 0);
584 if (extra_levels
== 0)
587 /* Make a new set of arguments, not containing the outer arguments. */
588 new_args
= make_tree_vec (n
);
589 for (i
= 1; i
<= n
; ++i
)
590 SET_TMPL_ARGS_LEVEL (new_args
, i
,
591 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
596 /* The inverse of get_innermost_template_args: Return all but the innermost
597 EXTRA_LEVELS levels of template arguments from the ARGS. */
600 strip_innermost_template_args (tree args
, int extra_levels
)
603 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
608 /* If N is 1, just return the outermost set of template arguments. */
610 return TMPL_ARGS_LEVEL (args
, 1);
612 /* If we're not removing anything, just return the arguments we were
614 gcc_assert (extra_levels
>= 0);
615 if (extra_levels
== 0)
618 /* Make a new set of arguments, not containing the inner arguments. */
619 new_args
= make_tree_vec (n
);
620 for (i
= 1; i
<= n
; ++i
)
621 SET_TMPL_ARGS_LEVEL (new_args
, i
,
622 TMPL_ARGS_LEVEL (args
, i
));
627 /* We've got a template header coming up; push to a new level for storing
631 begin_template_parm_list (void)
633 /* We use a non-tag-transparent scope here, which causes pushtag to
634 put tags in this scope, rather than in the enclosing class or
635 namespace scope. This is the right thing, since we want
636 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
637 global template class, push_template_decl handles putting the
638 TEMPLATE_DECL into top-level scope. For a nested template class,
641 template <class T> struct S1 {
642 template <class T> struct S2 {};
645 pushtag contains special code to call pushdecl_with_scope on the
646 TEMPLATE_DECL for S2. */
647 begin_scope (sk_template_parms
, NULL
);
648 ++processing_template_decl
;
649 ++processing_template_parmlist
;
650 note_template_header (0);
652 /* Add a dummy parameter level while we process the parameter list. */
653 current_template_parms
654 = tree_cons (size_int (processing_template_decl
),
656 current_template_parms
);
659 /* This routine is called when a specialization is declared. If it is
660 invalid to declare a specialization here, an error is reported and
661 false is returned, otherwise this routine will return true. */
664 check_specialization_scope (void)
666 tree scope
= current_scope ();
670 An explicit specialization shall be declared in the namespace of
671 which the template is a member, or, for member templates, in the
672 namespace of which the enclosing class or enclosing class
673 template is a member. An explicit specialization of a member
674 function, member class or static data member of a class template
675 shall be declared in the namespace of which the class template
677 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
679 error ("explicit specialization in non-namespace scope %qD", scope
);
685 In an explicit specialization declaration for a member of a class
686 template or a member template that appears in namespace scope,
687 the member template and some of its enclosing class templates may
688 remain unspecialized, except that the declaration shall not
689 explicitly specialize a class member template if its enclosing
690 class templates are not explicitly specialized as well. */
691 if (current_template_parms
)
693 error ("enclosing class templates are not explicitly specialized");
700 /* We've just seen template <>. */
703 begin_specialization (void)
705 begin_scope (sk_template_spec
, NULL
);
706 note_template_header (1);
707 return check_specialization_scope ();
710 /* Called at then end of processing a declaration preceded by
714 end_specialization (void)
717 reset_specialization ();
720 /* Any template <>'s that we have seen thus far are not referring to a
721 function specialization. */
724 reset_specialization (void)
726 processing_specialization
= 0;
727 template_header_count
= 0;
730 /* We've just seen a template header. If SPECIALIZATION is nonzero,
731 it was of the form template <>. */
734 note_template_header (int specialization
)
736 processing_specialization
= specialization
;
737 template_header_count
++;
740 /* We're beginning an explicit instantiation. */
743 begin_explicit_instantiation (void)
745 gcc_assert (!processing_explicit_instantiation
);
746 processing_explicit_instantiation
= true;
751 end_explicit_instantiation (void)
753 gcc_assert (processing_explicit_instantiation
);
754 processing_explicit_instantiation
= false;
757 /* An explicit specialization or partial specialization of TMPL is being
758 declared. Check that the namespace in which the specialization is
759 occurring is permissible. Returns false iff it is invalid to
760 specialize TMPL in the current namespace. */
763 check_specialization_namespace (tree tmpl
)
765 tree tpl_ns
= decl_namespace_context (tmpl
);
769 An explicit specialization shall be declared in the namespace of
770 which the template is a member, or, for member templates, in the
771 namespace of which the enclosing class or enclosing class
772 template is a member. An explicit specialization of a member
773 function, member class or static data member of a class template
774 shall be declared in the namespace of which the class template is
776 if (current_scope() != DECL_CONTEXT (tmpl
)
777 && !at_namespace_scope_p ())
779 error ("specialization of %qD must appear at namespace scope", tmpl
);
782 if (is_associated_namespace (current_namespace
, tpl_ns
))
783 /* Same or super-using namespace. */
787 permerror (input_location
,
788 "specialization of %qD in different namespace", tmpl
);
789 permerror (DECL_SOURCE_LOCATION (tmpl
),
790 " from definition of %q#D", tmpl
);
795 /* SPEC is an explicit instantiation. Check that it is valid to
796 perform this explicit instantiation in the current namespace. */
799 check_explicit_instantiation_namespace (tree spec
)
803 /* DR 275: An explicit instantiation shall appear in an enclosing
804 namespace of its template. */
805 ns
= decl_namespace_context (spec
);
806 if (!is_ancestor (current_namespace
, ns
))
807 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
808 "(which does not enclose namespace %qD)",
809 spec
, current_namespace
, ns
);
812 // Returns the type of a template specialization only if that
813 // specialization needs to be defined. Otherwise (e.g., if the type has
814 // already been defined), the function returns NULL_TREE.
816 maybe_new_partial_specialization (tree type
)
818 // An implicit instantiation of an incomplete type implies
819 // the definition of a new class template.
821 // template<typename T>
824 // template<typename T>
827 // Here, S<T*> is an implicit instantiation of S whose type
829 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
) && !COMPLETE_TYPE_P (type
))
832 // It can also be the case that TYPE is a completed specialization.
833 // Continuing the previous example, suppose we also declare:
835 // template<typename T>
836 // requires Integral<T>
839 // Here, S<T*> refers to the specialization S<T*> defined
840 // above. However, we need to differentiate definitions because
841 // we intend to define a new partial specialization. In this case,
842 // we rely on the fact that the constraints are different for
843 // this declaration than that above.
845 // Note that we also get here for injected class names and
846 // late-parsed template definitions. We must ensure that we
847 // do not create new type declarations for those cases.
848 if (flag_concepts
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
850 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
851 tree args
= CLASSTYPE_TI_ARGS (type
);
853 // If there are no template parameters, this cannot be a new
854 // partial template specializtion?
855 if (!current_template_parms
)
858 // The injected-class-name is not a new partial specialization.
859 if (DECL_SELF_REFERENCE_P (TYPE_NAME (type
)))
862 // If the constraints are not the same as those of the primary
863 // then, we can probably create a new specialization.
864 tree type_constr
= current_template_constraints ();
866 if (type
== TREE_TYPE (tmpl
))
868 tree main_constr
= get_constraints (tmpl
);
869 if (equivalent_constraints (type_constr
, main_constr
))
873 // Also, if there's a pre-existing specialization with matching
874 // constraints, then this also isn't new.
875 tree specs
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
878 tree spec_tmpl
= TREE_VALUE (specs
);
879 tree spec_args
= TREE_PURPOSE (specs
);
880 tree spec_constr
= get_constraints (spec_tmpl
);
881 if (comp_template_args (args
, spec_args
)
882 && equivalent_constraints (type_constr
, spec_constr
))
884 specs
= TREE_CHAIN (specs
);
887 // Create a new type node (and corresponding type decl)
888 // for the newly declared specialization.
889 tree t
= make_class_type (TREE_CODE (type
));
890 CLASSTYPE_DECLARED_CLASS (t
) = CLASSTYPE_DECLARED_CLASS (type
);
891 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (type
);
892 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (tmpl
, args
));
894 /* We only need a separate type node for storing the definition of this
895 partial specialization; uses of S<T*> are unconstrained, so all are
896 equivalent. So keep TYPE_CANONICAL the same. */
897 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
899 // Build the corresponding type decl.
900 tree d
= create_implicit_typedef (DECL_NAME (tmpl
), t
);
901 DECL_CONTEXT (d
) = TYPE_CONTEXT (t
);
902 DECL_SOURCE_LOCATION (d
) = input_location
;
910 /* The TYPE is being declared. If it is a template type, that means it
911 is a partial specialization. Do appropriate error-checking. */
914 maybe_process_partial_specialization (tree type
)
918 if (type
== error_mark_node
)
919 return error_mark_node
;
921 /* A lambda that appears in specialization context is not itself a
923 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
926 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
928 error ("name of class shadows template template parameter %qD",
930 return error_mark_node
;
933 context
= TYPE_CONTEXT (type
);
935 if (TYPE_ALIAS_P (type
))
937 if (TYPE_TEMPLATE_INFO (type
)
938 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (type
)))
939 error ("specialization of alias template %qD",
940 TYPE_TI_TEMPLATE (type
));
942 error ("explicit specialization of non-template %qT", type
);
943 return error_mark_node
;
945 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
947 /* This is for ordinary explicit specialization and partial
948 specialization of a template class such as:
950 template <> class C<int>;
954 template <class T> class C<T*>;
956 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
958 if (tree t
= maybe_new_partial_specialization (type
))
960 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (t
))
961 && !at_namespace_scope_p ())
962 return error_mark_node
;
963 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t
);
964 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (t
)) = input_location
;
965 if (processing_template_decl
)
967 tree decl
= push_template_decl (TYPE_MAIN_DECL (t
));
968 if (decl
== error_mark_node
)
969 return error_mark_node
;
970 return TREE_TYPE (decl
);
973 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
974 error ("specialization of %qT after instantiation", type
);
975 else if (errorcount
&& !processing_specialization
976 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
977 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
978 /* Trying to define a specialization either without a template<> header
979 or in an inappropriate place. We've already given an error, so just
980 bail now so we don't actually define the specialization. */
981 return error_mark_node
;
983 else if (CLASS_TYPE_P (type
)
984 && !CLASSTYPE_USE_TEMPLATE (type
)
985 && CLASSTYPE_TEMPLATE_INFO (type
)
986 && context
&& CLASS_TYPE_P (context
)
987 && CLASSTYPE_TEMPLATE_INFO (context
))
989 /* This is for an explicit specialization of member class
990 template according to [temp.expl.spec/18]:
992 template <> template <class U> class C<int>::D;
994 The context `C<int>' must be an implicit instantiation.
995 Otherwise this is just a member class template declared
998 template <> class C<int> { template <class U> class D; };
999 template <> template <class U> class C<int>::D;
1001 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1002 while in the second case, `C<int>::D' is a primary template
1003 and `C<T>::D' may not exist. */
1005 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
1006 && !COMPLETE_TYPE_P (type
))
1009 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1011 if (current_namespace
1012 != decl_namespace_context (tmpl
))
1014 permerror (input_location
,
1015 "specializing %q#T in different namespace", type
);
1016 permerror (DECL_SOURCE_LOCATION (tmpl
),
1017 " from definition of %q#D", tmpl
);
1020 /* Check for invalid specialization after instantiation:
1022 template <> template <> class C<int>::D<int>;
1023 template <> template <class U> class C<int>::D; */
1025 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
1026 t
; t
= TREE_CHAIN (t
))
1028 tree inst
= TREE_VALUE (t
);
1029 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
1030 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
1032 /* We already have a full specialization of this partial
1033 instantiation, or a full specialization has been
1034 looked up but not instantiated. Reassign it to the
1035 new member specialization template. */
1039 elt
.tmpl
= most_general_template (tmpl
);
1040 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
1043 type_specializations
->remove_elt (&elt
);
1046 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
1049 = type_specializations
->find_slot (&elt
, INSERT
);
1050 entry
= ggc_alloc
<spec_entry
> ();
1055 /* But if we've had an implicit instantiation, that's a
1056 problem ([temp.expl.spec]/6). */
1057 error ("specialization %qT after instantiation %qT",
1061 /* Mark TYPE as a specialization. And as a result, we only
1062 have one level of template argument for the innermost
1064 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
1065 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
1066 CLASSTYPE_TI_ARGS (type
)
1067 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
1070 else if (processing_specialization
)
1072 /* Someday C++0x may allow for enum template specialization. */
1073 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
1074 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
1075 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
1076 "of %qD not allowed by ISO C++", type
);
1079 error ("explicit specialization of non-template %qT", type
);
1080 return error_mark_node
;
1087 /* Returns nonzero if we can optimize the retrieval of specializations
1088 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1089 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1092 optimize_specialization_lookup_p (tree tmpl
)
1094 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
1095 && DECL_CLASS_SCOPE_P (tmpl
)
1096 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1098 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
1099 /* The optimized lookup depends on the fact that the
1100 template arguments for the member function template apply
1101 purely to the containing class, which is not true if the
1102 containing class is an explicit or partial
1104 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1105 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1106 && !DECL_CONV_FN_P (tmpl
)
1107 /* It is possible to have a template that is not a member
1108 template and is not a member of a template class:
1110 template <typename T>
1111 struct S { friend A::f(); };
1113 Here, the friend function is a template, but the context does
1114 not have template information. The optimized lookup relies
1115 on having ARGS be the template arguments for both the class
1116 and the function template. */
1117 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1120 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1121 gone through coerce_template_parms by now. */
1124 verify_unstripped_args (tree args
)
1126 ++processing_template_decl
;
1127 if (!any_dependent_template_arguments_p (args
))
1129 tree inner
= INNERMOST_TEMPLATE_ARGS (args
);
1130 for (int i
= 0; i
< TREE_VEC_LENGTH (inner
); ++i
)
1132 tree arg
= TREE_VEC_ELT (inner
, i
);
1133 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1135 else if (TYPE_P (arg
))
1136 gcc_assert (strip_typedefs (arg
, NULL
) == arg
);
1137 else if (strip_typedefs (TREE_TYPE (arg
), NULL
) != TREE_TYPE (arg
))
1138 /* Allow typedefs on the type of a non-type argument, since a
1139 parameter can have them. */;
1141 gcc_assert (strip_typedefs_expr (arg
, NULL
) == arg
);
1144 --processing_template_decl
;
1147 /* Retrieve the specialization (in the sense of [temp.spec] - a
1148 specialization is either an instantiation or an explicit
1149 specialization) of TMPL for the given template ARGS. If there is
1150 no such specialization, return NULL_TREE. The ARGS are a vector of
1151 arguments, or a vector of vectors of arguments, in the case of
1152 templates with more than one level of parameters.
1154 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1155 then we search for a partial specialization matching ARGS. This
1156 parameter is ignored if TMPL is not a class template.
1158 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1159 result is a NONTYPE_ARGUMENT_PACK. */
1162 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1164 if (tmpl
== NULL_TREE
)
1167 if (args
== error_mark_node
)
1170 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1171 || TREE_CODE (tmpl
) == FIELD_DECL
);
1173 /* There should be as many levels of arguments as there are
1174 levels of parameters. */
1175 gcc_assert (TMPL_ARGS_DEPTH (args
)
1176 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1177 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1178 : template_class_depth (DECL_CONTEXT (tmpl
))));
1181 verify_unstripped_args (args
);
1183 if (optimize_specialization_lookup_p (tmpl
))
1185 tree class_template
;
1186 tree class_specialization
;
1187 vec
<tree
, va_gc
> *methods
;
1191 /* The template arguments actually apply to the containing
1192 class. Find the class specialization with those
1194 class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1195 class_specialization
1196 = retrieve_specialization (class_template
, args
, 0);
1197 if (!class_specialization
)
1199 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1200 for the specialization. */
1201 idx
= class_method_index_for_fn (class_specialization
, tmpl
);
1204 /* Iterate through the methods with the indicated name, looking
1205 for the one that has an instance of TMPL. */
1206 methods
= CLASSTYPE_METHOD_VEC (class_specialization
);
1207 for (fns
= (*methods
)[idx
]; fns
; fns
= OVL_NEXT (fns
))
1209 tree fn
= OVL_CURRENT (fns
);
1210 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1211 /* using-declarations can add base methods to the method vec,
1212 and we don't want those here. */
1213 && DECL_CONTEXT (fn
) == class_specialization
)
1222 hash_table
<spec_hasher
> *specializations
;
1226 elt
.spec
= NULL_TREE
;
1228 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1229 specializations
= type_specializations
;
1231 specializations
= decl_specializations
;
1234 hash
= spec_hasher::hash (&elt
);
1235 found
= specializations
->find_with_hash (&elt
, hash
);
1243 /* Like retrieve_specialization, but for local declarations. */
1246 retrieve_local_specialization (tree tmpl
)
1248 if (local_specializations
== NULL
)
1251 tree
*slot
= local_specializations
->get (tmpl
);
1252 return slot
? *slot
: NULL_TREE
;
1255 /* Returns nonzero iff DECL is a specialization of TMPL. */
1258 is_specialization_of (tree decl
, tree tmpl
)
1262 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1266 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1272 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1274 for (t
= TREE_TYPE (decl
);
1276 t
= CLASSTYPE_USE_TEMPLATE (t
)
1277 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1278 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1285 /* Returns nonzero iff DECL is a specialization of friend declaration
1286 FRIEND_DECL according to [temp.friend]. */
1289 is_specialization_of_friend (tree decl
, tree friend_decl
)
1291 bool need_template
= true;
1294 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1295 || TREE_CODE (decl
) == TYPE_DECL
);
1297 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1298 of a template class, we want to check if DECL is a specialization
1300 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1301 && DECL_TEMPLATE_INFO (friend_decl
)
1302 && !DECL_USE_TEMPLATE (friend_decl
))
1304 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1305 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1306 need_template
= false;
1308 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1309 && !PRIMARY_TEMPLATE_P (friend_decl
))
1310 need_template
= false;
1312 /* There is nothing to do if this is not a template friend. */
1313 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1316 if (is_specialization_of (decl
, friend_decl
))
1320 A member of a class template may be declared to be a friend of a
1321 non-template class. In this case, the corresponding member of
1322 every specialization of the class template is a friend of the
1323 class granting friendship.
1325 For example, given a template friend declaration
1327 template <class T> friend void A<T>::f();
1329 the member function below is considered a friend
1331 template <> struct A<int> {
1335 For this type of template friend, TEMPLATE_DEPTH below will be
1336 nonzero. To determine if DECL is a friend of FRIEND, we first
1337 check if the enclosing class is a specialization of another. */
1339 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1341 && DECL_CLASS_SCOPE_P (decl
)
1342 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1343 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1345 /* Next, we check the members themselves. In order to handle
1346 a few tricky cases, such as when FRIEND_DECL's are
1348 template <class T> friend void A<T>::g(T t);
1349 template <class T> template <T t> friend void A<T>::h();
1353 void A<int>::g(int);
1354 template <int> void A<int>::h();
1356 we need to figure out ARGS, the template arguments from
1357 the context of DECL. This is required for template substitution
1358 of `T' in the function parameter of `g' and template parameter
1359 of `h' in the above examples. Here ARGS corresponds to `int'. */
1361 tree context
= DECL_CONTEXT (decl
);
1362 tree args
= NULL_TREE
;
1363 int current_depth
= 0;
1365 while (current_depth
< template_depth
)
1367 if (CLASSTYPE_TEMPLATE_INFO (context
))
1369 if (current_depth
== 0)
1370 args
= TYPE_TI_ARGS (context
);
1372 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1375 context
= TYPE_CONTEXT (context
);
1378 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1383 tree friend_args_type
;
1384 tree decl_args_type
;
1386 /* Make sure that both DECL and FRIEND_DECL are templates or
1388 is_template
= DECL_TEMPLATE_INFO (decl
)
1389 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1390 if (need_template
^ is_template
)
1392 else if (is_template
)
1394 /* If both are templates, check template parameter list. */
1396 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1398 if (!comp_template_parms
1399 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1403 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1406 decl_type
= TREE_TYPE (decl
);
1408 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1409 tf_none
, NULL_TREE
);
1410 if (friend_type
== error_mark_node
)
1413 /* Check if return types match. */
1414 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1417 /* Check if function parameter types match, ignoring the
1418 `this' parameter. */
1419 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1420 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1421 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1422 friend_args_type
= TREE_CHAIN (friend_args_type
);
1423 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1424 decl_args_type
= TREE_CHAIN (decl_args_type
);
1426 return compparms (decl_args_type
, friend_args_type
);
1430 /* DECL is a TYPE_DECL */
1432 tree decl_type
= TREE_TYPE (decl
);
1434 /* Make sure that both DECL and FRIEND_DECL are templates or
1437 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1438 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1440 if (need_template
^ is_template
)
1442 else if (is_template
)
1445 /* If both are templates, check the name of the two
1446 TEMPLATE_DECL's first because is_friend didn't. */
1447 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1448 != DECL_NAME (friend_decl
))
1451 /* Now check template parameter list. */
1453 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1455 return comp_template_parms
1456 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1460 return (DECL_NAME (decl
)
1461 == DECL_NAME (friend_decl
));
1467 /* Register the specialization SPEC as a specialization of TMPL with
1468 the indicated ARGS. IS_FRIEND indicates whether the specialization
1469 is actually just a friend declaration. Returns SPEC, or an
1470 equivalent prior declaration, if available.
1472 We also store instantiations of field packs in the hash table, even
1473 though they are not themselves templates, to make lookup easier. */
1476 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1480 spec_entry
**slot
= NULL
;
1483 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1484 || (TREE_CODE (tmpl
) == FIELD_DECL
1485 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1487 if (TREE_CODE (spec
) == FUNCTION_DECL
1488 && uses_template_parms (DECL_TI_ARGS (spec
)))
1489 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1490 register it; we want the corresponding TEMPLATE_DECL instead.
1491 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1492 the more obvious `uses_template_parms (spec)' to avoid problems
1493 with default function arguments. In particular, given
1494 something like this:
1496 template <class T> void f(T t1, T t = T())
1498 the default argument expression is not substituted for in an
1499 instantiation unless and until it is actually needed. */
1502 if (optimize_specialization_lookup_p (tmpl
))
1503 /* We don't put these specializations in the hash table, but we might
1504 want to give an error about a mismatch. */
1505 fn
= retrieve_specialization (tmpl
, args
, 0);
1513 hash
= spec_hasher::hash (&elt
);
1516 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1518 fn
= ((spec_entry
*) *slot
)->spec
;
1523 /* We can sometimes try to re-register a specialization that we've
1524 already got. In particular, regenerate_decl_from_template calls
1525 duplicate_decls which will update the specialization list. But,
1526 we'll still get called again here anyhow. It's more convenient
1527 to simply allow this than to try to prevent it. */
1530 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1532 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1534 if (DECL_ODR_USED (fn
)
1535 || DECL_EXPLICIT_INSTANTIATION (fn
))
1537 error ("specialization of %qD after instantiation",
1539 return error_mark_node
;
1544 /* This situation should occur only if the first
1545 specialization is an implicit instantiation, the
1546 second is an explicit specialization, and the
1547 implicit instantiation has not yet been used. That
1548 situation can occur if we have implicitly
1549 instantiated a member function and then specialized
1552 We can also wind up here if a friend declaration that
1553 looked like an instantiation turns out to be a
1556 template <class T> void foo(T);
1557 class S { friend void foo<>(int) };
1558 template <> void foo(int);
1560 We transform the existing DECL in place so that any
1561 pointers to it become pointers to the updated
1564 If there was a definition for the template, but not
1565 for the specialization, we want this to look as if
1566 there were no definition, and vice versa. */
1567 DECL_INITIAL (fn
) = NULL_TREE
;
1568 duplicate_decls (spec
, fn
, is_friend
);
1569 /* The call to duplicate_decls will have applied
1572 An explicit specialization of a function template
1573 is inline only if it is explicitly declared to be,
1574 and independently of whether its function template
1577 to the primary function; now copy the inline bits to
1578 the various clones. */
1579 FOR_EACH_CLONE (clone
, fn
)
1581 DECL_DECLARED_INLINE_P (clone
)
1582 = DECL_DECLARED_INLINE_P (fn
);
1583 DECL_SOURCE_LOCATION (clone
)
1584 = DECL_SOURCE_LOCATION (fn
);
1585 DECL_DELETED_FN (clone
)
1586 = DECL_DELETED_FN (fn
);
1588 check_specialization_namespace (tmpl
);
1593 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1595 if (!duplicate_decls (spec
, fn
, is_friend
) && DECL_INITIAL (spec
))
1596 /* Dup decl failed, but this is a new definition. Set the
1597 line number so any errors match this new
1599 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1605 return duplicate_decls (spec
, fn
, is_friend
);
1607 /* A specialization must be declared in the same namespace as the
1608 template it is specializing. */
1609 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1610 && !check_specialization_namespace (tmpl
))
1611 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1613 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1615 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1616 gcc_assert (tmpl
&& args
&& spec
);
1619 if ((TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1620 && PRIMARY_TEMPLATE_P (tmpl
)
1621 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1622 || variable_template_p (tmpl
))
1623 /* If TMPL is a forward declaration of a template function, keep a list
1624 of all specializations in case we need to reassign them to a friend
1625 template later in tsubst_friend_function.
1627 Also keep a list of all variable template instantiations so that
1628 process_partial_specialization can check whether a later partial
1629 specialization would have used it. */
1630 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1631 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1637 /* Returns true iff two spec_entry nodes are equivalent. */
1639 int comparing_specializations
;
1642 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1646 ++comparing_specializations
;
1647 equal
= (e1
->tmpl
== e2
->tmpl
1648 && comp_template_args (e1
->args
, e2
->args
));
1649 if (equal
&& flag_concepts
1650 /* tmpl could be a FIELD_DECL for a capture pack. */
1651 && TREE_CODE (e1
->tmpl
) == TEMPLATE_DECL
1652 && VAR_P (DECL_TEMPLATE_RESULT (e1
->tmpl
))
1653 && uses_template_parms (e1
->args
))
1655 /* Partial specializations of a variable template can be distinguished by
1657 tree c1
= e1
->spec
? get_constraints (e1
->spec
) : NULL_TREE
;
1658 tree c2
= e2
->spec
? get_constraints (e2
->spec
) : NULL_TREE
;
1659 equal
= equivalent_constraints (c1
, c2
);
1661 --comparing_specializations
;
1666 /* Returns a hash for a template TMPL and template arguments ARGS. */
1669 hash_tmpl_and_args (tree tmpl
, tree args
)
1671 hashval_t val
= iterative_hash_object (DECL_UID (tmpl
), 0);
1672 return iterative_hash_template_arg (args
, val
);
1675 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1679 spec_hasher::hash (spec_entry
*e
)
1681 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1684 /* Recursively calculate a hash value for a template argument ARG, for use
1685 in the hash tables of template specializations. */
1688 iterative_hash_template_arg (tree arg
, hashval_t val
)
1690 unsigned HOST_WIDE_INT i
;
1691 enum tree_code code
;
1694 if (arg
== NULL_TREE
)
1695 return iterative_hash_object (arg
, val
);
1700 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1701 /* We can get one of these when re-hashing a previous entry in the middle
1702 of substituting into a pack expansion. Just look through it. */
1703 arg
= ARGUMENT_PACK_SELECT_FROM_PACK (arg
);
1705 code
= TREE_CODE (arg
);
1706 tclass
= TREE_CODE_CLASS (code
);
1708 val
= iterative_hash_object (code
, val
);
1715 case IDENTIFIER_NODE
:
1716 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1720 int i
, len
= TREE_VEC_LENGTH (arg
);
1721 for (i
= 0; i
< len
; ++i
)
1722 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1726 case TYPE_PACK_EXPANSION
:
1727 case EXPR_PACK_EXPANSION
:
1728 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1729 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1731 case TYPE_ARGUMENT_PACK
:
1732 case NONTYPE_ARGUMENT_PACK
:
1733 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1736 for (; arg
; arg
= TREE_CHAIN (arg
))
1737 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1741 for (; arg
; arg
= OVL_NEXT (arg
))
1742 val
= iterative_hash_template_arg (OVL_CURRENT (arg
), val
);
1748 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1749 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1751 val
= iterative_hash_template_arg (field
, val
);
1752 val
= iterative_hash_template_arg (value
, val
);
1758 if (!DECL_ARTIFICIAL (arg
))
1760 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1761 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1763 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1766 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1769 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1770 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1772 case TEMPLATE_PARM_INDEX
:
1773 val
= iterative_hash_template_arg
1774 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1775 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1776 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1779 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1780 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1781 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1784 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1786 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1790 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1791 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1792 val
= iterative_hash_object (code
, val
);
1793 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1796 /* A lambda can't appear in a template arg, but don't crash on
1798 gcc_assert (seen_error ());
1802 case IMPLICIT_CONV_EXPR
:
1803 case STATIC_CAST_EXPR
:
1804 case REINTERPRET_CAST_EXPR
:
1805 case CONST_CAST_EXPR
:
1806 case DYNAMIC_CAST_EXPR
:
1808 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1809 /* Now hash operands as usual. */
1819 if (alias_template_specialization_p (arg
))
1821 // We want an alias specialization that survived strip_typedefs
1822 // to hash differently from its TYPE_CANONICAL, to avoid hash
1823 // collisions that compare as different in template_args_equal.
1824 // These could be dependent specializations that strip_typedefs
1825 // left alone, or untouched specializations because
1826 // coerce_template_parms returns the unconverted template
1827 // arguments if it sees incomplete argument packs.
1828 tree ti
= TYPE_TEMPLATE_INFO (arg
);
1829 return hash_tmpl_and_args (TI_TEMPLATE (ti
), TI_ARGS (ti
));
1831 if (TYPE_CANONICAL (arg
))
1832 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1834 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1835 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1836 /* Otherwise just compare the types during lookup. */
1839 case tcc_declaration
:
1841 return iterative_hash_expr (arg
, val
);
1844 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1846 unsigned n
= cp_tree_operand_length (arg
);
1847 for (i
= 0; i
< n
; ++i
)
1848 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1856 /* Unregister the specialization SPEC as a specialization of TMPL.
1857 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1858 if the SPEC was listed as a specialization of TMPL.
1860 Note that SPEC has been ggc_freed, so we can't look inside it. */
1863 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1868 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1869 elt
.args
= TI_ARGS (tinfo
);
1870 elt
.spec
= NULL_TREE
;
1872 entry
= decl_specializations
->find (&elt
);
1875 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1876 gcc_assert (new_spec
!= NULL_TREE
);
1877 entry
->spec
= new_spec
;
1884 /* Like register_specialization, but for local declarations. We are
1885 registering SPEC, an instantiation of TMPL. */
1888 register_local_specialization (tree spec
, tree tmpl
)
1890 local_specializations
->put (tmpl
, spec
);
1893 /* TYPE is a class type. Returns true if TYPE is an explicitly
1894 specialized class. */
1897 explicit_class_specialization_p (tree type
)
1899 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1901 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1904 /* Print the list of functions at FNS, going through all the overloads
1905 for each element of the list. Alternatively, FNS can not be a
1906 TREE_LIST, in which case it will be printed together with all the
1909 MORE and *STR should respectively be FALSE and NULL when the function
1910 is called from the outside. They are used internally on recursive
1911 calls. print_candidates manages the two parameters and leaves NULL
1912 in *STR when it ends. */
1915 print_candidates_1 (tree fns
, bool more
, const char **str
)
1918 char *spaces
= NULL
;
1920 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
1921 if (TREE_CODE (fn
) == TREE_LIST
)
1923 for (fn2
= fn
; fn2
!= NULL_TREE
; fn2
= TREE_CHAIN (fn2
))
1924 print_candidates_1 (TREE_VALUE (fn2
),
1925 TREE_CHAIN (fn2
) || more
, str
);
1929 tree cand
= OVL_CURRENT (fn
);
1932 /* Pick the prefix string. */
1933 if (!more
&& !OVL_NEXT (fns
))
1935 inform (DECL_SOURCE_LOCATION (cand
),
1936 "candidate is: %#D", cand
);
1940 *str
= _("candidates are:");
1941 spaces
= get_spaces (*str
);
1943 inform (DECL_SOURCE_LOCATION (cand
), "%s %#D", *str
, cand
);
1944 *str
= spaces
? spaces
: *str
;
1954 /* Print the list of candidate FNS in an error message. FNS can also
1955 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1958 print_candidates (tree fns
)
1960 const char *str
= NULL
;
1961 print_candidates_1 (fns
, false, &str
);
1962 gcc_assert (str
== NULL
);
1965 /* Get a (possibly) constrained template declaration for the
1966 purpose of ordering candidates. */
1968 get_template_for_ordering (tree list
)
1970 gcc_assert (TREE_CODE (list
) == TREE_LIST
);
1971 tree f
= TREE_VALUE (list
);
1972 if (tree ti
= DECL_TEMPLATE_INFO (f
))
1973 return TI_TEMPLATE (ti
);
1977 /* Among candidates having the same signature, return the
1978 most constrained or NULL_TREE if there is no best candidate.
1979 If the signatures of candidates vary (e.g., template
1980 specialization vs. member function), then there can be no
1983 Note that we don't compare constraints on the functions
1984 themselves, but rather those of their templates. */
1986 most_constrained_function (tree candidates
)
1988 // Try to find the best candidate in a first pass.
1989 tree champ
= candidates
;
1990 for (tree c
= TREE_CHAIN (champ
); c
; c
= TREE_CHAIN (c
))
1992 int winner
= more_constrained (get_template_for_ordering (champ
),
1993 get_template_for_ordering (c
));
1995 champ
= c
; // The candidate is more constrained
1996 else if (winner
== 0)
1997 return NULL_TREE
; // Neither is more constrained
2000 // Verify that the champ is better than previous candidates.
2001 for (tree c
= candidates
; c
!= champ
; c
= TREE_CHAIN (c
)) {
2002 if (!more_constrained (get_template_for_ordering (champ
),
2003 get_template_for_ordering (c
)))
2011 /* Returns the template (one of the functions given by TEMPLATE_ID)
2012 which can be specialized to match the indicated DECL with the
2013 explicit template args given in TEMPLATE_ID. The DECL may be
2014 NULL_TREE if none is available. In that case, the functions in
2015 TEMPLATE_ID are non-members.
2017 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2018 specialization of a member template.
2020 The TEMPLATE_COUNT is the number of references to qualifying
2021 template classes that appeared in the name of the function. See
2022 check_explicit_specialization for a more accurate description.
2024 TSK indicates what kind of template declaration (if any) is being
2025 declared. TSK_TEMPLATE indicates that the declaration given by
2026 DECL, though a FUNCTION_DECL, has template parameters, and is
2027 therefore a template function.
2029 The template args (those explicitly specified and those deduced)
2030 are output in a newly created vector *TARGS_OUT.
2032 If it is impossible to determine the result, an error message is
2033 issued. The error_mark_node is returned to indicate failure. */
2036 determine_specialization (tree template_id
,
2039 int need_member_template
,
2045 tree explicit_targs
;
2046 tree candidates
= NULL_TREE
;
2048 /* A TREE_LIST of templates of which DECL may be a specialization.
2049 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2050 corresponding TREE_PURPOSE is the set of template arguments that,
2051 when used to instantiate the template, would produce a function
2052 with the signature of DECL. */
2053 tree templates
= NULL_TREE
;
2055 cp_binding_level
*b
;
2057 *targs_out
= NULL_TREE
;
2059 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
2060 return error_mark_node
;
2062 /* We shouldn't be specializing a member template of an
2063 unspecialized class template; we already gave an error in
2064 check_specialization_scope, now avoid crashing. */
2065 if (template_count
&& DECL_CLASS_SCOPE_P (decl
)
2066 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
2068 gcc_assert (errorcount
);
2069 return error_mark_node
;
2072 fns
= TREE_OPERAND (template_id
, 0);
2073 explicit_targs
= TREE_OPERAND (template_id
, 1);
2075 if (fns
== error_mark_node
)
2076 return error_mark_node
;
2078 /* Check for baselinks. */
2079 if (BASELINK_P (fns
))
2080 fns
= BASELINK_FUNCTIONS (fns
);
2082 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
2084 error ("%qD is not a function template", fns
);
2085 return error_mark_node
;
2087 else if (VAR_P (decl
) && !variable_template_p (fns
))
2089 error ("%qD is not a variable template", fns
);
2090 return error_mark_node
;
2093 /* Count the number of template headers specified for this
2096 for (b
= current_binding_level
;
2097 b
->kind
== sk_template_parms
;
2101 tree orig_fns
= fns
;
2103 if (variable_template_p (fns
))
2105 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns
));
2106 targs
= coerce_template_parms (parms
, explicit_targs
, fns
,
2107 tf_warning_or_error
,
2108 /*req_all*/true, /*use_defarg*/true);
2109 if (targs
!= error_mark_node
)
2110 templates
= tree_cons (targs
, fns
, templates
);
2112 else for (; fns
; fns
= OVL_NEXT (fns
))
2114 tree fn
= OVL_CURRENT (fns
);
2116 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2118 tree decl_arg_types
;
2122 /* In case of explicit specialization, we need to check if
2123 the number of template headers appearing in the specialization
2124 is correct. This is usually done in check_explicit_specialization,
2125 but the check done there cannot be exhaustive when specializing
2126 member functions. Consider the following code:
2128 template <> void A<int>::f(int);
2129 template <> template <> void A<int>::f(int);
2131 Assuming that A<int> is not itself an explicit specialization
2132 already, the first line specializes "f" which is a non-template
2133 member function, whilst the second line specializes "f" which
2134 is a template member function. So both lines are syntactically
2135 correct, and check_explicit_specialization does not reject
2138 Here, we can do better, as we are matching the specialization
2139 against the declarations. We count the number of template
2140 headers, and we check if they match TEMPLATE_COUNT + 1
2141 (TEMPLATE_COUNT is the number of qualifying template classes,
2142 plus there must be another header for the member template
2145 Notice that if header_count is zero, this is not a
2146 specialization but rather a template instantiation, so there
2147 is no check we can perform here. */
2148 if (header_count
&& header_count
!= template_count
+ 1)
2151 /* Check that the number of template arguments at the
2152 innermost level for DECL is the same as for FN. */
2153 if (current_binding_level
->kind
== sk_template_parms
2154 && !current_binding_level
->explicit_spec_p
2155 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
2156 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
2157 (current_template_parms
))))
2160 /* DECL might be a specialization of FN. */
2161 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2162 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2164 /* For a non-static member function, we need to make sure
2165 that the const qualification is the same. Since
2166 get_bindings does not try to merge the "this" parameter,
2167 we must do the comparison explicitly. */
2168 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2169 && !same_type_p (TREE_VALUE (fn_arg_types
),
2170 TREE_VALUE (decl_arg_types
)))
2173 /* Skip the "this" parameter and, for constructors of
2174 classes with virtual bases, the VTT parameter. A
2175 full specialization of a constructor will have a VTT
2176 parameter, but a template never will. */
2178 = skip_artificial_parms_for (decl
, decl_arg_types
);
2180 = skip_artificial_parms_for (fn
, fn_arg_types
);
2182 /* Function templates cannot be specializations; there are
2183 no partial specializations of functions. Therefore, if
2184 the type of DECL does not match FN, there is no
2187 Note that it should never be the case that we have both
2188 candidates added here, and for regular member functions
2190 if (tsk
== tsk_template
)
2192 if (compparms (fn_arg_types
, decl_arg_types
))
2193 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2197 /* See whether this function might be a specialization of this
2198 template. Suppress access control because we might be trying
2199 to make this specialization a friend, and we have already done
2200 access control for the declaration of the specialization. */
2201 push_deferring_access_checks (dk_no_check
);
2202 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
2203 pop_deferring_access_checks ();
2206 /* We cannot deduce template arguments that when used to
2207 specialize TMPL will produce DECL. */
2210 /* Remove, from the set of candidates, all those functions
2211 whose constraints are not satisfied. */
2212 if (flag_concepts
&& !constraints_satisfied_p (fn
, targs
))
2215 // Then, try to form the new function type.
2216 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_none
, NULL_TREE
);
2217 if (insttype
== error_mark_node
)
2220 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
2221 if (!compparms (fn_arg_types
, decl_arg_types
))
2224 /* Save this template, and the arguments deduced. */
2225 templates
= tree_cons (targs
, fn
, templates
);
2227 else if (need_member_template
)
2228 /* FN is an ordinary member function, and we need a
2229 specialization of a member template. */
2231 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2232 /* We can get IDENTIFIER_NODEs here in certain erroneous
2235 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2236 /* This is just an ordinary non-member function. Nothing can
2237 be a specialization of that. */
2239 else if (DECL_ARTIFICIAL (fn
))
2240 /* Cannot specialize functions that are created implicitly. */
2244 tree decl_arg_types
;
2246 /* This is an ordinary member function. However, since
2247 we're here, we can assume its enclosing class is a
2248 template class. For example,
2250 template <typename T> struct S { void f(); };
2251 template <> void S<int>::f() {}
2253 Here, S<int>::f is a non-template, but S<int> is a
2254 template class. If FN has the same type as DECL, we
2255 might be in business. */
2257 if (!DECL_TEMPLATE_INFO (fn
))
2258 /* Its enclosing class is an explicit specialization
2259 of a template class. This is not a candidate. */
2262 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2263 TREE_TYPE (TREE_TYPE (fn
))))
2264 /* The return types differ. */
2267 /* Adjust the type of DECL in case FN is a static member. */
2268 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2269 if (DECL_STATIC_FUNCTION_P (fn
)
2270 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2271 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2273 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2277 // If the deduced arguments do not satisfy the constraints,
2278 // this is not a candidate.
2279 if (flag_concepts
&& !constraints_satisfied_p (fn
))
2282 // Add the candidate.
2283 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2287 if (templates
&& TREE_CHAIN (templates
))
2293 It is possible for a specialization with a given function
2294 signature to be instantiated from more than one function
2295 template. In such cases, explicit specification of the
2296 template arguments must be used to uniquely identify the
2297 function template specialization being specialized.
2299 Note that here, there's no suggestion that we're supposed to
2300 determine which of the candidate templates is most
2301 specialized. However, we, also have:
2305 Partial ordering of overloaded function template
2306 declarations is used in the following contexts to select
2307 the function template to which a function template
2308 specialization refers:
2310 -- when an explicit specialization refers to a function
2313 So, we do use the partial ordering rules, at least for now.
2314 This extension can only serve to make invalid programs valid,
2315 so it's safe. And, there is strong anecdotal evidence that
2316 the committee intended the partial ordering rules to apply;
2317 the EDG front end has that behavior, and John Spicer claims
2318 that the committee simply forgot to delete the wording in
2319 [temp.expl.spec]. */
2320 tree tmpl
= most_specialized_instantiation (templates
);
2321 if (tmpl
!= error_mark_node
)
2324 TREE_CHAIN (templates
) = NULL_TREE
;
2328 // Concepts allows multiple declarations of member functions
2329 // with the same signature. Like above, we need to rely on
2330 // on the partial ordering of those candidates to determine which
2332 if (flag_concepts
&& candidates
&& TREE_CHAIN (candidates
))
2334 if (tree cand
= most_constrained_function (candidates
))
2337 TREE_CHAIN (cand
) = NULL_TREE
;
2341 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2343 error ("template-id %qD for %q+D does not match any template "
2344 "declaration", template_id
, decl
);
2345 if (header_count
&& header_count
!= template_count
+ 1)
2346 inform (input_location
, "saw %d %<template<>%>, need %d for "
2347 "specializing a member function template",
2348 header_count
, template_count
+ 1);
2350 print_candidates (orig_fns
);
2351 return error_mark_node
;
2353 else if ((templates
&& TREE_CHAIN (templates
))
2354 || (candidates
&& TREE_CHAIN (candidates
))
2355 || (templates
&& candidates
))
2357 error ("ambiguous template specialization %qD for %q+D",
2359 candidates
= chainon (candidates
, templates
);
2360 print_candidates (candidates
);
2361 return error_mark_node
;
2364 /* We have one, and exactly one, match. */
2367 tree fn
= TREE_VALUE (candidates
);
2368 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2370 // Propagate the candidate's constraints to the declaration.
2371 set_constraints (decl
, get_constraints (fn
));
2373 /* DECL is a re-declaration or partial instantiation of a template
2375 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2377 /* It was a specialization of an ordinary member function in a
2379 return DECL_TI_TEMPLATE (fn
);
2382 /* It was a specialization of a template. */
2383 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2384 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2386 *targs_out
= copy_node (targs
);
2387 SET_TMPL_ARGS_LEVEL (*targs_out
,
2388 TMPL_ARGS_DEPTH (*targs_out
),
2389 TREE_PURPOSE (templates
));
2392 *targs_out
= TREE_PURPOSE (templates
);
2393 return TREE_VALUE (templates
);
2396 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2397 but with the default argument values filled in from those in the
2401 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2404 tree new_spec_types
;
2409 if (spec_types
== void_list_node
)
2410 return void_list_node
;
2412 /* Substitute into the rest of the list. */
2414 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2415 TREE_CHAIN (tmpl_types
));
2417 /* Add the default argument for this parameter. */
2418 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2419 TREE_VALUE (spec_types
),
2423 /* DECL is an explicit specialization. Replicate default arguments
2424 from the template it specializes. (That way, code like:
2426 template <class T> void f(T = 3);
2427 template <> void f(double);
2430 works, as required.) An alternative approach would be to look up
2431 the correct default arguments at the call-site, but this approach
2432 is consistent with how implicit instantiations are handled. */
2435 copy_default_args_to_explicit_spec (tree decl
)
2440 tree new_spec_types
;
2444 tree object_type
= NULL_TREE
;
2445 tree in_charge
= NULL_TREE
;
2446 tree vtt
= NULL_TREE
;
2448 /* See if there's anything we need to do. */
2449 tmpl
= DECL_TI_TEMPLATE (decl
);
2450 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2451 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2452 if (TREE_PURPOSE (t
))
2457 old_type
= TREE_TYPE (decl
);
2458 spec_types
= TYPE_ARG_TYPES (old_type
);
2460 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2462 /* Remove the this pointer, but remember the object's type for
2464 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2465 spec_types
= TREE_CHAIN (spec_types
);
2466 tmpl_types
= TREE_CHAIN (tmpl_types
);
2468 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2470 /* DECL may contain more parameters than TMPL due to the extra
2471 in-charge parameter in constructors and destructors. */
2472 in_charge
= spec_types
;
2473 spec_types
= TREE_CHAIN (spec_types
);
2475 if (DECL_HAS_VTT_PARM_P (decl
))
2478 spec_types
= TREE_CHAIN (spec_types
);
2482 /* Compute the merged default arguments. */
2484 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2486 /* Compute the new FUNCTION_TYPE. */
2490 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2495 /* Put the in-charge parameter back. */
2496 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2497 TREE_VALUE (in_charge
),
2500 new_type
= build_method_type_directly (object_type
,
2501 TREE_TYPE (old_type
),
2505 new_type
= build_function_type (TREE_TYPE (old_type
),
2507 new_type
= cp_build_type_attribute_variant (new_type
,
2508 TYPE_ATTRIBUTES (old_type
));
2509 new_type
= build_exception_variant (new_type
,
2510 TYPE_RAISES_EXCEPTIONS (old_type
));
2512 if (TYPE_HAS_LATE_RETURN_TYPE (old_type
))
2513 TYPE_HAS_LATE_RETURN_TYPE (new_type
) = 1;
2515 TREE_TYPE (decl
) = new_type
;
2518 /* Return the number of template headers we expect to see for a definition
2519 or specialization of CTYPE or one of its non-template members. */
2522 num_template_headers_for_class (tree ctype
)
2524 int num_templates
= 0;
2526 while (ctype
&& CLASS_TYPE_P (ctype
))
2528 /* You're supposed to have one `template <...>' for every
2529 template class, but you don't need one for a full
2530 specialization. For example:
2532 template <class T> struct S{};
2533 template <> struct S<int> { void f(); };
2534 void S<int>::f () {}
2536 is correct; there shouldn't be a `template <>' for the
2537 definition of `S<int>::f'. */
2538 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2539 /* If CTYPE does not have template information of any
2540 kind, then it is not a template, nor is it nested
2541 within a template. */
2543 if (explicit_class_specialization_p (ctype
))
2545 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2548 ctype
= TYPE_CONTEXT (ctype
);
2551 return num_templates
;
2554 /* Do a simple sanity check on the template headers that precede the
2555 variable declaration DECL. */
2558 check_template_variable (tree decl
)
2560 tree ctx
= CP_DECL_CONTEXT (decl
);
2561 int wanted
= num_template_headers_for_class (ctx
);
2562 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2563 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2565 if (cxx_dialect
< cxx14
)
2566 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2567 "variable templates only available with "
2568 "-std=c++14 or -std=gnu++14");
2570 // Namespace-scope variable templates should have a template header.
2573 if (template_header_count
> wanted
)
2575 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2576 "too many template headers for %D (should be %d)",
2578 if (warned
&& CLASS_TYPE_P (ctx
)
2579 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2580 inform (DECL_SOURCE_LOCATION (decl
),
2581 "members of an explicitly specialized class are defined "
2582 "without a template header");
2586 /* Check to see if the function just declared, as indicated in
2587 DECLARATOR, and in DECL, is a specialization of a function
2588 template. We may also discover that the declaration is an explicit
2589 instantiation at this point.
2591 Returns DECL, or an equivalent declaration that should be used
2592 instead if all goes well. Issues an error message if something is
2593 amiss. Returns error_mark_node if the error is not easily
2596 FLAGS is a bitmask consisting of the following flags:
2598 2: The function has a definition.
2599 4: The function is a friend.
2601 The TEMPLATE_COUNT is the number of references to qualifying
2602 template classes that appeared in the name of the function. For
2605 template <class T> struct S { void f(); };
2608 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2609 classes are not counted in the TEMPLATE_COUNT, so that in
2611 template <class T> struct S {};
2612 template <> struct S<int> { void f(); }
2613 template <> void S<int>::f();
2615 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2616 invalid; there should be no template <>.)
2618 If the function is a specialization, it is marked as such via
2619 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2620 is set up correctly, and it is added to the list of specializations
2621 for that template. */
2624 check_explicit_specialization (tree declarator
,
2629 int have_def
= flags
& 2;
2630 int is_friend
= flags
& 4;
2631 bool is_concept
= flags
& 8;
2632 int specialization
= 0;
2633 int explicit_instantiation
= 0;
2634 int member_specialization
= 0;
2635 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2636 tree dname
= DECL_NAME (decl
);
2641 if (!processing_specialization
)
2644 tsk
= tsk_excessive_parms
;
2647 tsk
= current_tmpl_spec_kind (template_count
);
2652 if (processing_specialization
&& !VAR_P (decl
))
2655 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2657 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2660 /* This could be something like:
2662 template <class T> void f(T);
2663 class S { friend void f<>(int); } */
2667 /* This case handles bogus declarations like template <>
2668 template <class T> void f<int>(); */
2670 error ("template-id %qD in declaration of primary template",
2677 case tsk_invalid_member_spec
:
2678 /* The error has already been reported in
2679 check_specialization_scope. */
2680 return error_mark_node
;
2682 case tsk_invalid_expl_inst
:
2683 error ("template parameter list used in explicit instantiation");
2689 error ("definition provided for explicit instantiation");
2691 explicit_instantiation
= 1;
2694 case tsk_excessive_parms
:
2695 case tsk_insufficient_parms
:
2696 if (tsk
== tsk_excessive_parms
)
2697 error ("too many template parameter lists in declaration of %qD",
2699 else if (template_header_count
)
2700 error("too few template parameter lists in declaration of %qD", decl
);
2702 error("explicit specialization of %qD must be introduced by "
2703 "%<template <>%>", decl
);
2708 error ("explicit specialization declared %<concept%>");
2710 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2711 /* In cases like template<> constexpr bool v = true;
2712 We'll give an error in check_template_variable. */
2715 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2717 member_specialization
= 1;
2723 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2725 /* This case handles bogus declarations like template <>
2726 template <class T> void f<int>(); */
2728 if (!uses_template_parms (declarator
))
2729 error ("template-id %qD in declaration of primary template",
2731 else if (variable_template_p (TREE_OPERAND (declarator
, 0)))
2733 /* Partial specialization of variable template. */
2734 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2738 else if (cxx_dialect
< cxx14
)
2739 error ("non-type partial specialization %qD "
2740 "is not allowed", declarator
);
2742 error ("non-class, non-variable partial specialization %qD "
2743 "is not allowed", declarator
);
2748 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2749 /* This is a specialization of a member template, without
2750 specialization the containing class. Something like:
2752 template <class T> struct S {
2753 template <class U> void f (U);
2755 template <> template <class U> void S<int>::f(U) {}
2757 That's a specialization -- but of the entire template. */
2765 if ((specialization
|| member_specialization
)
2766 /* This doesn't apply to variable templates. */
2767 && (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
2768 || TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
))
2770 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2771 for (; t
; t
= TREE_CHAIN (t
))
2772 if (TREE_PURPOSE (t
))
2774 permerror (input_location
,
2775 "default argument specified in explicit specialization");
2780 if (specialization
|| member_specialization
|| explicit_instantiation
)
2782 tree tmpl
= NULL_TREE
;
2783 tree targs
= NULL_TREE
;
2784 bool was_template_id
= (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
);
2786 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2787 if (!was_template_id
)
2791 gcc_assert (identifier_p (declarator
));
2796 /* If there is no class context, the explicit instantiation
2797 must be at namespace scope. */
2798 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2800 /* Find the namespace binding, using the declaration
2802 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2804 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2806 error ("%qD is not a template function", dname
);
2807 fns
= error_mark_node
;
2811 declarator
= lookup_template_function (fns
, NULL_TREE
);
2814 if (declarator
== error_mark_node
)
2815 return error_mark_node
;
2817 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2819 if (!explicit_instantiation
)
2820 /* A specialization in class scope. This is invalid,
2821 but the error will already have been flagged by
2822 check_specialization_scope. */
2823 return error_mark_node
;
2826 /* It's not valid to write an explicit instantiation in
2829 class C { template void f(); }
2831 This case is caught by the parser. However, on
2834 template class C { void f(); };
2836 (which is invalid) we can get here. The error will be
2843 else if (ctype
!= NULL_TREE
2844 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2846 // We'll match variable templates in start_decl.
2850 /* Find the list of functions in ctype that have the same
2851 name as the declared function. */
2852 tree name
= TREE_OPERAND (declarator
, 0);
2853 tree fns
= NULL_TREE
;
2856 if (constructor_name_p (name
, ctype
))
2858 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
2860 if (is_constructor
? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2861 : !CLASSTYPE_DESTRUCTORS (ctype
))
2863 /* From [temp.expl.spec]:
2865 If such an explicit specialization for the member
2866 of a class template names an implicitly-declared
2867 special member function (clause _special_), the
2868 program is ill-formed.
2870 Similar language is found in [temp.explicit]. */
2871 error ("specialization of implicitly-declared special member function");
2872 return error_mark_node
;
2875 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
2878 if (!DECL_CONV_FN_P (decl
))
2880 idx
= lookup_fnfields_1 (ctype
, name
);
2882 fns
= (*CLASSTYPE_METHOD_VEC (ctype
))[idx
];
2886 vec
<tree
, va_gc
> *methods
;
2889 /* For a type-conversion operator, we cannot do a
2890 name-based lookup. We might be looking for `operator
2891 int' which will be a specialization of `operator T'.
2892 So, we find *all* the conversion operators, and then
2893 select from them. */
2896 methods
= CLASSTYPE_METHOD_VEC (ctype
);
2898 for (idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2899 methods
->iterate (idx
, &ovl
);
2902 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
2903 /* There are no more conversion functions. */
2906 /* Glue all these conversion functions together
2907 with those we already have. */
2908 for (; ovl
; ovl
= OVL_NEXT (ovl
))
2909 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
2913 if (fns
== NULL_TREE
)
2915 error ("no member function %qD declared in %qT", name
, ctype
);
2916 return error_mark_node
;
2919 TREE_OPERAND (declarator
, 0) = fns
;
2922 /* Figure out what exactly is being specialized at this point.
2923 Note that for an explicit instantiation, even one for a
2924 member function, we cannot tell apriori whether the
2925 instantiation is for a member template, or just a member
2926 function of a template class. Even if a member template is
2927 being instantiated, the member template arguments may be
2928 elided if they can be deduced from the rest of the
2930 tmpl
= determine_specialization (declarator
, decl
,
2932 member_specialization
,
2936 if (!tmpl
|| tmpl
== error_mark_node
)
2937 /* We couldn't figure out what this declaration was
2939 return error_mark_node
;
2942 if (!ctype
&& !was_template_id
2943 && (specialization
|| member_specialization
2944 || explicit_instantiation
)
2945 && !is_associated_namespace (CP_DECL_CONTEXT (decl
),
2946 CP_DECL_CONTEXT (tmpl
)))
2947 error ("%qD is not declared in %qD",
2948 tmpl
, current_namespace
);
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 /* Structure used to track the progress of find_parameter_packs_r. */
3388 struct find_parameter_pack_data
3390 /* TREE_LIST that will contain all of the parameter packs found by
3392 tree
* parameter_packs
;
3394 /* Set of AST nodes that have been visited by the traversal. */
3395 hash_set
<tree
> *visited
;
3397 /* True iff we're making a type pack expansion. */
3398 bool type_pack_expansion_p
;
3401 /* Identifies all of the argument packs that occur in a template
3402 argument and appends them to the TREE_LIST inside DATA, which is a
3403 find_parameter_pack_data structure. This is a subroutine of
3404 make_pack_expansion and uses_parameter_packs. */
3406 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3409 struct find_parameter_pack_data
* ppd
=
3410 (struct find_parameter_pack_data
*)data
;
3411 bool parameter_pack_p
= false;
3413 /* Handle type aliases/typedefs. */
3414 if (TYPE_ALIAS_P (t
))
3416 if (TYPE_TEMPLATE_INFO (t
))
3417 cp_walk_tree (&TYPE_TI_ARGS (t
),
3418 &find_parameter_packs_r
,
3424 /* Identify whether this is a parameter pack or not. */
3425 switch (TREE_CODE (t
))
3427 case TEMPLATE_PARM_INDEX
:
3428 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3429 parameter_pack_p
= true;
3432 case TEMPLATE_TYPE_PARM
:
3433 t
= TYPE_MAIN_VARIANT (t
);
3434 case TEMPLATE_TEMPLATE_PARM
:
3435 /* If the placeholder appears in the decl-specifier-seq of a function
3436 parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3437 is a pack expansion, the invented template parameter is a template
3439 if (ppd
->type_pack_expansion_p
&& is_auto_or_concept (t
))
3440 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
3441 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3442 parameter_pack_p
= true;
3447 if (DECL_PACK_P (t
))
3449 /* We don't want to walk into the type of a PARM_DECL,
3450 because we don't want to see the type parameter pack. */
3452 parameter_pack_p
= true;
3456 /* Look through a lambda capture proxy to the field pack. */
3458 if (DECL_HAS_VALUE_EXPR_P (t
))
3460 tree v
= DECL_VALUE_EXPR (t
);
3462 &find_parameter_packs_r
,
3466 else if (variable_template_specialization_p (t
))
3468 cp_walk_tree (&DECL_TI_ARGS (t
),
3469 find_parameter_packs_r
,
3476 parameter_pack_p
= true;
3479 /* Not a parameter pack. */
3483 if (parameter_pack_p
)
3485 /* Add this parameter pack to the list. */
3486 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3490 cp_walk_tree (&TYPE_CONTEXT (t
),
3491 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3493 /* This switch statement will return immediately if we don't find a
3495 switch (TREE_CODE (t
))
3497 case TEMPLATE_PARM_INDEX
:
3500 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3501 /* Check the template itself. */
3502 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3503 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3504 /* Check the template arguments. */
3505 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3510 case TEMPLATE_TYPE_PARM
:
3511 case TEMPLATE_TEMPLATE_PARM
:
3518 if (TYPE_PTRMEMFUNC_P (t
))
3524 if (TYPE_TEMPLATE_INFO (t
))
3525 cp_walk_tree (&TYPE_TI_ARGS (t
),
3526 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3533 cp_walk_tree (&TREE_TYPE (t
),
3534 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3538 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3543 case TYPE_PACK_EXPANSION
:
3544 case EXPR_PACK_EXPANSION
:
3549 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3554 case IDENTIFIER_NODE
:
3555 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3562 /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
3563 type_pack_expansion_p to false so that any placeholders
3564 within the expression don't get marked as parameter packs. */
3565 bool type_pack_expansion_p
= ppd
->type_pack_expansion_p
;
3566 ppd
->type_pack_expansion_p
= false;
3567 cp_walk_tree (&DECLTYPE_TYPE_EXPR (t
), &find_parameter_packs_r
,
3569 ppd
->type_pack_expansion_p
= type_pack_expansion_p
;
3581 /* Determines if the expression or type T uses any parameter packs. */
3583 uses_parameter_packs (tree t
)
3585 tree parameter_packs
= NULL_TREE
;
3586 struct find_parameter_pack_data ppd
;
3587 ppd
.parameter_packs
= ¶meter_packs
;
3588 ppd
.visited
= new hash_set
<tree
>;
3589 ppd
.type_pack_expansion_p
= false;
3590 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3592 return parameter_packs
!= NULL_TREE
;
3595 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3596 representation a base-class initializer into a parameter pack
3597 expansion. If all goes well, the resulting node will be an
3598 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3601 make_pack_expansion (tree arg
)
3604 tree parameter_packs
= NULL_TREE
;
3605 bool for_types
= false;
3606 struct find_parameter_pack_data ppd
;
3608 if (!arg
|| arg
== error_mark_node
)
3611 if (TREE_CODE (arg
) == TREE_LIST
&& TREE_PURPOSE (arg
))
3613 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3614 class initializer. In this case, the TREE_PURPOSE will be a
3615 _TYPE node (representing the base class expansion we're
3616 initializing) and the TREE_VALUE will be a TREE_LIST
3617 containing the initialization arguments.
3619 The resulting expansion looks somewhat different from most
3620 expansions. Rather than returning just one _EXPANSION, we
3621 return a TREE_LIST whose TREE_PURPOSE is a
3622 TYPE_PACK_EXPANSION containing the bases that will be
3623 initialized. The TREE_VALUE will be identical to the
3624 original TREE_VALUE, which is a list of arguments that will
3625 be passed to each base. We do not introduce any new pack
3626 expansion nodes into the TREE_VALUE (although it is possible
3627 that some already exist), because the TREE_PURPOSE and
3628 TREE_VALUE all need to be expanded together with the same
3629 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3630 resulting TREE_PURPOSE will mention the parameter packs in
3631 both the bases and the arguments to the bases. */
3634 tree parameter_packs
= NULL_TREE
;
3636 /* Determine which parameter packs will be used by the base
3638 ppd
.visited
= new hash_set
<tree
>;
3639 ppd
.parameter_packs
= ¶meter_packs
;
3640 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3643 if (parameter_packs
== NULL_TREE
)
3645 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
3647 return error_mark_node
;
3650 if (TREE_VALUE (arg
) != void_type_node
)
3652 /* Collect the sets of parameter packs used in each of the
3653 initialization arguments. */
3654 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3656 /* Determine which parameter packs will be expanded in this
3658 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3665 /* Create the pack expansion type for the base type. */
3666 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3667 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3668 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3670 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3671 they will rarely be compared to anything. */
3672 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3674 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3677 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3680 /* Build the PACK_EXPANSION_* node. */
3682 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3683 : make_node (EXPR_PACK_EXPANSION
);
3684 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3685 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3687 /* Propagate type and const-expression information. */
3688 TREE_TYPE (result
) = TREE_TYPE (arg
);
3689 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3692 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3693 they will rarely be compared to anything. */
3694 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3696 /* Determine which parameter packs will be expanded. */
3697 ppd
.parameter_packs
= ¶meter_packs
;
3698 ppd
.visited
= new hash_set
<tree
>;
3699 ppd
.type_pack_expansion_p
= TYPE_P (arg
);
3700 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3703 /* Make sure we found some parameter packs. */
3704 if (parameter_packs
== NULL_TREE
)
3707 error ("expansion pattern %<%T%> contains no argument packs", arg
);
3709 error ("expansion pattern %<%E%> contains no argument packs", arg
);
3710 return error_mark_node
;
3712 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3714 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3719 /* Checks T for any "bare" parameter packs, which have not yet been
3720 expanded, and issues an error if any are found. This operation can
3721 only be done on full expressions or types (e.g., an expression
3722 statement, "if" condition, etc.), because we could have expressions like:
3724 foo(f(g(h(args)))...)
3726 where "args" is a parameter pack. check_for_bare_parameter_packs
3727 should not be called for the subexpressions args, h(args),
3728 g(h(args)), or f(g(h(args))), because we would produce erroneous
3731 Returns TRUE and emits an error if there were bare parameter packs,
3732 returns FALSE otherwise. */
3734 check_for_bare_parameter_packs (tree t
)
3736 tree parameter_packs
= NULL_TREE
;
3737 struct find_parameter_pack_data ppd
;
3739 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3742 if (TREE_CODE (t
) == TYPE_DECL
)
3745 ppd
.parameter_packs
= ¶meter_packs
;
3746 ppd
.visited
= new hash_set
<tree
>;
3747 ppd
.type_pack_expansion_p
= false;
3748 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3751 if (parameter_packs
)
3753 error ("parameter packs not expanded with %<...%>:");
3754 while (parameter_packs
)
3756 tree pack
= TREE_VALUE (parameter_packs
);
3757 tree name
= NULL_TREE
;
3759 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3760 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3761 name
= TYPE_NAME (pack
);
3762 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3763 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3765 name
= DECL_NAME (pack
);
3768 inform (input_location
, " %qD", name
);
3770 inform (input_location
, " <anonymous>");
3772 parameter_packs
= TREE_CHAIN (parameter_packs
);
3781 /* Expand any parameter packs that occur in the template arguments in
3784 expand_template_argument_pack (tree args
)
3786 tree result_args
= NULL_TREE
;
3787 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3788 int num_result_args
= -1;
3789 int non_default_args_count
= -1;
3791 /* First, determine if we need to expand anything, and the number of
3792 slots we'll need. */
3793 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3795 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3796 if (arg
== NULL_TREE
)
3798 if (ARGUMENT_PACK_P (arg
))
3800 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3801 if (num_result_args
< 0)
3802 num_result_args
= in_arg
+ num_packed
;
3804 num_result_args
+= num_packed
;
3808 if (num_result_args
>= 0)
3813 /* If no expansion is necessary, we're done. */
3814 if (num_result_args
< 0)
3817 /* Expand arguments. */
3818 result_args
= make_tree_vec (num_result_args
);
3819 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3820 non_default_args_count
=
3821 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3822 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3824 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3825 if (ARGUMENT_PACK_P (arg
))
3827 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3828 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3829 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3830 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3831 if (non_default_args_count
> 0)
3832 non_default_args_count
+= num_packed
- 1;
3836 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3840 if (non_default_args_count
>= 0)
3841 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3845 /* Checks if DECL shadows a template parameter.
3847 [temp.local]: A template-parameter shall not be redeclared within its
3848 scope (including nested scopes).
3850 Emits an error and returns TRUE if the DECL shadows a parameter,
3851 returns FALSE otherwise. */
3854 check_template_shadow (tree decl
)
3858 /* If we're not in a template, we can't possibly shadow a template
3860 if (!current_template_parms
)
3863 /* Figure out what we're shadowing. */
3864 if (TREE_CODE (decl
) == OVERLOAD
)
3865 decl
= OVL_CURRENT (decl
);
3866 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
3868 /* If there's no previous binding for this name, we're not shadowing
3869 anything, let alone a template parameter. */
3873 /* If we're not shadowing a template parameter, we're done. Note
3874 that OLDDECL might be an OVERLOAD (or perhaps even an
3875 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3877 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
3880 /* We check for decl != olddecl to avoid bogus errors for using a
3881 name inside a class. We check TPFI to avoid duplicate errors for
3882 inline member templates. */
3884 || (DECL_TEMPLATE_PARM_P (decl
)
3885 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
3888 /* Don't complain about the injected class name, as we've already
3889 complained about the class itself. */
3890 if (DECL_SELF_REFERENCE_P (decl
))
3893 if (DECL_TEMPLATE_PARM_P (decl
))
3894 error ("declaration of template parameter %q+D shadows "
3895 "template parameter", decl
);
3897 error ("declaration of %q+#D shadows template parameter", decl
);
3898 inform (DECL_SOURCE_LOCATION (olddecl
),
3899 "template parameter %qD declared here", olddecl
);
3903 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3904 ORIG_LEVEL, DECL, and TYPE. */
3907 build_template_parm_index (int index
,
3913 tree t
= make_node (TEMPLATE_PARM_INDEX
);
3914 TEMPLATE_PARM_IDX (t
) = index
;
3915 TEMPLATE_PARM_LEVEL (t
) = level
;
3916 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
3917 TEMPLATE_PARM_DECL (t
) = decl
;
3918 TREE_TYPE (t
) = type
;
3919 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
3920 TREE_READONLY (t
) = TREE_READONLY (decl
);
3925 /* Find the canonical type parameter for the given template type
3926 parameter. Returns the canonical type parameter, which may be TYPE
3927 if no such parameter existed. */
3930 canonical_type_parameter (tree type
)
3933 int idx
= TEMPLATE_TYPE_IDX (type
);
3934 if (!canonical_template_parms
)
3935 vec_alloc (canonical_template_parms
, idx
+1);
3937 while (canonical_template_parms
->length () <= (unsigned)idx
)
3938 vec_safe_push (canonical_template_parms
, NULL_TREE
);
3940 list
= (*canonical_template_parms
)[idx
];
3941 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
3942 list
= TREE_CHAIN (list
);
3945 return TREE_VALUE (list
);
3948 (*canonical_template_parms
)[idx
]
3949 = tree_cons (NULL_TREE
, type
,
3950 (*canonical_template_parms
)[idx
]);
3955 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3956 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3957 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3958 new one is created. */
3961 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
3962 tsubst_flags_t complain
)
3964 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
3965 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
3966 != TEMPLATE_PARM_LEVEL (index
) - levels
)
3967 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
3969 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
3972 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
3973 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
3974 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
3975 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
3976 DECL_ARTIFICIAL (decl
) = 1;
3977 SET_DECL_TEMPLATE_PARM_P (decl
);
3979 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
3980 TEMPLATE_PARM_LEVEL (index
) - levels
,
3981 TEMPLATE_PARM_ORIG_LEVEL (index
),
3983 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
3984 TEMPLATE_PARM_PARAMETER_PACK (t
)
3985 = TEMPLATE_PARM_PARAMETER_PACK (index
);
3987 /* Template template parameters need this. */
3988 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3990 DECL_TEMPLATE_RESULT (decl
)
3991 = build_decl (DECL_SOURCE_LOCATION (decl
),
3992 TYPE_DECL
, DECL_NAME (decl
), type
);
3993 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (decl
)) = true;
3994 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
3995 (DECL_TEMPLATE_PARMS (orig_decl
), args
, complain
);
3999 return TEMPLATE_PARM_DESCENDANTS (index
);
4002 /* Process information from new template parameter PARM and append it
4003 to the LIST being built. This new parameter is a non-type
4004 parameter iff IS_NON_TYPE is true. This new parameter is a
4005 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4009 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
4010 bool is_non_type
, bool is_parameter_pack
)
4015 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
4016 tree defval
= TREE_PURPOSE (parm
);
4017 tree constr
= TREE_TYPE (parm
);
4021 tree p
= tree_last (list
);
4023 if (p
&& TREE_VALUE (p
) != error_mark_node
)
4026 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
4027 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
4029 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
4037 parm
= TREE_VALUE (parm
);
4039 SET_DECL_TEMPLATE_PARM_P (parm
);
4041 if (TREE_TYPE (parm
) != error_mark_node
)
4045 The top-level cv-qualifiers on the template-parameter are
4046 ignored when determining its type. */
4047 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
4048 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
4049 TREE_TYPE (parm
) = error_mark_node
;
4050 else if (uses_parameter_packs (TREE_TYPE (parm
))
4051 && !is_parameter_pack
4052 /* If we're in a nested template parameter list, the template
4053 template parameter could be a parameter pack. */
4054 && processing_template_parmlist
== 1)
4056 /* This template parameter is not a parameter pack, but it
4057 should be. Complain about "bare" parameter packs. */
4058 check_for_bare_parameter_packs (TREE_TYPE (parm
));
4060 /* Recover by calling this a parameter pack. */
4061 is_parameter_pack
= true;
4065 /* A template parameter is not modifiable. */
4066 TREE_CONSTANT (parm
) = 1;
4067 TREE_READONLY (parm
) = 1;
4068 decl
= build_decl (parm_loc
,
4069 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
4070 TREE_CONSTANT (decl
) = 1;
4071 TREE_READONLY (decl
) = 1;
4072 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
4073 = build_template_parm_index (idx
, processing_template_decl
,
4074 processing_template_decl
,
4075 decl
, TREE_TYPE (parm
));
4077 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
4078 = is_parameter_pack
;
4083 parm
= TREE_VALUE (TREE_VALUE (parm
));
4085 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
4087 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
4088 /* This is for distinguishing between real templates and template
4089 template parameters */
4090 TREE_TYPE (parm
) = t
;
4091 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
4096 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
4097 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4098 decl
= build_decl (parm_loc
,
4099 TYPE_DECL
, parm
, t
);
4102 TYPE_NAME (t
) = decl
;
4103 TYPE_STUB_DECL (t
) = decl
;
4105 TEMPLATE_TYPE_PARM_INDEX (t
)
4106 = build_template_parm_index (idx
, processing_template_decl
,
4107 processing_template_decl
,
4108 decl
, TREE_TYPE (parm
));
4109 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
4110 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
4112 DECL_ARTIFICIAL (decl
) = 1;
4113 SET_DECL_TEMPLATE_PARM_P (decl
);
4115 /* Build requirements for the type/template parameter.
4116 This must be done after SET_DECL_TEMPLATE_PARM_P or
4117 process_template_parm could fail. */
4118 tree reqs
= finish_shorthand_constraint (parm
, constr
);
4122 /* Build the parameter node linking the parameter declaration,
4123 its default argument (if any), and its constraints (if any). */
4124 parm
= build_tree_list (defval
, parm
);
4125 TEMPLATE_PARM_CONSTRAINTS (parm
) = reqs
;
4127 return chainon (list
, parm
);
4130 /* The end of a template parameter list has been reached. Process the
4131 tree list into a parameter vector, converting each parameter into a more
4132 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4136 end_template_parm_list (tree parms
)
4140 tree saved_parmlist
= make_tree_vec (list_length (parms
));
4142 /* Pop the dummy parameter level and add the real one. */
4143 current_template_parms
= TREE_CHAIN (current_template_parms
);
4145 current_template_parms
4146 = tree_cons (size_int (processing_template_decl
),
4147 saved_parmlist
, current_template_parms
);
4149 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
4151 next
= TREE_CHAIN (parm
);
4152 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
4153 TREE_CHAIN (parm
) = NULL_TREE
;
4156 --processing_template_parmlist
;
4158 return saved_parmlist
;
4161 // Explicitly indicate the end of the template parameter list. We assume
4162 // that the current template parameters have been constructed and/or
4163 // managed explicitly, as when creating new template template parameters
4164 // from a shorthand constraint.
4166 end_template_parm_list ()
4168 --processing_template_parmlist
;
4171 /* end_template_decl is called after a template declaration is seen. */
4174 end_template_decl (void)
4176 reset_specialization ();
4178 if (! processing_template_decl
)
4181 /* This matches the pushlevel in begin_template_parm_list. */
4184 --processing_template_decl
;
4185 current_template_parms
= TREE_CHAIN (current_template_parms
);
4188 /* Takes a TREE_LIST representing a template parameter and convert it
4189 into an argument suitable to be passed to the type substitution
4190 functions. Note that If the TREE_LIST contains an error_mark
4191 node, the returned argument is error_mark_node. */
4194 template_parm_to_arg (tree t
)
4198 || TREE_CODE (t
) != TREE_LIST
)
4201 if (error_operand_p (TREE_VALUE (t
)))
4202 return error_mark_node
;
4206 if (TREE_CODE (t
) == TYPE_DECL
4207 || TREE_CODE (t
) == TEMPLATE_DECL
)
4211 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
4213 /* Turn this argument into a TYPE_ARGUMENT_PACK
4214 with a single element, which expands T. */
4215 tree vec
= make_tree_vec (1);
4217 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4219 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4221 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
4222 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4227 t
= DECL_INITIAL (t
);
4229 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
4231 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4232 with a single element, which expands T. */
4233 tree vec
= make_tree_vec (1);
4234 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
4236 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4238 t
= convert_from_reference (t
);
4239 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4241 t
= make_node (NONTYPE_ARGUMENT_PACK
);
4242 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4243 TREE_TYPE (t
) = type
;
4246 t
= convert_from_reference (t
);
4251 /* Given a set of template parameters, return them as a set of template
4252 arguments. The template parameters are represented as a TREE_VEC, in
4253 the form documented in cp-tree.h for template arguments. */
4256 template_parms_to_args (tree parms
)
4259 tree args
= NULL_TREE
;
4260 int length
= TMPL_PARMS_DEPTH (parms
);
4263 /* If there is only one level of template parameters, we do not
4264 create a TREE_VEC of TREE_VECs. Instead, we return a single
4265 TREE_VEC containing the arguments. */
4267 args
= make_tree_vec (length
);
4269 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
4271 tree a
= copy_node (TREE_VALUE (header
));
4274 TREE_TYPE (a
) = NULL_TREE
;
4275 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
4276 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
4279 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
4282 TREE_VEC_ELT (args
, --l
) = a
;
4290 /* Within the declaration of a template, return the currently active
4291 template parameters as an argument TREE_VEC. */
4294 current_template_args (void)
4296 return template_parms_to_args (current_template_parms
);
4299 /* Update the declared TYPE by doing any lookups which were thought to be
4300 dependent, but are not now that we know the SCOPE of the declarator. */
4303 maybe_update_decl_type (tree orig_type
, tree scope
)
4305 tree type
= orig_type
;
4307 if (type
== NULL_TREE
)
4310 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4311 type
= TREE_TYPE (type
);
4313 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
4314 && dependent_type_p (type
)
4315 /* Don't bother building up the args in this case. */
4316 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
4318 /* tsubst in the args corresponding to the template parameters,
4319 including auto if present. Most things will be unchanged, but
4320 make_typename_type and tsubst_qualified_id will resolve
4321 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4322 tree args
= current_template_args ();
4323 tree auto_node
= type_uses_auto (type
);
4327 tree auto_vec
= make_tree_vec (1);
4328 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4329 args
= add_to_template_args (args
, auto_vec
);
4331 pushed
= push_scope (scope
);
4332 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4337 if (type
== error_mark_node
)
4340 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4342 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4345 type
= TYPE_NAME (type
);
4350 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4351 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4352 the new template is a member template. */
4355 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4357 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4358 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4359 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4360 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4361 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4366 struct template_parm_data
4368 /* The level of the template parameters we are currently
4372 /* The index of the specialization argument we are currently
4376 /* An array whose size is the number of template parameters. The
4377 elements are nonzero if the parameter has been used in any one
4378 of the arguments processed so far. */
4381 /* An array whose size is the number of template arguments. The
4382 elements are nonzero if the argument makes use of template
4383 parameters of this level. */
4384 int* arg_uses_template_parms
;
4387 /* Subroutine of push_template_decl used to see if each template
4388 parameter in a partial specialization is used in the explicit
4389 argument list. If T is of the LEVEL given in DATA (which is
4390 treated as a template_parm_data*), then DATA->PARMS is marked
4394 mark_template_parm (tree t
, void* data
)
4398 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4400 template_parm_level_and_index (t
, &level
, &idx
);
4402 if (level
== tpd
->level
)
4404 tpd
->parms
[idx
] = 1;
4405 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4408 /* Return zero so that for_each_template_parm will continue the
4409 traversal of the tree; we want to mark *every* template parm. */
4413 /* Process the partial specialization DECL. */
4416 process_partial_specialization (tree decl
)
4418 tree type
= TREE_TYPE (decl
);
4419 tree tinfo
= get_template_info (decl
);
4420 tree maintmpl
= TI_TEMPLATE (tinfo
);
4421 tree specargs
= TI_ARGS (tinfo
);
4422 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4423 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4426 int nargs
= TREE_VEC_LENGTH (inner_args
);
4429 bool did_error_intro
= false;
4430 struct template_parm_data tpd
;
4431 struct template_parm_data tpd2
;
4433 gcc_assert (current_template_parms
);
4435 /* A concept cannot be specialized. */
4436 if (flag_concepts
&& variable_concept_p (maintmpl
))
4438 error ("specialization of variable concept %q#D", maintmpl
);
4439 return error_mark_node
;
4442 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4443 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4445 /* We check that each of the template parameters given in the
4446 partial specialization is used in the argument list to the
4447 specialization. For example:
4449 template <class T> struct S;
4450 template <class T> struct S<T*>;
4452 The second declaration is OK because `T*' uses the template
4453 parameter T, whereas
4455 template <class T> struct S<int>;
4457 is no good. Even trickier is:
4468 The S2<T> declaration is actually invalid; it is a
4469 full-specialization. Of course,
4472 struct S2<T (*)(U)>;
4474 or some such would have been OK. */
4475 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4476 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4477 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4479 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4480 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4481 for (i
= 0; i
< nargs
; ++i
)
4483 tpd
.current_arg
= i
;
4484 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4485 &mark_template_parm
,
4488 /*include_nondeduced_p=*/false);
4490 for (i
= 0; i
< ntparms
; ++i
)
4491 if (tpd
.parms
[i
] == 0)
4493 /* One of the template parms was not used in a deduced context in the
4495 if (!did_error_intro
)
4497 error ("template parameters not deducible in "
4498 "partial specialization:");
4499 did_error_intro
= true;
4502 inform (input_location
, " %qD",
4503 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4506 if (did_error_intro
)
4507 return error_mark_node
;
4509 /* [temp.class.spec]
4511 The argument list of the specialization shall not be identical to
4512 the implicit argument list of the primary template. */
4514 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl
)));
4515 if (comp_template_args (inner_args
, INNERMOST_TEMPLATE_ARGS (main_args
))
4517 || !strictly_subsumes (current_template_constraints (),
4518 get_constraints (maintmpl
))))
4521 error ("partial specialization %q+D does not specialize "
4522 "any template arguments", decl
);
4524 error ("partial specialization %q+D does not specialize any "
4525 "template arguments and is not more constrained than", decl
);
4526 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4529 /* A partial specialization that replaces multiple parameters of the
4530 primary template with a pack expansion is less specialized for those
4532 if (nargs
< DECL_NTPARMS (maintmpl
))
4534 error ("partial specialization is not more specialized than the "
4535 "primary template because it replaces multiple parameters "
4536 "with a pack expansion");
4537 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4541 /* [temp.class.spec]
4543 A partially specialized non-type argument expression shall not
4544 involve template parameters of the partial specialization except
4545 when the argument expression is a simple identifier.
4547 The type of a template parameter corresponding to a specialized
4548 non-type argument shall not be dependent on a parameter of the
4551 Also, we verify that pack expansions only occur at the
4552 end of the argument list. */
4553 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4555 for (i
= 0; i
< nargs
; ++i
)
4557 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4558 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4559 tree packed_args
= NULL_TREE
;
4562 if (ARGUMENT_PACK_P (arg
))
4564 /* Extract the arguments from the argument pack. We'll be
4565 iterating over these in the following loop. */
4566 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4567 len
= TREE_VEC_LENGTH (packed_args
);
4570 for (j
= 0; j
< len
; j
++)
4573 /* Get the Jth argument in the parameter pack. */
4574 arg
= TREE_VEC_ELT (packed_args
, j
);
4576 if (PACK_EXPANSION_P (arg
))
4578 /* Pack expansions must come at the end of the
4580 if ((packed_args
&& j
< len
- 1)
4581 || (!packed_args
&& i
< nargs
- 1))
4583 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4584 error ("parameter pack argument %qE must be at the "
4585 "end of the template argument list", arg
);
4587 error ("parameter pack argument %qT must be at the "
4588 "end of the template argument list", arg
);
4592 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4593 /* We only care about the pattern. */
4594 arg
= PACK_EXPANSION_PATTERN (arg
);
4596 if (/* These first two lines are the `non-type' bit. */
4598 && TREE_CODE (arg
) != TEMPLATE_DECL
4599 /* This next two lines are the `argument expression is not just a
4600 simple identifier' condition and also the `specialized
4601 non-type argument' bit. */
4602 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4603 && !(REFERENCE_REF_P (arg
)
4604 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4606 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4607 || (packed_args
&& uses_template_parms (arg
)))
4608 error ("template argument %qE involves template parameter(s)",
4612 /* Look at the corresponding template parameter,
4613 marking which template parameters its type depends
4615 tree type
= TREE_TYPE (parm
);
4619 /* We haven't yet initialized TPD2. Do so now. */
4620 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4621 /* The number of parameters here is the number in the
4622 main template, which, as checked in the assertion
4624 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4626 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4629 /* Mark the template parameters. But this time, we're
4630 looking for the template parameters of the main
4631 template, not in the specialization. */
4632 tpd2
.current_arg
= i
;
4633 tpd2
.arg_uses_template_parms
[i
] = 0;
4634 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4635 for_each_template_parm (type
,
4636 &mark_template_parm
,
4639 /*include_nondeduced_p=*/false);
4641 if (tpd2
.arg_uses_template_parms
[i
])
4643 /* The type depended on some template parameters.
4644 If they are fully specialized in the
4645 specialization, that's OK. */
4648 for (j
= 0; j
< nargs
; ++j
)
4649 if (tpd2
.parms
[j
] != 0
4650 && tpd
.arg_uses_template_parms
[j
])
4653 error_n (input_location
, count
,
4654 "type %qT of template argument %qE depends "
4655 "on a template parameter",
4656 "type %qT of template argument %qE depends "
4657 "on template parameters",
4666 /* We should only get here once. */
4667 if (TREE_CODE (decl
) == TYPE_DECL
)
4668 gcc_assert (!COMPLETE_TYPE_P (type
));
4670 // Build the template decl.
4671 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4672 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4673 TREE_TYPE (tmpl
) = type
;
4674 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4675 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4676 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4677 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4680 /* We didn't register this in check_explicit_specialization so we could
4681 wait until the constraints were set. */
4682 decl
= register_specialization (decl
, maintmpl
, specargs
, false, 0);
4684 associate_classtype_constraints (type
);
4686 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4687 = tree_cons (specargs
, tmpl
,
4688 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4689 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4691 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4692 inst
= TREE_CHAIN (inst
))
4694 tree instance
= TREE_VALUE (inst
);
4695 if (TYPE_P (instance
)
4696 ? (COMPLETE_TYPE_P (instance
)
4697 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance
))
4698 : DECL_TEMPLATE_INSTANTIATION (instance
))
4700 tree spec
= most_specialized_partial_spec (instance
, tf_none
);
4701 tree inst_decl
= (DECL_P (instance
)
4702 ? instance
: TYPE_NAME (instance
));
4705 else if (spec
== error_mark_node
)
4706 permerror (input_location
,
4707 "declaration of %qD ambiguates earlier template "
4708 "instantiation for %qD", decl
, inst_decl
);
4709 else if (TREE_VALUE (spec
) == tmpl
)
4710 permerror (input_location
,
4711 "partial specialization of %qD after instantiation "
4712 "of %qD", decl
, inst_decl
);
4719 /* PARM is a template parameter of some form; return the corresponding
4720 TEMPLATE_PARM_INDEX. */
4723 get_template_parm_index (tree parm
)
4725 if (TREE_CODE (parm
) == PARM_DECL
4726 || TREE_CODE (parm
) == CONST_DECL
)
4727 parm
= DECL_INITIAL (parm
);
4728 else if (TREE_CODE (parm
) == TYPE_DECL
4729 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4730 parm
= TREE_TYPE (parm
);
4731 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4732 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
4733 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4734 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4735 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4739 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4740 parameter packs used by the template parameter PARM. */
4743 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4745 /* A type parm can't refer to another parm. */
4746 if (TREE_CODE (parm
) == TYPE_DECL
)
4748 else if (TREE_CODE (parm
) == PARM_DECL
)
4750 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4755 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4757 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4758 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4759 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4762 /* PARM is a template parameter pack. Return any parameter packs used in
4763 its type or the type of any of its template parameters. If there are
4764 any such packs, it will be instantiated into a fixed template parameter
4765 list by partial instantiation rather than be fully deduced. */
4768 fixed_parameter_pack_p (tree parm
)
4770 /* This can only be true in a member template. */
4771 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4773 /* This can only be true for a parameter pack. */
4774 if (!template_parameter_pack_p (parm
))
4776 /* A type parm can't refer to another parm. */
4777 if (TREE_CODE (parm
) == TYPE_DECL
)
4780 tree parameter_packs
= NULL_TREE
;
4781 struct find_parameter_pack_data ppd
;
4782 ppd
.parameter_packs
= ¶meter_packs
;
4783 ppd
.visited
= new hash_set
<tree
>;
4784 ppd
.type_pack_expansion_p
= false;
4786 fixed_parameter_pack_p_1 (parm
, &ppd
);
4789 return parameter_packs
;
4792 /* Check that a template declaration's use of default arguments and
4793 parameter packs is not invalid. Here, PARMS are the template
4794 parameters. IS_PRIMARY is true if DECL is the thing declared by
4795 a primary template. IS_PARTIAL is true if DECL is a partial
4798 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4799 declaration (but not a definition); 1 indicates a declaration, 2
4800 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4801 emitted for extraneous default arguments.
4803 Returns TRUE if there were no errors found, FALSE otherwise. */
4806 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4807 bool is_partial
, int is_friend_decl
)
4810 int last_level_to_check
;
4812 bool no_errors
= true;
4816 A default template-argument shall not be specified in a
4817 function template declaration or a function template definition, nor
4818 in the template-parameter-list of the definition of a member of a
4821 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
4822 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
4823 /* You can't have a function template declaration in a local
4824 scope, nor you can you define a member of a class template in a
4828 if ((TREE_CODE (decl
) == TYPE_DECL
4830 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4831 || (TREE_CODE (decl
) == FUNCTION_DECL
4832 && LAMBDA_FUNCTION_P (decl
)))
4833 /* A lambda doesn't have an explicit declaration; don't complain
4834 about the parms of the enclosing class. */
4837 if (current_class_type
4838 && !TYPE_BEING_DEFINED (current_class_type
)
4839 && DECL_LANG_SPECIFIC (decl
)
4840 && DECL_DECLARES_FUNCTION_P (decl
)
4841 /* If this is either a friend defined in the scope of the class
4842 or a member function. */
4843 && (DECL_FUNCTION_MEMBER_P (decl
)
4844 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4845 : DECL_FRIEND_CONTEXT (decl
)
4846 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
4848 /* And, if it was a member function, it really was defined in
4849 the scope of the class. */
4850 && (!DECL_FUNCTION_MEMBER_P (decl
)
4851 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
4852 /* We already checked these parameters when the template was
4853 declared, so there's no need to do it again now. This function
4854 was defined in class scope, but we're processing its body now
4855 that the class is complete. */
4858 /* Core issue 226 (C++0x only): the following only applies to class
4861 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
4865 If a template-parameter has a default template-argument, all
4866 subsequent template-parameters shall have a default
4867 template-argument supplied. */
4868 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
4870 tree inner_parms
= TREE_VALUE (parm_level
);
4871 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
4872 int seen_def_arg_p
= 0;
4875 for (i
= 0; i
< ntparms
; ++i
)
4877 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
4879 if (parm
== error_mark_node
)
4882 if (TREE_PURPOSE (parm
))
4884 else if (seen_def_arg_p
4885 && !template_parameter_pack_p (TREE_VALUE (parm
)))
4887 error ("no default argument for %qD", TREE_VALUE (parm
));
4888 /* For better subsequent error-recovery, we indicate that
4889 there should have been a default argument. */
4890 TREE_PURPOSE (parm
) = error_mark_node
;
4893 else if (!is_partial
4895 /* Don't complain about an enclosing partial
4897 && parm_level
== parms
4898 && TREE_CODE (decl
) == TYPE_DECL
4900 && template_parameter_pack_p (TREE_VALUE (parm
))
4901 /* A fixed parameter pack will be partially
4902 instantiated into a fixed length list. */
4903 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
4905 /* A primary class template can only have one
4906 parameter pack, at the end of the template
4909 error ("parameter pack %q+D must be at the end of the"
4910 " template parameter list", TREE_VALUE (parm
));
4912 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
4920 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
4924 /* For an ordinary class template, default template arguments are
4925 allowed at the innermost level, e.g.:
4926 template <class T = int>
4928 but, in a partial specialization, they're not allowed even
4929 there, as we have in [temp.class.spec]:
4931 The template parameter list of a specialization shall not
4932 contain default template argument values.
4934 So, for a partial specialization, or for a function template
4935 (in C++98/C++03), we look at all of them. */
4938 /* But, for a primary class template that is not a partial
4939 specialization we look at all template parameters except the
4941 parms
= TREE_CHAIN (parms
);
4943 /* Figure out what error message to issue. */
4944 if (is_friend_decl
== 2)
4945 msg
= G_("default template arguments may not be used in function template "
4946 "friend re-declaration");
4947 else if (is_friend_decl
)
4948 msg
= G_("default template arguments may not be used in function template "
4949 "friend declarations");
4950 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
4951 msg
= G_("default template arguments may not be used in function templates "
4952 "without -std=c++11 or -std=gnu++11");
4953 else if (is_partial
)
4954 msg
= G_("default template arguments may not be used in "
4955 "partial specializations");
4956 else if (current_class_type
&& CLASSTYPE_IS_TEMPLATE (current_class_type
))
4957 msg
= G_("default argument for template parameter for class enclosing %qD");
4959 /* Per [temp.param]/9, "A default template-argument shall not be
4960 specified in the template-parameter-lists of the definition of
4961 a member of a class template that appears outside of the member's
4962 class.", thus if we aren't handling a member of a class template
4963 there is no need to examine the parameters. */
4966 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
4967 /* If we're inside a class definition, there's no need to
4968 examine the parameters to the class itself. On the one
4969 hand, they will be checked when the class is defined, and,
4970 on the other, default arguments are valid in things like:
4971 template <class T = double>
4972 struct S { template <class U> void f(U); };
4973 Here the default argument for `S' has no bearing on the
4974 declaration of `f'. */
4975 last_level_to_check
= template_class_depth (current_class_type
) + 1;
4977 /* Check everything. */
4978 last_level_to_check
= 0;
4980 for (parm_level
= parms
;
4981 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
4982 parm_level
= TREE_CHAIN (parm_level
))
4984 tree inner_parms
= TREE_VALUE (parm_level
);
4988 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4989 for (i
= 0; i
< ntparms
; ++i
)
4991 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
4994 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
4999 if (is_friend_decl
== 2)
5006 /* Clear out the default argument so that we are not
5008 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
5012 /* At this point, if we're still interested in issuing messages,
5013 they must apply to classes surrounding the object declared. */
5015 msg
= G_("default argument for template parameter for class "
5022 /* Worker for push_template_decl_real, called via
5023 for_each_template_parm. DATA is really an int, indicating the
5024 level of the parameters we are interested in. If T is a template
5025 parameter of that level, return nonzero. */
5028 template_parm_this_level_p (tree t
, void* data
)
5030 int this_level
= *(int *)data
;
5033 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5034 level
= TEMPLATE_PARM_LEVEL (t
);
5036 level
= TEMPLATE_TYPE_LEVEL (t
);
5037 return level
== this_level
;
5040 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5041 parameters given by current_template_args, or reuses a
5042 previously existing one, if appropriate. Returns the DECL, or an
5043 equivalent one, if it is replaced via a call to duplicate_decls.
5045 If IS_FRIEND is true, DECL is a friend declaration. */
5048 push_template_decl_real (tree decl
, bool is_friend
)
5056 int new_template_p
= 0;
5057 /* True if the template is a member template, in the sense of
5059 bool member_template_p
= false;
5061 if (decl
== error_mark_node
|| !current_template_parms
)
5062 return error_mark_node
;
5064 /* See if this is a partial specialization. */
5065 is_partial
= ((DECL_IMPLICIT_TYPEDEF_P (decl
)
5066 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
5067 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
5069 && DECL_LANG_SPECIFIC (decl
)
5070 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5071 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
))));
5073 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
5077 /* For a friend, we want the context of the friend function, not
5078 the type of which it is a friend. */
5079 ctx
= CP_DECL_CONTEXT (decl
);
5080 else if (CP_DECL_CONTEXT (decl
)
5081 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
5082 /* In the case of a virtual function, we want the class in which
5084 ctx
= CP_DECL_CONTEXT (decl
);
5086 /* Otherwise, if we're currently defining some class, the DECL
5087 is assumed to be a member of the class. */
5088 ctx
= current_scope ();
5090 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5093 if (!DECL_CONTEXT (decl
))
5094 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
5096 /* See if this is a primary template. */
5097 if (is_friend
&& ctx
5098 && uses_template_parms_level (ctx
, processing_template_decl
))
5099 /* A friend template that specifies a class context, i.e.
5100 template <typename T> friend void A<T>::f();
5103 else if (TREE_CODE (decl
) == TYPE_DECL
5104 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5107 is_primary
= template_parm_scope_p ();
5111 warning (OPT_Wtemplates
, "template %qD declared", decl
);
5113 if (DECL_CLASS_SCOPE_P (decl
))
5114 member_template_p
= true;
5115 if (TREE_CODE (decl
) == TYPE_DECL
5116 && anon_aggrname_p (DECL_NAME (decl
)))
5118 error ("template class without a name");
5119 return error_mark_node
;
5121 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
5123 if (member_template_p
)
5125 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
5126 error ("member template %qD may not have virt-specifiers", decl
);
5128 if (DECL_DESTRUCTOR_P (decl
))
5132 A destructor shall not be a member template. */
5133 error ("destructor %qD declared as member template", decl
);
5134 return error_mark_node
;
5136 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
5137 && (!prototype_p (TREE_TYPE (decl
))
5138 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
5139 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5140 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
5141 == void_list_node
)))
5143 /* [basic.stc.dynamic.allocation]
5145 An allocation function can be a function
5146 template. ... Template allocation functions shall
5147 have two or more parameters. */
5148 error ("invalid template declaration of %qD", decl
);
5149 return error_mark_node
;
5152 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5153 && CLASS_TYPE_P (TREE_TYPE (decl
)))
5155 else if (TREE_CODE (decl
) == TYPE_DECL
5156 && TYPE_DECL_ALIAS_P (decl
))
5157 /* alias-declaration */
5158 gcc_assert (!DECL_ARTIFICIAL (decl
));
5159 else if (VAR_P (decl
))
5160 /* C++14 variable template. */;
5163 error ("template declaration of %q#D", decl
);
5164 return error_mark_node
;
5168 /* Check to see that the rules regarding the use of default
5169 arguments are not being violated. */
5170 check_default_tmpl_args (decl
, current_template_parms
,
5171 is_primary
, is_partial
, /*is_friend_decl=*/0);
5173 /* Ensure that there are no parameter packs in the type of this
5174 declaration that have not been expanded. */
5175 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5177 /* Check each of the arguments individually to see if there are
5178 any bare parameter packs. */
5179 tree type
= TREE_TYPE (decl
);
5180 tree arg
= DECL_ARGUMENTS (decl
);
5181 tree argtype
= TYPE_ARG_TYPES (type
);
5183 while (arg
&& argtype
)
5185 if (!DECL_PACK_P (arg
)
5186 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
5188 /* This is a PARM_DECL that contains unexpanded parameter
5189 packs. We have already complained about this in the
5190 check_for_bare_parameter_packs call, so just replace
5191 these types with ERROR_MARK_NODE. */
5192 TREE_TYPE (arg
) = error_mark_node
;
5193 TREE_VALUE (argtype
) = error_mark_node
;
5196 arg
= DECL_CHAIN (arg
);
5197 argtype
= TREE_CHAIN (argtype
);
5200 /* Check for bare parameter packs in the return type and the
5201 exception specifiers. */
5202 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
5203 /* Errors were already issued, set return type to int
5204 as the frontend doesn't expect error_mark_node as
5206 TREE_TYPE (type
) = integer_type_node
;
5207 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
5208 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
5210 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
5211 && TYPE_DECL_ALIAS_P (decl
))
5212 ? DECL_ORIGINAL_TYPE (decl
)
5213 : TREE_TYPE (decl
)))
5215 TREE_TYPE (decl
) = error_mark_node
;
5216 return error_mark_node
;
5220 return process_partial_specialization (decl
);
5222 args
= current_template_args ();
5225 || TREE_CODE (ctx
) == FUNCTION_DECL
5226 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
5227 || (TREE_CODE (decl
) == TYPE_DECL
5228 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5229 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
5231 if (DECL_LANG_SPECIFIC (decl
)
5232 && DECL_TEMPLATE_INFO (decl
)
5233 && DECL_TI_TEMPLATE (decl
))
5234 tmpl
= DECL_TI_TEMPLATE (decl
);
5235 /* If DECL is a TYPE_DECL for a class-template, then there won't
5236 be DECL_LANG_SPECIFIC. The information equivalent to
5237 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5238 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5239 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
5240 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
5242 /* Since a template declaration already existed for this
5243 class-type, we must be redeclaring it here. Make sure
5244 that the redeclaration is valid. */
5245 redeclare_class_template (TREE_TYPE (decl
),
5246 current_template_parms
,
5247 current_template_constraints ());
5248 /* We don't need to create a new TEMPLATE_DECL; just use the
5249 one we already had. */
5250 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
5254 tmpl
= build_template_decl (decl
, current_template_parms
,
5258 if (DECL_LANG_SPECIFIC (decl
)
5259 && DECL_TEMPLATE_SPECIALIZATION (decl
))
5261 /* A specialization of a member template of a template
5263 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5264 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
5265 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
5271 tree a
, t
, current
, parms
;
5273 tree tinfo
= get_template_info (decl
);
5277 error ("template definition of non-template %q#D", decl
);
5278 return error_mark_node
;
5281 tmpl
= TI_TEMPLATE (tinfo
);
5283 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
5284 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
5285 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5286 && DECL_MEMBER_TEMPLATE_P (tmpl
))
5290 /* The declaration is a specialization of a member
5291 template, declared outside the class. Therefore, the
5292 innermost template arguments will be NULL, so we
5293 replace them with the arguments determined by the
5294 earlier call to check_explicit_specialization. */
5295 args
= DECL_TI_ARGS (decl
);
5298 = build_template_decl (decl
, current_template_parms
,
5300 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
5301 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
5302 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
5303 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
5304 DECL_TEMPLATE_INFO (new_tmpl
)
5305 = build_template_info (tmpl
, args
);
5307 register_specialization (new_tmpl
,
5308 most_general_template (tmpl
),
5314 /* Make sure the template headers we got make sense. */
5316 parms
= DECL_TEMPLATE_PARMS (tmpl
);
5317 i
= TMPL_PARMS_DEPTH (parms
);
5318 if (TMPL_ARGS_DEPTH (args
) != i
)
5320 error ("expected %d levels of template parms for %q#D, got %d",
5321 i
, decl
, TMPL_ARGS_DEPTH (args
));
5322 DECL_INTERFACE_KNOWN (decl
) = 1;
5323 return error_mark_node
;
5326 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
5328 a
= TMPL_ARGS_LEVEL (args
, i
);
5329 t
= INNERMOST_TEMPLATE_PARMS (parms
);
5331 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
5333 if (current
== decl
)
5334 error ("got %d template parameters for %q#D",
5335 TREE_VEC_LENGTH (a
), decl
);
5337 error ("got %d template parameters for %q#T",
5338 TREE_VEC_LENGTH (a
), current
);
5339 error (" but %d required", TREE_VEC_LENGTH (t
));
5340 /* Avoid crash in import_export_decl. */
5341 DECL_INTERFACE_KNOWN (decl
) = 1;
5342 return error_mark_node
;
5345 if (current
== decl
)
5347 else if (current
== NULL_TREE
)
5348 /* Can happen in erroneous input. */
5351 current
= get_containing_scope (current
);
5354 /* Check that the parms are used in the appropriate qualifying scopes
5355 in the declarator. */
5356 if (!comp_template_args
5358 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
5361 template arguments to %qD do not match original template %qD",
5362 decl
, DECL_TEMPLATE_RESULT (tmpl
));
5363 if (!uses_template_parms (TI_ARGS (tinfo
)))
5364 inform (input_location
, "use template<> for an explicit specialization");
5365 /* Avoid crash in import_export_decl. */
5366 DECL_INTERFACE_KNOWN (decl
) = 1;
5367 return error_mark_node
;
5371 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5372 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5374 /* Push template declarations for global functions and types. Note
5375 that we do not try to push a global template friend declared in a
5376 template class; such a thing may well depend on the template
5377 parameters of the class. */
5378 if (new_template_p
&& !ctx
5379 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5381 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5382 if (tmpl
== error_mark_node
)
5383 return error_mark_node
;
5385 /* Hide template friend classes that haven't been declared yet. */
5386 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5388 DECL_ANTICIPATED (tmpl
) = 1;
5389 DECL_FRIEND_P (tmpl
) = 1;
5395 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5398 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5399 if (DECL_CONV_FN_P (tmpl
))
5401 int depth
= TMPL_PARMS_DEPTH (parms
);
5403 /* It is a conversion operator. See if the type converted to
5404 depends on innermost template operands. */
5406 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
5408 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
5411 /* Give template template parms a DECL_CONTEXT of the template
5412 for which they are a parameter. */
5413 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5414 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5416 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5417 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5418 DECL_CONTEXT (parm
) = tmpl
;
5421 if (TREE_CODE (decl
) == TYPE_DECL
5422 && TYPE_DECL_ALIAS_P (decl
)
5423 && complex_alias_template_p (tmpl
))
5424 TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl
) = true;
5427 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5428 back to its most general template. If TMPL is a specialization,
5429 ARGS may only have the innermost set of arguments. Add the missing
5430 argument levels if necessary. */
5431 if (DECL_TEMPLATE_INFO (tmpl
))
5432 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5434 info
= build_template_info (tmpl
, args
);
5436 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5437 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5440 if (is_primary
&& !DECL_LANG_SPECIFIC (decl
))
5441 retrofit_lang_decl (decl
);
5442 if (DECL_LANG_SPECIFIC (decl
))
5443 DECL_TEMPLATE_INFO (decl
) = info
;
5446 if (flag_implicit_templates
5448 && TREE_PUBLIC (decl
)
5449 && VAR_OR_FUNCTION_DECL_P (decl
))
5450 /* Set DECL_COMDAT on template instantiations; if we force
5451 them to be emitted by explicit instantiation or -frepo,
5452 mark_needed will tell cgraph to do the right thing. */
5453 DECL_COMDAT (decl
) = true;
5455 return DECL_TEMPLATE_RESULT (tmpl
);
5459 push_template_decl (tree decl
)
5461 return push_template_decl_real (decl
, false);
5464 /* FN is an inheriting constructor that inherits from the constructor
5465 template INHERITED; turn FN into a constructor template with a matching
5469 add_inherited_template_parms (tree fn
, tree inherited
)
5472 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5473 inner_parms
= copy_node (inner_parms
);
5475 = tree_cons (size_int (processing_template_decl
+ 1),
5476 inner_parms
, current_template_parms
);
5477 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5478 tree args
= template_parms_to_args (parms
);
5479 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5480 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5481 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5482 DECL_ARTIFICIAL (tmpl
) = true;
5483 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5487 /* Called when a class template TYPE is redeclared with the indicated
5488 template PARMS, e.g.:
5490 template <class T> struct S;
5491 template <class T> struct S {}; */
5494 redeclare_class_template (tree type
, tree parms
, tree cons
)
5500 if (!TYPE_TEMPLATE_INFO (type
))
5502 error ("%qT is not a template type", type
);
5506 tmpl
= TYPE_TI_TEMPLATE (type
);
5507 if (!PRIMARY_TEMPLATE_P (tmpl
))
5508 /* The type is nested in some template class. Nothing to worry
5509 about here; there are no new template parameters for the nested
5515 error ("template specifiers not specified in declaration of %qD",
5520 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5521 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5523 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5525 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5526 "redeclared with %d template parameter",
5527 "redeclared with %d template parameters",
5528 TREE_VEC_LENGTH (parms
));
5529 inform_n (DECL_SOURCE_LOCATION (tmpl
), TREE_VEC_LENGTH (tmpl_parms
),
5530 "previous declaration %qD used %d template parameter",
5531 "previous declaration %qD used %d template parameters",
5532 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5536 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5543 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5544 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5547 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5548 if (error_operand_p (tmpl_parm
))
5551 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5552 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5553 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5555 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5557 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5558 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5559 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5560 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5561 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5562 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5563 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5564 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5565 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5567 error ("template parameter %q+#D", tmpl_parm
);
5568 error ("redeclared here as %q#D", parm
);
5572 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5574 /* We have in [temp.param]:
5576 A template-parameter may not be given default arguments
5577 by two different declarations in the same scope. */
5578 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5579 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5580 "original definition appeared here");
5584 if (parm_default
!= NULL_TREE
)
5585 /* Update the previous template parameters (which are the ones
5586 that will really count) with the new default value. */
5587 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5588 else if (tmpl_default
!= NULL_TREE
)
5589 /* Update the new parameters, too; they'll be used as the
5590 parameters for any members. */
5591 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5593 /* Give each template template parm in this redeclaration a
5594 DECL_CONTEXT of the template for which they are a parameter. */
5595 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5597 gcc_assert (DECL_CONTEXT (parm
) == NULL_TREE
);
5598 DECL_CONTEXT (parm
) = tmpl
;
5602 // Cannot redeclare a class template with a different set of constraints.
5603 if (!equivalent_constraints (get_constraints (tmpl
), cons
))
5605 error_at (input_location
, "redeclaration %q#D with different "
5606 "constraints", tmpl
);
5607 inform (DECL_SOURCE_LOCATION (tmpl
),
5608 "original declaration appeared here");
5614 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5615 to be used when the caller has already checked
5616 (processing_template_decl
5617 && !instantiation_dependent_expression_p (expr)
5618 && potential_constant_expression (expr))
5619 and cleared processing_template_decl. */
5622 instantiate_non_dependent_expr_internal (tree expr
, tsubst_flags_t complain
)
5624 return tsubst_copy_and_build (expr
,
5627 /*in_decl=*/NULL_TREE
,
5628 /*function_p=*/false,
5629 /*integral_constant_expression_p=*/true);
5632 /* Simplify EXPR if it is a non-dependent expression. Returns the
5633 (possibly simplified) expression. */
5636 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5638 if (expr
== NULL_TREE
)
5641 /* If we're in a template, but EXPR isn't value dependent, simplify
5642 it. We're supposed to treat:
5644 template <typename T> void f(T[1 + 1]);
5645 template <typename T> void f(T[2]);
5647 as two declarations of the same function, for example. */
5648 if (processing_template_decl
5649 && !instantiation_dependent_expression_p (expr
)
5650 && potential_constant_expression (expr
))
5652 processing_template_decl_sentinel s
;
5653 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
5659 instantiate_non_dependent_expr (tree expr
)
5661 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
5664 /* True iff T is a specialization of a variable template. */
5667 variable_template_specialization_p (tree t
)
5669 if (!VAR_P (t
) || !DECL_LANG_SPECIFIC (t
) || !DECL_TEMPLATE_INFO (t
))
5671 tree tmpl
= DECL_TI_TEMPLATE (t
);
5672 return variable_template_p (tmpl
);
5675 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5676 template declaration, or a TYPE_DECL for an alias declaration. */
5679 alias_type_or_template_p (tree t
)
5683 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5686 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5687 || DECL_ALIAS_TEMPLATE_P (t
));
5690 /* Return TRUE iff T is a specialization of an alias template. */
5693 alias_template_specialization_p (const_tree t
)
5695 /* It's an alias template specialization if it's an alias and its
5696 TYPE_NAME is a specialization of a primary template. */
5697 if (TYPE_ALIAS_P (t
))
5699 tree name
= TYPE_NAME (t
);
5700 if (DECL_LANG_SPECIFIC (name
))
5701 if (tree ti
= DECL_TEMPLATE_INFO (name
))
5703 tree tmpl
= TI_TEMPLATE (ti
);
5704 return PRIMARY_TEMPLATE_P (tmpl
);
5710 /* An alias template is complex from a SFINAE perspective if a template-id
5711 using that alias can be ill-formed when the expansion is not, as with
5712 the void_t template. We determine this by checking whether the
5713 expansion for the alias template uses all its template parameters. */
5715 struct uses_all_template_parms_data
5722 uses_all_template_parms_r (tree t
, void *data_
)
5724 struct uses_all_template_parms_data
&data
5725 = *(struct uses_all_template_parms_data
*)data_
;
5726 tree idx
= get_template_parm_index (t
);
5728 if (TEMPLATE_PARM_LEVEL (idx
) == data
.level
)
5729 data
.seen
[TEMPLATE_PARM_IDX (idx
)] = true;
5734 complex_alias_template_p (const_tree tmpl
)
5736 struct uses_all_template_parms_data data
;
5737 tree pat
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5738 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5739 data
.level
= TMPL_PARMS_DEPTH (parms
);
5740 int len
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms
));
5741 data
.seen
= XALLOCAVEC (bool, len
);
5742 for (int i
= 0; i
< len
; ++i
)
5743 data
.seen
[i
] = false;
5745 for_each_template_parm (pat
, uses_all_template_parms_r
, &data
, NULL
, true);
5746 for (int i
= 0; i
< len
; ++i
)
5752 /* Return TRUE iff T is a specialization of a complex alias template with
5753 dependent template-arguments. */
5756 dependent_alias_template_spec_p (const_tree t
)
5758 return (alias_template_specialization_p (t
)
5759 && TEMPLATE_DECL_COMPLEX_ALIAS_P (DECL_TI_TEMPLATE (TYPE_NAME (t
)))
5760 && (any_dependent_template_arguments_p
5761 (INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (t
)))));
5764 /* Return the number of innermost template parameters in TMPL. */
5767 num_innermost_template_parms (tree tmpl
)
5769 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5770 return TREE_VEC_LENGTH (parms
);
5773 /* Return either TMPL or another template that it is equivalent to under DR
5774 1286: An alias that just changes the name of a template is equivalent to
5775 the other template. */
5778 get_underlying_template (tree tmpl
)
5780 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5781 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5783 tree result
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5784 if (TYPE_TEMPLATE_INFO (result
))
5786 tree sub
= TYPE_TI_TEMPLATE (result
);
5787 if (PRIMARY_TEMPLATE_P (sub
)
5788 && (num_innermost_template_parms (tmpl
)
5789 == num_innermost_template_parms (sub
)))
5791 tree alias_args
= INNERMOST_TEMPLATE_ARGS
5792 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
5793 if (!comp_template_args (TYPE_TI_ARGS (result
), alias_args
))
5795 /* The alias type is equivalent to the pattern of the
5796 underlying template, so strip the alias. */
5806 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5807 must be a function or a pointer-to-function type, as specified
5808 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5809 and check that the resulting function has external linkage. */
5812 convert_nontype_argument_function (tree type
, tree expr
,
5813 tsubst_flags_t complain
)
5817 linkage_kind linkage
;
5819 fn
= instantiate_type (type
, fns
, tf_none
);
5820 if (fn
== error_mark_node
)
5821 return error_mark_node
;
5824 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5825 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5826 if (BASELINK_P (fn_no_ptr
))
5827 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5829 /* [temp.arg.nontype]/1
5831 A template-argument for a non-type, non-template template-parameter
5834 -- the address of an object or function with external [C++11: or
5835 internal] linkage. */
5837 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5839 if (complain
& tf_error
)
5841 error ("%qE is not a valid template argument for type %qT",
5843 if (TYPE_PTR_P (type
))
5844 error ("it must be the address of a function with "
5845 "external linkage");
5847 error ("it must be the name of a function with "
5848 "external linkage");
5853 linkage
= decl_linkage (fn_no_ptr
);
5854 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5856 if (complain
& tf_error
)
5858 if (cxx_dialect
>= cxx11
)
5859 error ("%qE is not a valid template argument for type %qT "
5860 "because %qD has no linkage",
5861 expr
, type
, fn_no_ptr
);
5863 error ("%qE is not a valid template argument for type %qT "
5864 "because %qD does not have external linkage",
5865 expr
, type
, fn_no_ptr
);
5873 /* Subroutine of convert_nontype_argument.
5874 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5875 Emit an error otherwise. */
5878 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5879 tsubst_flags_t complain
)
5882 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5884 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5886 if (processing_template_decl
5887 && TREE_CODE (expr
) == ADDR_EXPR
5888 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
5890 if (complain
& tf_error
)
5892 error ("%qE is not a valid template argument for type %qT",
5894 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5899 /* Returns TRUE iff the address of OP is value-dependent.
5901 14.6.2.4 [temp.dep.temp]:
5902 A non-integral non-type template-argument is dependent if its type is
5903 dependent or it has either of the following forms
5906 and contains a nested-name-specifier which specifies a class-name that
5907 names a dependent type.
5909 We generalize this to just say that the address of a member of a
5910 dependent class is value-dependent; the above doesn't cover the
5911 address of a static data member named with an unqualified-id. */
5914 has_value_dependent_address (tree op
)
5916 /* We could use get_inner_reference here, but there's no need;
5917 this is only relevant for template non-type arguments, which
5918 can only be expressed as &id-expression. */
5921 tree ctx
= CP_DECL_CONTEXT (op
);
5922 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5929 /* The next set of functions are used for providing helpful explanatory
5930 diagnostics for failed overload resolution. Their messages should be
5931 indented by two spaces for consistency with the messages in
5935 unify_success (bool /*explain_p*/)
5941 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5944 inform (input_location
,
5945 " couldn't deduce template parameter %qD", parm
);
5950 unify_invalid (bool /*explain_p*/)
5956 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5959 inform (input_location
,
5960 " types %qT and %qT have incompatible cv-qualifiers",
5966 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5969 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5974 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5977 inform (input_location
,
5978 " template parameter %qD is not a parameter pack, but "
5985 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5988 inform (input_location
,
5989 " template argument %qE does not match "
5990 "pointer-to-member constant %qE",
5996 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5999 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
6004 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
6007 inform (input_location
,
6008 " inconsistent parameter pack deduction with %qT and %qT",
6014 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
6019 inform (input_location
,
6020 " deduced conflicting types for parameter %qT (%qT and %qT)",
6021 parm
, first
, second
);
6023 inform (input_location
,
6024 " deduced conflicting values for non-type parameter "
6025 "%qE (%qE and %qE)", parm
, first
, second
);
6031 unify_vla_arg (bool explain_p
, tree arg
)
6034 inform (input_location
,
6035 " variable-sized array type %qT is not "
6036 "a valid template argument",
6042 unify_method_type_error (bool explain_p
, tree arg
)
6045 inform (input_location
,
6046 " member function type %qT is not a valid template argument",
6052 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
6057 inform_n (input_location
, wanted
,
6058 " candidate expects at least %d argument, %d provided",
6059 " candidate expects at least %d arguments, %d provided",
6062 inform_n (input_location
, wanted
,
6063 " candidate expects %d argument, %d provided",
6064 " candidate expects %d arguments, %d provided",
6071 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
6073 return unify_arity (explain_p
, have
, wanted
);
6077 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
6078 bool least_p
= false)
6080 return unify_arity (explain_p
, have
, wanted
, least_p
);
6084 unify_arg_conversion (bool explain_p
, tree to_type
,
6085 tree from_type
, tree arg
)
6088 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
6089 " cannot convert %qE (type %qT) to type %qT",
6090 arg
, from_type
, to_type
);
6095 unify_no_common_base (bool explain_p
, enum template_base_result r
,
6096 tree parm
, tree arg
)
6101 case tbr_ambiguous_baseclass
:
6102 inform (input_location
, " %qT is an ambiguous base class of %qT",
6106 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
6113 unify_inconsistent_template_template_parameters (bool explain_p
)
6116 inform (input_location
,
6117 " template parameters of a template template argument are "
6118 "inconsistent with other deduced template arguments");
6123 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
6126 inform (input_location
,
6127 " can't deduce a template for %qT from non-template type %qT",
6133 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
6136 inform (input_location
,
6137 " template argument %qE does not match %qD", arg
, parm
);
6142 unify_overload_resolution_failure (bool explain_p
, tree arg
)
6145 inform (input_location
,
6146 " could not resolve address from overloaded function %qE",
6151 /* Attempt to convert the non-type template parameter EXPR to the
6152 indicated TYPE. If the conversion is successful, return the
6153 converted value. If the conversion is unsuccessful, return
6154 NULL_TREE if we issued an error message, or error_mark_node if we
6155 did not. We issue error messages for out-and-out bad template
6156 parameters, but not simply because the conversion failed, since we
6157 might be just trying to do argument deduction. Both TYPE and EXPR
6158 must be non-dependent.
6160 The conversion follows the special rules described in
6161 [temp.arg.nontype], and it is much more strict than an implicit
6164 This function is called twice for each template argument (see
6165 lookup_template_class for a more accurate description of this
6166 problem). This means that we need to handle expressions which
6167 are not valid in a C++ source, but can be created from the
6168 first call (for instance, casts to perform conversions). These
6169 hacks can go away after we fix the double coercion problem. */
6172 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
6176 /* Detect immediately string literals as invalid non-type argument.
6177 This special-case is not needed for correctness (we would easily
6178 catch this later), but only to provide better diagnostic for this
6179 common user mistake. As suggested by DR 100, we do not mention
6180 linkage issues in the diagnostic as this is not the point. */
6181 /* FIXME we're making this OK. */
6182 if (TREE_CODE (expr
) == STRING_CST
)
6184 if (complain
& tf_error
)
6185 error ("%qE is not a valid template argument for type %qT "
6186 "because string literals can never be used in this context",
6191 /* Add the ADDR_EXPR now for the benefit of
6192 value_dependent_expression_p. */
6193 if (TYPE_PTROBV_P (type
)
6194 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
6196 expr
= decay_conversion (expr
, complain
);
6197 if (expr
== error_mark_node
)
6198 return error_mark_node
;
6201 /* If we are in a template, EXPR may be non-dependent, but still
6202 have a syntactic, rather than semantic, form. For example, EXPR
6203 might be a SCOPE_REF, rather than the VAR_DECL to which the
6204 SCOPE_REF refers. Preserving the qualifying scope is necessary
6205 so that access checking can be performed when the template is
6206 instantiated -- but here we need the resolved form so that we can
6207 convert the argument. */
6208 bool non_dep
= false;
6209 if (TYPE_REF_OBJ_P (type
)
6210 && has_value_dependent_address (expr
))
6211 /* If we want the address and it's value-dependent, don't fold. */;
6212 else if (!type_unknown_p (expr
)
6213 && processing_template_decl
6214 && !instantiation_dependent_expression_p (expr
)
6215 && potential_constant_expression (expr
))
6217 if (error_operand_p (expr
))
6218 return error_mark_node
;
6219 expr_type
= TREE_TYPE (expr
);
6220 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6221 expr
= mark_lvalue_use (expr
);
6223 expr
= mark_rvalue_use (expr
);
6225 /* If the argument is non-dependent, perform any conversions in
6226 non-dependent context as well. */
6227 processing_template_decl_sentinel
s (non_dep
);
6229 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6231 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
6232 to a non-type argument of "nullptr". */
6233 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
6234 expr
= fold_simple (convert (type
, expr
));
6236 /* In C++11, integral or enumeration non-type template arguments can be
6237 arbitrary constant expressions. Pointer and pointer to
6238 member arguments can be general constant expressions that evaluate
6239 to a null value, but otherwise still need to be of a specific form. */
6240 if (cxx_dialect
>= cxx11
)
6242 if (TREE_CODE (expr
) == PTRMEM_CST
)
6243 /* A PTRMEM_CST is already constant, and a valid template
6244 argument for a parameter of pointer to member type, we just want
6245 to leave it in that form rather than lower it to a
6247 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6248 expr
= maybe_constant_value (expr
);
6249 else if (cxx_dialect
>= cxx1z
)
6251 if (TREE_CODE (type
) != REFERENCE_TYPE
)
6252 expr
= maybe_constant_value (expr
);
6253 else if (REFERENCE_REF_P (expr
))
6255 expr
= TREE_OPERAND (expr
, 0);
6256 expr
= maybe_constant_value (expr
);
6257 expr
= convert_from_reference (expr
);
6260 else if (TYPE_PTR_OR_PTRMEM_P (type
))
6262 tree folded
= maybe_constant_value (expr
);
6263 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
6264 : null_member_pointer_value_p (folded
))
6269 /* HACK: Due to double coercion, we can get a
6270 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
6271 which is the tree that we built on the first call (see
6272 below when coercing to reference to object or to reference to
6273 function). We just strip everything and get to the arg.
6274 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
6276 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
6278 tree probe_type
, probe
= expr
;
6279 if (REFERENCE_REF_P (probe
))
6280 probe
= TREE_OPERAND (probe
, 0);
6281 probe_type
= TREE_TYPE (probe
);
6282 if (TREE_CODE (probe
) == NOP_EXPR
)
6284 /* ??? Maybe we could use convert_from_reference here, but we
6285 would need to relax its constraints because the NOP_EXPR
6286 could actually change the type to something more cv-qualified,
6287 and this is not folded by convert_from_reference. */
6288 tree addr
= TREE_OPERAND (probe
, 0);
6289 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
6290 && TREE_CODE (addr
) == ADDR_EXPR
6291 && TYPE_PTR_P (TREE_TYPE (addr
))
6292 && (same_type_ignoring_top_level_qualifiers_p
6293 (TREE_TYPE (probe_type
),
6294 TREE_TYPE (TREE_TYPE (addr
)))))
6296 expr
= TREE_OPERAND (addr
, 0);
6297 expr_type
= TREE_TYPE (probe_type
);
6302 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
6303 parameter is a pointer to object, through decay and
6304 qualification conversion. Let's strip everything. */
6305 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
6309 if (TREE_CODE (probe
) == ADDR_EXPR
6310 && TYPE_PTR_P (TREE_TYPE (probe
)))
6312 /* Skip the ADDR_EXPR only if it is part of the decay for
6313 an array. Otherwise, it is part of the original argument
6314 in the source code. */
6315 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
6316 probe
= TREE_OPERAND (probe
, 0);
6318 expr_type
= TREE_TYPE (expr
);
6322 /* [temp.arg.nontype]/5, bullet 1
6324 For a non-type template-parameter of integral or enumeration type,
6325 integral promotions (_conv.prom_) and integral conversions
6326 (_conv.integral_) are applied. */
6327 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6329 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
6330 t
= maybe_constant_value (t
);
6331 if (t
!= error_mark_node
)
6334 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
6335 return error_mark_node
;
6337 /* Notice that there are constant expressions like '4 % 0' which
6338 do not fold into integer constants. */
6339 if (TREE_CODE (expr
) != INTEGER_CST
)
6341 if (complain
& tf_error
)
6343 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
6344 if (processing_template_decl
6345 && !require_potential_constant_expression (expr
))
6347 expr
= cxx_constant_value (expr
);
6348 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
6349 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
6350 "in template argument for type %qT ", type
);
6351 if (expr
== error_mark_node
)
6353 /* else cxx_constant_value complained but gave us
6354 a real constant, so go ahead. */
6355 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
6361 /* Avoid typedef problems. */
6362 if (TREE_TYPE (expr
) != type
)
6363 expr
= fold_convert (type
, expr
);
6365 /* [temp.arg.nontype]/5, bullet 2
6367 For a non-type template-parameter of type pointer to object,
6368 qualification conversions (_conv.qual_) and the array-to-pointer
6369 conversion (_conv.array_) are applied. */
6370 else if (TYPE_PTROBV_P (type
))
6372 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6374 A template-argument for a non-type, non-template template-parameter
6375 shall be one of: [...]
6377 -- the name of a non-type template-parameter;
6378 -- the address of an object or function with external linkage, [...]
6379 expressed as "& id-expression" where the & is optional if the name
6380 refers to a function or array, or if the corresponding
6381 template-parameter is a reference.
6383 Here, we do not care about functions, as they are invalid anyway
6384 for a parameter of type pointer-to-object. */
6386 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
6387 /* Non-type template parameters are OK. */
6389 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6390 /* Null pointer values are OK in C++11. */;
6391 else if (TREE_CODE (expr
) != ADDR_EXPR
6392 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
6396 if (complain
& tf_error
)
6397 error ("%qD is not a valid template argument "
6398 "because %qD is a variable, not the address of "
6399 "a variable", expr
, expr
);
6402 if (POINTER_TYPE_P (expr_type
))
6404 if (complain
& tf_error
)
6405 error ("%qE is not a valid template argument for %qT "
6406 "because it is not the address of a variable",
6410 /* Other values, like integer constants, might be valid
6411 non-type arguments of some other type. */
6412 return error_mark_node
;
6418 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
6419 ? TREE_OPERAND (expr
, 0) : expr
);
6422 if (complain
& tf_error
)
6423 error ("%qE is not a valid template argument of type %qT "
6424 "because %qE is not a variable", expr
, type
, decl
);
6427 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
6429 if (complain
& tf_error
)
6430 error ("%qE is not a valid template argument of type %qT "
6431 "because %qD does not have external linkage",
6435 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
6437 if (complain
& tf_error
)
6438 error ("%qE is not a valid template argument of type %qT "
6439 "because %qD has no linkage", expr
, type
, decl
);
6444 expr
= decay_conversion (expr
, complain
);
6445 if (expr
== error_mark_node
)
6446 return error_mark_node
;
6448 expr
= perform_qualification_conversions (type
, expr
);
6449 if (expr
== error_mark_node
)
6450 return error_mark_node
;
6452 /* [temp.arg.nontype]/5, bullet 3
6454 For a non-type template-parameter of type reference to object, no
6455 conversions apply. The type referred to by the reference may be more
6456 cv-qualified than the (otherwise identical) type of the
6457 template-argument. The template-parameter is bound directly to the
6458 template-argument, which must be an lvalue. */
6459 else if (TYPE_REF_OBJ_P (type
))
6461 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
6463 return error_mark_node
;
6465 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
6467 if (complain
& tf_error
)
6468 error ("%qE is not a valid template argument for type %qT "
6469 "because of conflicts in cv-qualification", expr
, type
);
6473 if (!real_lvalue_p (expr
))
6475 if (complain
& tf_error
)
6476 error ("%qE is not a valid template argument for type %qT "
6477 "because it is not an lvalue", expr
, type
);
6481 /* [temp.arg.nontype]/1
6483 A template-argument for a non-type, non-template template-parameter
6484 shall be one of: [...]
6486 -- the address of an object or function with external linkage. */
6487 if (INDIRECT_REF_P (expr
)
6488 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
6490 expr
= TREE_OPERAND (expr
, 0);
6493 if (complain
& tf_error
)
6494 error ("%q#D is not a valid template argument for type %qT "
6495 "because a reference variable does not have a constant "
6496 "address", expr
, type
);
6503 if (complain
& tf_error
)
6504 error ("%qE is not a valid template argument for type %qT "
6505 "because it is not an object with linkage",
6510 /* DR 1155 allows internal linkage in C++11 and up. */
6511 linkage_kind linkage
= decl_linkage (expr
);
6512 if (linkage
< (cxx_dialect
>= cxx11
? lk_internal
: lk_external
))
6514 if (complain
& tf_error
)
6515 error ("%qE is not a valid template argument for type %qT "
6516 "because object %qD does not have linkage",
6521 expr
= build_nop (type
, build_address (expr
));
6523 /* [temp.arg.nontype]/5, bullet 4
6525 For a non-type template-parameter of type pointer to function, only
6526 the function-to-pointer conversion (_conv.func_) is applied. If the
6527 template-argument represents a set of overloaded functions (or a
6528 pointer to such), the matching function is selected from the set
6530 else if (TYPE_PTRFN_P (type
))
6532 /* If the argument is a template-id, we might not have enough
6533 context information to decay the pointer. */
6534 if (!type_unknown_p (expr_type
))
6536 expr
= decay_conversion (expr
, complain
);
6537 if (expr
== error_mark_node
)
6538 return error_mark_node
;
6541 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6542 /* Null pointer values are OK in C++11. */
6543 return perform_qualification_conversions (type
, expr
);
6545 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6546 if (!expr
|| expr
== error_mark_node
)
6549 /* [temp.arg.nontype]/5, bullet 5
6551 For a non-type template-parameter of type reference to function, no
6552 conversions apply. If the template-argument represents a set of
6553 overloaded functions, the matching function is selected from the set
6555 else if (TYPE_REFFN_P (type
))
6557 if (TREE_CODE (expr
) == ADDR_EXPR
)
6559 if (complain
& tf_error
)
6561 error ("%qE is not a valid template argument for type %qT "
6562 "because it is a pointer", expr
, type
);
6563 inform (input_location
, "try using %qE instead",
6564 TREE_OPERAND (expr
, 0));
6569 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6570 if (!expr
|| expr
== error_mark_node
)
6573 expr
= build_nop (type
, build_address (expr
));
6575 /* [temp.arg.nontype]/5, bullet 6
6577 For a non-type template-parameter of type pointer to member function,
6578 no conversions apply. If the template-argument represents a set of
6579 overloaded member functions, the matching member function is selected
6580 from the set (_over.over_). */
6581 else if (TYPE_PTRMEMFUNC_P (type
))
6583 expr
= instantiate_type (type
, expr
, tf_none
);
6584 if (expr
== error_mark_node
)
6585 return error_mark_node
;
6587 /* [temp.arg.nontype] bullet 1 says the pointer to member
6588 expression must be a pointer-to-member constant. */
6589 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6590 return error_mark_node
;
6592 /* There is no way to disable standard conversions in
6593 resolve_address_of_overloaded_function (called by
6594 instantiate_type). It is possible that the call succeeded by
6595 converting &B::I to &D::I (where B is a base of D), so we need
6596 to reject this conversion here.
6598 Actually, even if there was a way to disable standard conversions,
6599 it would still be better to reject them here so that we can
6600 provide a superior diagnostic. */
6601 if (!same_type_p (TREE_TYPE (expr
), type
))
6603 if (complain
& tf_error
)
6605 error ("%qE is not a valid template argument for type %qT "
6606 "because it is of type %qT", expr
, type
,
6608 /* If we are just one standard conversion off, explain. */
6609 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6610 inform (input_location
,
6611 "standard conversions are not allowed in this context");
6616 /* [temp.arg.nontype]/5, bullet 7
6618 For a non-type template-parameter of type pointer to data member,
6619 qualification conversions (_conv.qual_) are applied. */
6620 else if (TYPE_PTRDATAMEM_P (type
))
6622 /* [temp.arg.nontype] bullet 1 says the pointer to member
6623 expression must be a pointer-to-member constant. */
6624 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6625 return error_mark_node
;
6627 expr
= perform_qualification_conversions (type
, expr
);
6628 if (expr
== error_mark_node
)
6631 else if (NULLPTR_TYPE_P (type
))
6633 if (expr
!= nullptr_node
)
6635 if (complain
& tf_error
)
6636 error ("%qE is not a valid template argument for type %qT "
6637 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6642 /* A template non-type parameter must be one of the above. */
6646 /* Sanity check: did we actually convert the argument to the
6648 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6649 (type
, TREE_TYPE (expr
)));
6650 return convert_from_reference (expr
);
6653 /* Subroutine of coerce_template_template_parms, which returns 1 if
6654 PARM_PARM and ARG_PARM match using the rule for the template
6655 parameters of template template parameters. Both PARM and ARG are
6656 template parameters; the rest of the arguments are the same as for
6657 coerce_template_template_parms.
6660 coerce_template_template_parm (tree parm
,
6662 tsubst_flags_t complain
,
6666 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6667 || parm
== NULL_TREE
|| error_operand_p (parm
))
6670 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6673 switch (TREE_CODE (parm
))
6676 /* We encounter instantiations of templates like
6677 template <template <template <class> class> class TT>
6680 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6681 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6683 if (!coerce_template_template_parms
6684 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6690 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6691 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6692 /* Argument is a parameter pack but parameter is not. */
6697 /* The tsubst call is used to handle cases such as
6699 template <int> class C {};
6700 template <class T, template <T> class TT> class D {};
6703 i.e. the parameter list of TT depends on earlier parameters. */
6704 if (!uses_template_parms (TREE_TYPE (arg
)))
6706 tree t
= tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
);
6707 if (!uses_template_parms (t
)
6708 && !same_type_p (t
, TREE_TYPE (arg
)))
6712 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6713 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6714 /* Argument is a parameter pack but parameter is not. */
6727 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6728 template template parameters. Both PARM_PARMS and ARG_PARMS are
6729 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6732 Consider the example:
6733 template <class T> class A;
6734 template<template <class U> class TT> class B;
6736 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6737 the parameters to A, and OUTER_ARGS contains A. */
6740 coerce_template_template_parms (tree parm_parms
,
6742 tsubst_flags_t complain
,
6746 int nparms
, nargs
, i
;
6750 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6751 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6753 nparms
= TREE_VEC_LENGTH (parm_parms
);
6754 nargs
= TREE_VEC_LENGTH (arg_parms
);
6756 /* Determine whether we have a parameter pack at the end of the
6757 template template parameter's template parameter list. */
6758 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6760 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6762 if (error_operand_p (parm
))
6765 switch (TREE_CODE (parm
))
6769 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6774 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6784 && !(variadic_p
&& nargs
>= nparms
- 1))
6787 /* Check all of the template parameters except the parameter pack at
6788 the end (if any). */
6789 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6791 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6792 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6795 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6796 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6798 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6806 /* Check each of the template parameters in the template
6807 argument against the template parameter pack at the end of
6808 the template template parameter. */
6809 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6812 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6814 for (; i
< nargs
; ++i
)
6816 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6819 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6821 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6830 /* Verifies that the deduced template arguments (in TARGS) for the
6831 template template parameters (in TPARMS) represent valid bindings,
6832 by comparing the template parameter list of each template argument
6833 to the template parameter list of its corresponding template
6834 template parameter, in accordance with DR150. This
6835 routine can only be called after all template arguments have been
6836 deduced. It will return TRUE if all of the template template
6837 parameter bindings are okay, FALSE otherwise. */
6839 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6841 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6844 /* We're dealing with template parms in this process. */
6845 ++processing_template_decl
;
6847 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6849 for (i
= 0; i
< ntparms
; ++i
)
6851 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6852 tree targ
= TREE_VEC_ELT (targs
, i
);
6854 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6856 tree packed_args
= NULL_TREE
;
6859 if (ARGUMENT_PACK_P (targ
))
6861 /* Look inside the argument pack. */
6862 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6863 len
= TREE_VEC_LENGTH (packed_args
);
6866 for (idx
= 0; idx
< len
; ++idx
)
6868 tree targ_parms
= NULL_TREE
;
6871 /* Extract the next argument from the argument
6873 targ
= TREE_VEC_ELT (packed_args
, idx
);
6875 if (PACK_EXPANSION_P (targ
))
6876 /* Look at the pattern of the pack expansion. */
6877 targ
= PACK_EXPANSION_PATTERN (targ
);
6879 /* Extract the template parameters from the template
6881 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6882 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6883 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6884 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6886 /* Verify that we can coerce the template template
6887 parameters from the template argument to the template
6888 parameter. This requires an exact match. */
6890 && !coerce_template_template_parms
6891 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6906 --processing_template_decl
;
6910 /* Since type attributes aren't mangled, we need to strip them from
6911 template type arguments. */
6914 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6916 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6918 bool removed_attributes
= false;
6919 tree canon
= strip_typedefs (arg
, &removed_attributes
);
6920 if (removed_attributes
6921 && (complain
& tf_warning
))
6922 warning (0, "ignoring attributes on template argument %qT", arg
);
6926 // A template declaration can be substituted for a constrained
6927 // template template parameter only when the argument is more
6928 // constrained than the parameter.
6930 is_compatible_template_arg (tree parm
, tree arg
)
6932 tree parm_cons
= get_constraints (parm
);
6934 /* For now, allow constrained template template arguments
6935 and unconstrained template template parameters. */
6936 if (parm_cons
== NULL_TREE
)
6939 tree arg_cons
= get_constraints (arg
);
6941 // If the template parameter is constrained, we need to rewrite its
6942 // constraints in terms of the ARG's template parameters. This ensures
6943 // that all of the template parameter types will have the same depth.
6945 // Note that this is only valid when coerce_template_template_parm is
6946 // true for the innermost template parameters of PARM and ARG. In other
6947 // words, because coercion is successful, this conversion will be valid.
6950 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (arg
));
6951 parm_cons
= tsubst_constraint_info (parm_cons
,
6952 INNERMOST_TEMPLATE_ARGS (args
),
6953 tf_none
, NULL_TREE
);
6954 if (parm_cons
== error_mark_node
)
6958 return subsumes (parm_cons
, arg_cons
);
6961 // Convert a placeholder argument into a binding to the original
6962 // parameter. The original parameter is saved as the TREE_TYPE of
6965 convert_wildcard_argument (tree parm
, tree arg
)
6967 TREE_TYPE (arg
) = parm
;
6971 /* Convert the indicated template ARG as necessary to match the
6972 indicated template PARM. Returns the converted ARG, or
6973 error_mark_node if the conversion was unsuccessful. Error and
6974 warning messages are issued under control of COMPLAIN. This
6975 conversion is for the Ith parameter in the parameter list. ARGS is
6976 the full set of template arguments deduced so far. */
6979 convert_template_argument (tree parm
,
6982 tsubst_flags_t complain
,
6988 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6990 if (parm
== error_mark_node
)
6991 return error_mark_node
;
6993 /* Trivially convert placeholders. */
6994 if (TREE_CODE (arg
) == WILDCARD_DECL
)
6995 return convert_wildcard_argument (parm
, arg
);
6997 if (TREE_CODE (arg
) == TREE_LIST
6998 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
7000 /* The template argument was the name of some
7001 member function. That's usually
7002 invalid, but static members are OK. In any
7003 case, grab the underlying fields/functions
7004 and issue an error later if required. */
7005 orig_arg
= TREE_VALUE (arg
);
7006 TREE_TYPE (arg
) = unknown_type_node
;
7011 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
7012 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
7013 || requires_tmpl_type
);
7015 /* When determining whether an argument pack expansion is a template,
7016 look at the pattern. */
7017 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
7018 arg
= PACK_EXPANSION_PATTERN (arg
);
7020 /* Deal with an injected-class-name used as a template template arg. */
7021 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
7023 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
7024 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7026 if (cxx_dialect
>= cxx11
)
7027 /* OK under DR 1004. */;
7028 else if (complain
& tf_warning_or_error
)
7029 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
7030 " used as template template argument", TYPE_NAME (arg
));
7031 else if (flag_pedantic_errors
)
7039 ((TREE_CODE (arg
) == TEMPLATE_DECL
7040 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
7041 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
7042 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7043 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
7046 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7047 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
7048 arg
= TYPE_STUB_DECL (arg
);
7050 is_type
= TYPE_P (arg
) || is_tmpl_type
;
7052 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
7053 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
7055 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
7057 if (complain
& tf_error
)
7058 error ("invalid use of destructor %qE as a type", orig_arg
);
7059 return error_mark_node
;
7062 permerror (input_location
,
7063 "to refer to a type member of a template parameter, "
7064 "use %<typename %E%>", orig_arg
);
7066 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
7067 TREE_OPERAND (arg
, 1),
7073 if (is_type
!= requires_type
)
7077 if (complain
& tf_error
)
7079 error ("type/value mismatch at argument %d in template "
7080 "parameter list for %qD",
7083 inform (input_location
,
7084 " expected a constant of type %qT, got %qT",
7086 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
7087 else if (requires_tmpl_type
)
7088 inform (input_location
,
7089 " expected a class template, got %qE", orig_arg
);
7091 inform (input_location
,
7092 " expected a type, got %qE", orig_arg
);
7095 return error_mark_node
;
7097 if (is_tmpl_type
^ requires_tmpl_type
)
7099 if (in_decl
&& (complain
& tf_error
))
7101 error ("type/value mismatch at argument %d in template "
7102 "parameter list for %qD",
7105 inform (input_location
,
7106 " expected a type, got %qT", DECL_NAME (arg
));
7108 inform (input_location
,
7109 " expected a class template, got %qT", orig_arg
);
7111 return error_mark_node
;
7116 if (requires_tmpl_type
)
7118 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
7120 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
7121 /* The number of argument required is not known yet.
7122 Just accept it for now. */
7123 val
= TREE_TYPE (arg
);
7126 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
7129 /* Strip alias templates that are equivalent to another
7131 arg
= get_underlying_template (arg
);
7132 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
7134 if (coerce_template_template_parms (parmparm
, argparm
,
7140 /* TEMPLATE_TEMPLATE_PARM node is preferred over
7142 if (val
!= error_mark_node
)
7144 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
7145 val
= TREE_TYPE (val
);
7146 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
7147 val
= make_pack_expansion (val
);
7152 if (in_decl
&& (complain
& tf_error
))
7154 error ("type/value mismatch at argument %d in "
7155 "template parameter list for %qD",
7157 inform (input_location
,
7158 " expected a template of type %qD, got %qT",
7162 val
= error_mark_node
;
7165 // Check that the constraints are compatible before allowing the
7167 if (val
!= error_mark_node
)
7168 if (!is_compatible_template_arg (parm
, arg
))
7170 if (in_decl
&& (complain
& tf_error
))
7172 error ("constraint mismatch at argument %d in "
7173 "template parameter list for %qD",
7175 inform (input_location
, " expected %qD but got %qD",
7178 val
= error_mark_node
;
7184 /* We only form one instance of each template specialization.
7185 Therefore, if we use a non-canonical variant (i.e., a
7186 typedef), any future messages referring to the type will use
7187 the typedef, which is confusing if those future uses do not
7188 themselves also use the typedef. */
7190 val
= canonicalize_type_argument (val
, complain
);
7194 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
7196 if (invalid_nontype_parm_type_p (t
, complain
))
7197 return error_mark_node
;
7199 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
7201 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
7205 /* Not sure if this is reachable, but it doesn't hurt
7207 error ("type mismatch in nontype parameter pack");
7208 val
= error_mark_node
;
7211 else if (!dependent_template_arg_p (orig_arg
)
7212 && !uses_template_parms (t
))
7213 /* We used to call digest_init here. However, digest_init
7214 will report errors, which we don't want when complain
7215 is zero. More importantly, digest_init will try too
7216 hard to convert things: for example, `0' should not be
7217 converted to pointer type at this point according to
7218 the standard. Accepting this is not merely an
7219 extension, since deciding whether or not these
7220 conversions can occur is part of determining which
7221 function template to call, or whether a given explicit
7222 argument specification is valid. */
7223 val
= convert_nontype_argument (t
, orig_arg
, complain
);
7226 bool removed_attr
= false;
7227 val
= strip_typedefs_expr (orig_arg
, &removed_attr
);
7230 if (val
== NULL_TREE
)
7231 val
= error_mark_node
;
7232 else if (val
== error_mark_node
&& (complain
& tf_error
))
7233 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
7235 if (INDIRECT_REF_P (val
))
7237 /* Reject template arguments that are references to built-in
7238 functions with no library fallbacks. */
7239 const_tree inner
= TREE_OPERAND (val
, 0);
7240 if (TREE_CODE (TREE_TYPE (inner
)) == REFERENCE_TYPE
7241 && TREE_CODE (TREE_TYPE (TREE_TYPE (inner
))) == FUNCTION_TYPE
7242 && TREE_CODE (TREE_TYPE (inner
)) == REFERENCE_TYPE
7243 && 0 < TREE_OPERAND_LENGTH (inner
)
7244 && reject_gcc_builtin (TREE_OPERAND (inner
, 0)))
7245 return error_mark_node
;
7248 if (TREE_CODE (val
) == SCOPE_REF
)
7250 /* Strip typedefs from the SCOPE_REF. */
7251 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
7252 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
7254 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
7255 QUALIFIED_NAME_IS_TEMPLATE (val
));
7262 /* Coerces the remaining template arguments in INNER_ARGS (from
7263 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
7264 Returns the coerced argument pack. PARM_IDX is the position of this
7265 parameter in the template parameter list. ARGS is the original
7266 template argument list. */
7268 coerce_template_parameter_pack (tree parms
,
7276 tsubst_flags_t complain
)
7278 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
7279 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
7282 tree packed_parms
= NULL_TREE
;
7284 if (arg_idx
> nargs
)
7287 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
7289 /* When the template parameter is a non-type template parameter pack
7290 or template template parameter pack whose type or template
7291 parameters use parameter packs, we know exactly how many arguments
7292 we are looking for. Build a vector of the instantiated decls for
7293 these template parameters in PACKED_PARMS. */
7294 /* We can't use make_pack_expansion here because it would interpret a
7295 _DECL as a use rather than a declaration. */
7296 tree decl
= TREE_VALUE (parm
);
7297 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
7298 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
7299 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
7300 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
7302 TREE_VEC_LENGTH (args
)--;
7303 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
7304 TREE_VEC_LENGTH (args
)++;
7306 if (packed_parms
== error_mark_node
)
7307 return error_mark_node
;
7309 /* If we're doing a partial instantiation of a member template,
7310 verify that all of the types used for the non-type
7311 template parameter pack are, in fact, valid for non-type
7312 template parameters. */
7314 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
7316 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
7317 for (j
= 0; j
< len
; ++j
)
7319 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
7320 if (invalid_nontype_parm_type_p (t
, complain
))
7321 return error_mark_node
;
7323 /* We don't know how many args we have yet, just
7324 use the unconverted ones for now. */
7328 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
7330 /* Check if we have a placeholder pack, which indicates we're
7331 in the context of a introduction list. In that case we want
7332 to match this pack to the single placeholder. */
7333 else if (arg_idx
< nargs
7334 && TREE_CODE (TREE_VEC_ELT (inner_args
, arg_idx
)) == WILDCARD_DECL
7335 && WILDCARD_PACK_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
7337 nargs
= arg_idx
+ 1;
7338 packed_args
= make_tree_vec (1);
7341 packed_args
= make_tree_vec (nargs
- arg_idx
);
7343 /* Convert the remaining arguments, which will be a part of the
7344 parameter pack "parm". */
7345 for (; arg_idx
< nargs
; ++arg_idx
)
7347 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
7348 tree actual_parm
= TREE_VALUE (parm
);
7349 int pack_idx
= arg_idx
- parm_idx
;
7353 /* Once we've packed as many args as we have types, stop. */
7354 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
7356 else if (PACK_EXPANSION_P (arg
))
7357 /* We don't know how many args we have yet, just
7358 use the unconverted ones for now. */
7361 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
7364 if (arg
== error_mark_node
)
7366 if (complain
& tf_error
)
7367 error ("template argument %d is invalid", arg_idx
+ 1);
7370 arg
= convert_template_argument (actual_parm
,
7371 arg
, new_args
, complain
, parm_idx
,
7373 if (arg
== error_mark_node
)
7375 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
7378 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
7379 && TREE_VEC_LENGTH (packed_args
) > 0)
7381 if (complain
& tf_error
)
7382 error ("wrong number of template arguments (%d, should be %d)",
7383 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
7384 return error_mark_node
;
7387 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
7388 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
7389 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
7392 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
7393 TREE_TYPE (argument_pack
)
7394 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
7395 TREE_CONSTANT (argument_pack
) = 1;
7398 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
7400 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
7401 TREE_VEC_LENGTH (packed_args
));
7402 return argument_pack
;
7405 /* Returns the number of pack expansions in the template argument vector
7409 pack_expansion_args_count (tree args
)
7414 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
7416 tree elt
= TREE_VEC_ELT (args
, i
);
7417 if (elt
&& PACK_EXPANSION_P (elt
))
7423 /* Convert all template arguments to their appropriate types, and
7424 return a vector containing the innermost resulting template
7425 arguments. If any error occurs, return error_mark_node. Error and
7426 warning messages are issued under control of COMPLAIN.
7428 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
7429 for arguments not specified in ARGS. Otherwise, if
7430 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
7431 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
7432 USE_DEFAULT_ARGS is false, then all arguments must be specified in
7436 coerce_template_parms (tree parms
,
7439 tsubst_flags_t complain
,
7440 bool require_all_args
,
7441 bool use_default_args
)
7443 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
7444 tree orig_inner_args
;
7447 tree new_inner_args
;
7448 int saved_unevaluated_operand
;
7449 int saved_inhibit_evaluation_warnings
;
7451 /* When used as a boolean value, indicates whether this is a
7452 variadic template parameter list. Since it's an int, we can also
7453 subtract it from nparms to get the number of non-variadic
7456 int variadic_args_p
= 0;
7457 int post_variadic_parms
= 0;
7459 /* Likewise for parameters with default arguments. */
7462 if (args
== error_mark_node
)
7463 return error_mark_node
;
7465 nparms
= TREE_VEC_LENGTH (parms
);
7467 /* Determine if there are any parameter packs or default arguments. */
7468 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
7470 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
7472 ++post_variadic_parms
;
7473 if (template_parameter_pack_p (TREE_VALUE (parm
)))
7475 if (TREE_PURPOSE (parm
))
7479 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
7480 /* If there are no parameters that follow a parameter pack, we need to
7481 expand any argument packs so that we can deduce a parameter pack from
7482 some non-packed args followed by an argument pack, as in variadic85.C.
7483 If there are such parameters, we need to leave argument packs intact
7484 so the arguments are assigned properly. This can happen when dealing
7485 with a nested class inside a partial specialization of a class
7486 template, as in variadic92.C, or when deducing a template parameter pack
7487 from a sub-declarator, as in variadic114.C. */
7488 if (!post_variadic_parms
)
7489 inner_args
= expand_template_argument_pack (inner_args
);
7491 /* Count any pack expansion args. */
7492 variadic_args_p
= pack_expansion_args_count (inner_args
);
7494 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
7495 if ((nargs
> nparms
&& !variadic_p
)
7496 || (nargs
< nparms
- variadic_p
7499 && (!use_default_args
7500 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
7501 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
7503 if (complain
& tf_error
)
7505 if (variadic_p
|| default_p
)
7507 nparms
-= variadic_p
+ default_p
;
7508 error ("wrong number of template arguments "
7509 "(%d, should be at least %d)", nargs
, nparms
);
7512 error ("wrong number of template arguments "
7513 "(%d, should be %d)", nargs
, nparms
);
7516 inform (DECL_SOURCE_LOCATION (in_decl
),
7517 "provided for %qD", in_decl
);
7520 return error_mark_node
;
7522 /* We can't pass a pack expansion to a non-pack parameter of an alias
7523 template (DR 1430). */
7525 && (DECL_ALIAS_TEMPLATE_P (in_decl
)
7526 || concept_template_p (in_decl
))
7528 && nargs
- variadic_args_p
< nparms
- variadic_p
)
7530 if (complain
& tf_error
)
7532 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
7534 tree arg
= TREE_VEC_ELT (inner_args
, i
);
7535 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
7537 if (PACK_EXPANSION_P (arg
)
7538 && !template_parameter_pack_p (parm
))
7540 if (DECL_ALIAS_TEMPLATE_P (in_decl
))
7541 error_at (location_of (arg
),
7542 "pack expansion argument for non-pack parameter "
7543 "%qD of alias template %qD", parm
, in_decl
);
7545 error_at (location_of (arg
),
7546 "pack expansion argument for non-pack parameter "
7547 "%qD of concept %qD", parm
, in_decl
);
7548 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
7555 return error_mark_node
;
7558 /* We need to evaluate the template arguments, even though this
7559 template-id may be nested within a "sizeof". */
7560 saved_unevaluated_operand
= cp_unevaluated_operand
;
7561 cp_unevaluated_operand
= 0;
7562 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
7563 c_inhibit_evaluation_warnings
= 0;
7564 new_inner_args
= make_tree_vec (nparms
);
7565 new_args
= add_outermost_template_args (args
, new_inner_args
);
7566 int pack_adjust
= 0;
7567 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
7572 /* Get the Ith template parameter. */
7573 parm
= TREE_VEC_ELT (parms
, parm_idx
);
7575 if (parm
== error_mark_node
)
7577 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
7581 /* Calculate the next argument. */
7582 if (arg_idx
< nargs
)
7583 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
7587 if (template_parameter_pack_p (TREE_VALUE (parm
))
7588 && !(arg
&& ARGUMENT_PACK_P (arg
)))
7590 /* Some arguments will be placed in the
7591 template parameter pack PARM. */
7592 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
7593 inner_args
, arg_idx
,
7597 if (arg
== NULL_TREE
)
7599 /* We don't know how many args we have yet, just use the
7600 unconverted (and still packed) ones for now. */
7601 new_inner_args
= orig_inner_args
;
7606 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
7608 /* Store this argument. */
7609 if (arg
== error_mark_node
)
7612 /* We are done with all of the arguments. */
7617 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
7618 arg_idx
+= pack_adjust
;
7625 if (PACK_EXPANSION_P (arg
))
7627 /* "If every valid specialization of a variadic template
7628 requires an empty template parameter pack, the template is
7629 ill-formed, no diagnostic required." So check that the
7630 pattern works with this parameter. */
7631 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
7632 tree conv
= convert_template_argument (TREE_VALUE (parm
),
7636 if (conv
== error_mark_node
)
7638 inform (input_location
, "so any instantiation with a "
7639 "non-empty parameter pack would be ill-formed");
7642 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
7643 /* Recover from missing typename. */
7644 TREE_VEC_ELT (inner_args
, arg_idx
)
7645 = make_pack_expansion (conv
);
7647 /* We don't know how many args we have yet, just
7648 use the unconverted ones for now. */
7649 new_inner_args
= inner_args
;
7654 else if (require_all_args
)
7656 /* There must be a default arg in this case. */
7657 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
7659 /* The position of the first default template argument,
7660 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7662 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7663 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7664 arg_idx
- pack_adjust
);
7669 if (arg
== error_mark_node
)
7671 if (complain
& tf_error
)
7672 error ("template argument %d is invalid", arg_idx
+ 1);
7675 /* This only occurs if there was an error in the template
7676 parameter list itself (which we would already have
7677 reported) that we are trying to recover from, e.g., a class
7678 template with a parameter list such as
7679 template<typename..., typename>. */
7682 arg
= convert_template_argument (TREE_VALUE (parm
),
7683 arg
, new_args
, complain
,
7686 if (arg
== error_mark_node
)
7688 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
7690 cp_unevaluated_operand
= saved_unevaluated_operand
;
7691 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
7693 if (variadic_p
&& arg_idx
< nargs
)
7695 if (complain
& tf_error
)
7697 error ("wrong number of template arguments "
7698 "(%d, should be %d)", nargs
, arg_idx
);
7700 error ("provided for %q+D", in_decl
);
7702 return error_mark_node
;
7706 return error_mark_node
;
7708 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7709 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7710 TREE_VEC_LENGTH (new_inner_args
));
7712 return new_inner_args
;
7715 /* Convert all template arguments to their appropriate types, and
7716 return a vector containing the innermost resulting template
7717 arguments. If any error occurs, return error_mark_node. Error and
7718 warning messages are not issued.
7720 Note that no function argument deduction is performed, and default
7721 arguments are used to fill in unspecified arguments. */
7723 coerce_template_parms (tree parms
, tree args
, tree in_decl
)
7725 return coerce_template_parms (parms
, args
, in_decl
, tf_none
, true, true);
7728 /* Convert all template arguments to their appropriate type, and
7729 instantiate default arguments as needed. This returns a vector
7730 containing the innermost resulting template arguments, or
7731 error_mark_node if unsuccessful. */
7733 coerce_template_parms (tree parms
, tree args
, tree in_decl
,
7734 tsubst_flags_t complain
)
7736 return coerce_template_parms (parms
, args
, in_decl
, complain
, true, true);
7739 /* Like coerce_template_parms. If PARMS represents all template
7740 parameters levels, this function returns a vector of vectors
7741 representing all the resulting argument levels. Note that in this
7742 case, only the innermost arguments are coerced because the
7743 outermost ones are supposed to have been coerced already.
7745 Otherwise, if PARMS represents only (the innermost) vector of
7746 parameters, this function returns a vector containing just the
7747 innermost resulting arguments. */
7750 coerce_innermost_template_parms (tree parms
,
7753 tsubst_flags_t complain
,
7754 bool require_all_args
,
7755 bool use_default_args
)
7757 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
7758 int args_depth
= TMPL_ARGS_DEPTH (args
);
7761 if (parms_depth
> 1)
7763 coerced_args
= make_tree_vec (parms_depth
);
7767 for (level
= parms
, cur_depth
= parms_depth
;
7768 parms_depth
> 0 && level
!= NULL_TREE
;
7769 level
= TREE_CHAIN (level
), --cur_depth
)
7772 if (cur_depth
== args_depth
)
7773 l
= coerce_template_parms (TREE_VALUE (level
),
7774 args
, in_decl
, complain
,
7778 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
7780 if (l
== error_mark_node
)
7781 return error_mark_node
;
7783 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
7787 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
7788 args
, in_decl
, complain
,
7791 return coerced_args
;
7794 /* Returns 1 if template args OT and NT are equivalent. */
7797 template_args_equal (tree ot
, tree nt
)
7801 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
7804 if (TREE_CODE (nt
) == TREE_VEC
)
7805 /* For member templates */
7806 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
7807 else if (PACK_EXPANSION_P (ot
))
7808 return (PACK_EXPANSION_P (nt
)
7809 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
7810 PACK_EXPANSION_PATTERN (nt
))
7811 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
7812 PACK_EXPANSION_EXTRA_ARGS (nt
)));
7813 else if (ARGUMENT_PACK_P (ot
))
7818 if (!ARGUMENT_PACK_P (nt
))
7821 opack
= ARGUMENT_PACK_ARGS (ot
);
7822 npack
= ARGUMENT_PACK_ARGS (nt
);
7823 len
= TREE_VEC_LENGTH (opack
);
7824 if (TREE_VEC_LENGTH (npack
) != len
)
7826 for (i
= 0; i
< len
; ++i
)
7827 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
7828 TREE_VEC_ELT (npack
, i
)))
7832 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
7834 /* We get here probably because we are in the middle of substituting
7835 into the pattern of a pack expansion. In that case the
7836 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7837 interested in. So we want to use the initial pack argument for
7839 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
7840 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
7841 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
7842 return template_args_equal (ot
, nt
);
7844 else if (TYPE_P (nt
))
7848 /* Don't treat an alias template specialization with dependent
7849 arguments as equivalent to its underlying type when used as a
7850 template argument; we need them to be distinct so that we
7851 substitute into the specialization arguments at instantiation
7852 time. And aliases can't be equivalent without being ==, so
7853 we don't need to look any deeper. */
7854 if (TYPE_ALIAS_P (nt
) || TYPE_ALIAS_P (ot
))
7857 return same_type_p (ot
, nt
);
7859 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
7863 /* Try to treat a template non-type argument that has been converted
7864 to the parameter type as equivalent to one that hasn't yet. */
7865 for (enum tree_code code1
= TREE_CODE (ot
);
7866 CONVERT_EXPR_CODE_P (code1
)
7867 || code1
== NON_LVALUE_EXPR
;
7868 code1
= TREE_CODE (ot
))
7869 ot
= TREE_OPERAND (ot
, 0);
7870 for (enum tree_code code2
= TREE_CODE (nt
);
7871 CONVERT_EXPR_CODE_P (code2
)
7872 || code2
== NON_LVALUE_EXPR
;
7873 code2
= TREE_CODE (nt
))
7874 nt
= TREE_OPERAND (nt
, 0);
7876 return cp_tree_equal (ot
, nt
);
7880 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7881 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7882 NEWARG_PTR with the offending arguments if they are non-NULL. */
7885 comp_template_args_with_info (tree oldargs
, tree newargs
,
7886 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7890 if (oldargs
== newargs
)
7893 if (!oldargs
|| !newargs
)
7896 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7899 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7901 tree nt
= TREE_VEC_ELT (newargs
, i
);
7902 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7904 if (! template_args_equal (ot
, nt
))
7906 if (oldarg_ptr
!= NULL
)
7908 if (newarg_ptr
!= NULL
)
7916 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7917 of template arguments. Returns 0 otherwise. */
7920 comp_template_args (tree oldargs
, tree newargs
)
7922 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7926 add_pending_template (tree d
)
7928 tree ti
= (TYPE_P (d
)
7929 ? CLASSTYPE_TEMPLATE_INFO (d
)
7930 : DECL_TEMPLATE_INFO (d
));
7931 struct pending_template
*pt
;
7934 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7937 /* We are called both from instantiate_decl, where we've already had a
7938 tinst_level pushed, and instantiate_template, where we haven't.
7940 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7943 push_tinst_level (d
);
7945 pt
= ggc_alloc
<pending_template
> ();
7947 pt
->tinst
= current_tinst_level
;
7948 if (last_pending_template
)
7949 last_pending_template
->next
= pt
;
7951 pending_templates
= pt
;
7953 last_pending_template
= pt
;
7955 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7962 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7963 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7964 documentation for TEMPLATE_ID_EXPR. */
7967 lookup_template_function (tree fns
, tree arglist
)
7971 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7972 return error_mark_node
;
7974 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7976 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7978 error ("%q#D is not a function template", fns
);
7979 return error_mark_node
;
7982 if (BASELINK_P (fns
))
7984 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7986 BASELINK_FUNCTIONS (fns
),
7991 type
= TREE_TYPE (fns
);
7992 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7993 type
= unknown_type_node
;
7995 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7998 /* Within the scope of a template class S<T>, the name S gets bound
7999 (in build_self_reference) to a TYPE_DECL for the class, not a
8000 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
8001 or one of its enclosing classes, and that type is a template,
8002 return the associated TEMPLATE_DECL. Otherwise, the original
8005 Also handle the case when DECL is a TREE_LIST of ambiguous
8006 injected-class-names from different bases. */
8009 maybe_get_template_decl_from_type_decl (tree decl
)
8011 if (decl
== NULL_TREE
)
8014 /* DR 176: A lookup that finds an injected-class-name (10.2
8015 [class.member.lookup]) can result in an ambiguity in certain cases
8016 (for example, if it is found in more than one base class). If all of
8017 the injected-class-names that are found refer to specializations of
8018 the same class template, and if the name is followed by a
8019 template-argument-list, the reference refers to the class template
8020 itself and not a specialization thereof, and is not ambiguous. */
8021 if (TREE_CODE (decl
) == TREE_LIST
)
8023 tree t
, tmpl
= NULL_TREE
;
8024 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
8026 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
8029 else if (tmpl
!= elt
)
8032 if (tmpl
&& t
== NULL_TREE
)
8038 return (decl
!= NULL_TREE
8039 && DECL_SELF_REFERENCE_P (decl
)
8040 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
8041 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
8044 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
8045 parameters, find the desired type.
8047 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
8049 IN_DECL, if non-NULL, is the template declaration we are trying to
8052 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
8053 the class we are looking up.
8055 Issue error and warning messages under control of COMPLAIN.
8057 If the template class is really a local class in a template
8058 function, then the FUNCTION_CONTEXT is the function in which it is
8061 ??? Note that this function is currently called *twice* for each
8062 template-id: the first time from the parser, while creating the
8063 incomplete type (finish_template_type), and the second type during the
8064 real instantiation (instantiate_template_class). This is surely something
8065 that we want to avoid. It also causes some problems with argument
8066 coercion (see convert_nontype_argument for more information on this). */
8069 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
8070 int entering_scope
, tsubst_flags_t complain
)
8072 tree templ
= NULL_TREE
, parmlist
;
8079 if (identifier_p (d1
))
8081 tree value
= innermost_non_namespace_value (d1
);
8082 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
8087 push_decl_namespace (context
);
8088 templ
= lookup_name (d1
);
8089 templ
= maybe_get_template_decl_from_type_decl (templ
);
8091 pop_decl_namespace ();
8094 context
= DECL_CONTEXT (templ
);
8096 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
8098 tree type
= TREE_TYPE (d1
);
8100 /* If we are declaring a constructor, say A<T>::A<T>, we will get
8101 an implicit typename for the second A. Deal with it. */
8102 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
8103 type
= TREE_TYPE (type
);
8105 if (CLASSTYPE_TEMPLATE_INFO (type
))
8107 templ
= CLASSTYPE_TI_TEMPLATE (type
);
8108 d1
= DECL_NAME (templ
);
8111 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
8112 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
8114 templ
= TYPE_TI_TEMPLATE (d1
);
8115 d1
= DECL_NAME (templ
);
8117 else if (DECL_TYPE_TEMPLATE_P (d1
))
8120 d1
= DECL_NAME (templ
);
8121 context
= DECL_CONTEXT (templ
);
8123 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
8126 d1
= DECL_NAME (templ
);
8129 /* Issue an error message if we didn't find a template. */
8132 if (complain
& tf_error
)
8133 error ("%qT is not a template", d1
);
8134 return error_mark_node
;
8137 if (TREE_CODE (templ
) != TEMPLATE_DECL
8138 /* Make sure it's a user visible template, if it was named by
8140 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
8141 && !PRIMARY_TEMPLATE_P (templ
)))
8143 if (complain
& tf_error
)
8145 error ("non-template type %qT used as a template", d1
);
8147 error ("for template declaration %q+D", in_decl
);
8149 return error_mark_node
;
8152 complain
&= ~tf_user
;
8154 /* An alias that just changes the name of a template is equivalent to the
8155 other template, so if any of the arguments are pack expansions, strip
8156 the alias to avoid problems with a pack expansion passed to a non-pack
8157 alias template parameter (DR 1430). */
8158 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
8159 templ
= get_underlying_template (templ
);
8161 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
8163 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
8164 template arguments */
8170 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
8172 /* Consider an example where a template template parameter declared as
8174 template <class T, class U = std::allocator<T> > class TT
8176 The template parameter level of T and U are one level larger than
8177 of TT. To proper process the default argument of U, say when an
8178 instantiation `TT<int>' is seen, we need to build the full
8179 arguments containing {int} as the innermost level. Outer levels,
8180 available when not appearing as default template argument, can be
8181 obtained from the arguments of the enclosing template.
8183 Suppose that TT is later substituted with std::vector. The above
8184 instantiation is `TT<int, std::allocator<T> >' with TT at
8185 level 1, and T at level 2, while the template arguments at level 1
8186 becomes {std::vector} and the inner level 2 is {int}. */
8188 outer
= DECL_CONTEXT (templ
);
8190 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
8191 else if (current_template_parms
)
8193 /* This is an argument of the current template, so we haven't set
8194 DECL_CONTEXT yet. */
8195 tree relevant_template_parms
;
8197 /* Parameter levels that are greater than the level of the given
8198 template template parm are irrelevant. */
8199 relevant_template_parms
= current_template_parms
;
8200 while (TMPL_PARMS_DEPTH (relevant_template_parms
)
8201 != TEMPLATE_TYPE_LEVEL (TREE_TYPE (templ
)))
8202 relevant_template_parms
= TREE_CHAIN (relevant_template_parms
);
8204 outer
= template_parms_to_args (relevant_template_parms
);
8208 arglist
= add_to_template_args (outer
, arglist
);
8210 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
8212 /*require_all_args=*/true,
8213 /*use_default_args=*/true);
8214 if (arglist2
== error_mark_node
8215 || (!uses_template_parms (arglist2
)
8216 && check_instantiated_args (templ
, arglist2
, complain
)))
8217 return error_mark_node
;
8219 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
8224 tree template_type
= TREE_TYPE (templ
);
8227 tree found
= NULL_TREE
;
8230 int is_dependent_type
;
8231 int use_partial_inst_tmpl
= false;
8233 if (template_type
== error_mark_node
)
8234 /* An error occurred while building the template TEMPL, and a
8235 diagnostic has most certainly been emitted for that
8236 already. Let's propagate that error. */
8237 return error_mark_node
;
8239 gen_tmpl
= most_general_template (templ
);
8240 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
8241 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
8242 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
8244 if (arg_depth
== 1 && parm_depth
> 1)
8246 /* We've been given an incomplete set of template arguments.
8249 template <class T> struct S1 {
8250 template <class U> struct S2 {};
8251 template <class U> struct S2<U*> {};
8254 we will be called with an ARGLIST of `U*', but the
8255 TEMPLATE will be `template <class T> template
8256 <class U> struct S1<T>::S2'. We must fill in the missing
8259 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
8261 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
8264 /* Now we should have enough arguments. */
8265 gcc_assert (parm_depth
== arg_depth
);
8267 /* From here on, we're only interested in the most general
8270 /* Calculate the BOUND_ARGS. These will be the args that are
8271 actually tsubst'd into the definition to create the
8273 arglist
= coerce_innermost_template_parms (parmlist
, arglist
, gen_tmpl
,
8275 /*require_all_args=*/true,
8276 /*use_default_args=*/true);
8278 if (arglist
== error_mark_node
)
8279 /* We were unable to bind the arguments. */
8280 return error_mark_node
;
8282 /* In the scope of a template class, explicit references to the
8283 template class refer to the type of the template, not any
8284 instantiation of it. For example, in:
8286 template <class T> class C { void f(C<T>); }
8288 the `C<T>' is just the same as `C'. Outside of the
8289 class, however, such a reference is an instantiation. */
8291 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
8292 || currently_open_class (template_type
))
8293 /* comp_template_args is expensive, check it last. */
8294 && comp_template_args (TYPE_TI_ARGS (template_type
),
8296 return template_type
;
8298 /* If we already have this specialization, return it. */
8299 elt
.tmpl
= gen_tmpl
;
8301 elt
.spec
= NULL_TREE
;
8302 hash
= spec_hasher::hash (&elt
);
8303 entry
= type_specializations
->find_with_hash (&elt
, hash
);
8308 /* If the the template's constraints are not satisfied,
8309 then we cannot form a valid type.
8311 Note that the check is deferred until after the hash
8312 lookup. This prevents redundant checks on previously
8313 instantiated specializations. */
8314 if (flag_concepts
&& !constraints_satisfied_p (gen_tmpl
, arglist
))
8316 if (complain
& tf_error
)
8318 error ("template constraint failure");
8319 diagnose_constraints (input_location
, gen_tmpl
, arglist
);
8321 return error_mark_node
;
8324 is_dependent_type
= uses_template_parms (arglist
);
8326 /* If the deduced arguments are invalid, then the binding
8328 if (!is_dependent_type
8329 && check_instantiated_args (gen_tmpl
,
8330 INNERMOST_TEMPLATE_ARGS (arglist
),
8332 return error_mark_node
;
8334 if (!is_dependent_type
8335 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
8336 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
8337 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
8339 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
8340 DECL_NAME (gen_tmpl
),
8341 /*tag_scope=*/ts_global
);
8345 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
8347 if (context
== error_mark_node
)
8348 return error_mark_node
;
8351 context
= global_namespace
;
8353 /* Create the type. */
8354 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8356 /* The user referred to a specialization of an alias
8357 template represented by GEN_TMPL.
8359 [temp.alias]/2 says:
8361 When a template-id refers to the specialization of an
8362 alias template, it is equivalent to the associated
8363 type obtained by substitution of its
8364 template-arguments for the template-parameters in the
8365 type-id of the alias template. */
8367 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
8368 /* Note that the call above (by indirectly calling
8369 register_specialization in tsubst_decl) registers the
8370 TYPE_DECL representing the specialization of the alias
8371 template. So next time someone substitutes ARGLIST for
8372 the template parms into the alias template (GEN_TMPL),
8373 she'll get that TYPE_DECL back. */
8375 if (t
== error_mark_node
)
8378 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
8380 if (!is_dependent_type
)
8382 set_current_access_from_decl (TYPE_NAME (template_type
));
8383 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
8384 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
8385 arglist
, complain
, in_decl
),
8386 SCOPED_ENUM_P (template_type
), NULL
);
8388 if (t
== error_mark_node
)
8393 /* We don't want to call start_enum for this type, since
8394 the values for the enumeration constants may involve
8395 template parameters. And, no one should be interested
8396 in the enumeration constants for such a type. */
8397 t
= cxx_make_type (ENUMERAL_TYPE
);
8398 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
8400 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
8401 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
8402 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
8404 else if (CLASS_TYPE_P (template_type
))
8406 t
= make_class_type (TREE_CODE (template_type
));
8407 CLASSTYPE_DECLARED_CLASS (t
)
8408 = CLASSTYPE_DECLARED_CLASS (template_type
);
8409 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
8410 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
8412 /* A local class. Make sure the decl gets registered properly. */
8413 if (context
== current_function_decl
)
8414 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
8416 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
8417 /* This instantiation is another name for the primary
8418 template type. Set the TYPE_CANONICAL field
8420 TYPE_CANONICAL (t
) = template_type
;
8421 else if (any_template_arguments_need_structural_equality_p (arglist
))
8422 /* Some of the template arguments require structural
8423 equality testing, so this template class requires
8424 structural equality testing. */
8425 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8430 /* If we called start_enum or pushtag above, this information
8431 will already be set up. */
8434 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
8436 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
8437 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
8438 DECL_SOURCE_LOCATION (type_decl
)
8439 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
8442 type_decl
= TYPE_NAME (t
);
8444 if (CLASS_TYPE_P (template_type
))
8446 TREE_PRIVATE (type_decl
)
8447 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
8448 TREE_PROTECTED (type_decl
)
8449 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
8450 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
8452 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
8453 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
8457 if (OVERLOAD_TYPE_P (t
)
8458 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8460 static const char *tags
[] = {"abi_tag", "may_alias"};
8462 for (unsigned ix
= 0; ix
!= 2; ix
++)
8465 = lookup_attribute (tags
[ix
], TYPE_ATTRIBUTES (template_type
));
8469 else if (!TREE_CHAIN (attributes
) && !TYPE_ATTRIBUTES (t
))
8470 TYPE_ATTRIBUTES (t
) = attributes
;
8473 = tree_cons (TREE_PURPOSE (attributes
),
8474 TREE_VALUE (attributes
),
8475 TYPE_ATTRIBUTES (t
));
8479 /* Let's consider the explicit specialization of a member
8480 of a class template specialization that is implicitly instantiated,
8485 template<class U> struct M {}; //#0
8490 struct S<int>::M<char> //#1
8494 [temp.expl.spec]/4 says this is valid.
8496 In this case, when we write:
8499 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
8502 When we encounter #1, we want to store the partial instantiation
8503 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
8505 For all cases other than this "explicit specialization of member of a
8506 class template", we just want to store the most general template into
8507 the CLASSTYPE_TI_TEMPLATE of M.
8509 This case of "explicit specialization of member of a class template"
8511 1/ the enclosing class is an instantiation of, and therefore not
8512 the same as, the context of the most general template, and
8513 2/ we aren't looking at the partial instantiation itself, i.e.
8514 the innermost arguments are not the same as the innermost parms of
8515 the most general template.
8517 So it's only when 1/ and 2/ happens that we want to use the partial
8518 instantiation of the member template in lieu of its most general
8521 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
8522 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
8523 /* the enclosing class must be an instantiation... */
8524 && CLASS_TYPE_P (context
)
8525 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
8527 tree partial_inst_args
;
8528 TREE_VEC_LENGTH (arglist
)--;
8529 ++processing_template_decl
;
8531 tsubst (INNERMOST_TEMPLATE_ARGS
8532 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
8533 arglist
, complain
, NULL_TREE
);
8534 --processing_template_decl
;
8535 TREE_VEC_LENGTH (arglist
)++;
8536 use_partial_inst_tmpl
=
8537 /*...and we must not be looking at the partial instantiation
8539 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
8543 if (!use_partial_inst_tmpl
)
8544 /* This case is easy; there are no member templates involved. */
8548 /* This is a full instantiation of a member template. Find
8549 the partial instantiation of which this is an instance. */
8551 /* Temporarily reduce by one the number of levels in the ARGLIST
8552 so as to avoid comparing the last set of arguments. */
8553 TREE_VEC_LENGTH (arglist
)--;
8554 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
8555 TREE_VEC_LENGTH (arglist
)++;
8556 /* FOUND is either a proper class type, or an alias
8557 template specialization. In the later case, it's a
8558 TYPE_DECL, resulting from the substituting of arguments
8559 for parameters in the TYPE_DECL of the alias template
8560 done earlier. So be careful while getting the template
8562 found
= TREE_CODE (found
) == TYPE_DECL
8563 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
8564 : CLASSTYPE_TI_TEMPLATE (found
);
8567 // Build template info for the new specialization.
8568 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
8571 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
8572 entry
= ggc_alloc
<spec_entry
> ();
8576 /* Note this use of the partial instantiation so we can check it
8577 later in maybe_process_partial_specialization. */
8578 DECL_TEMPLATE_INSTANTIATIONS (found
)
8579 = tree_cons (arglist
, t
,
8580 DECL_TEMPLATE_INSTANTIATIONS (found
));
8582 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
8583 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8584 /* Now that the type has been registered on the instantiations
8585 list, we set up the enumerators. Because the enumeration
8586 constants may involve the enumeration type itself, we make
8587 sure to register the type first, and then create the
8588 constants. That way, doing tsubst_expr for the enumeration
8589 constants won't result in recursive calls here; we'll find
8590 the instantiation and exit above. */
8591 tsubst_enum (template_type
, t
, arglist
);
8593 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
8594 /* If the type makes use of template parameters, the
8595 code that generates debugging information will crash. */
8596 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
8598 /* Possibly limit visibility based on template args. */
8599 TREE_PUBLIC (type_decl
) = 1;
8600 determine_visibility (type_decl
);
8602 inherit_targ_abi_tags (t
);
8608 /* Wrapper for lookup_template_class_1. */
8611 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
8612 int entering_scope
, tsubst_flags_t complain
)
8615 timevar_push (TV_TEMPLATE_INST
);
8616 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
8617 entering_scope
, complain
);
8618 timevar_pop (TV_TEMPLATE_INST
);
8622 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
8625 lookup_template_variable (tree templ
, tree arglist
)
8627 /* The type of the expression is NULL_TREE since the template-id could refer
8628 to an explicit or partial specialization. */
8629 tree type
= NULL_TREE
;
8630 if (flag_concepts
&& variable_concept_p (templ
))
8631 /* Except that concepts are always bool. */
8632 type
= boolean_type_node
;
8633 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
8636 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
8639 finish_template_variable (tree var
, tsubst_flags_t complain
)
8641 tree templ
= TREE_OPERAND (var
, 0);
8642 tree arglist
= TREE_OPERAND (var
, 1);
8644 /* We never want to return a VAR_DECL for a variable concept, since they
8645 aren't instantiated. In a template, leave the TEMPLATE_ID_EXPR alone. */
8646 bool concept_p
= flag_concepts
&& variable_concept_p (templ
);
8647 if (concept_p
&& processing_template_decl
)
8650 tree tmpl_args
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ
));
8651 arglist
= add_outermost_template_args (tmpl_args
, arglist
);
8653 tree parms
= DECL_TEMPLATE_PARMS (templ
);
8654 arglist
= coerce_innermost_template_parms (parms
, arglist
, templ
, complain
,
8656 /*use_default*/true);
8658 if (flag_concepts
&& !constraints_satisfied_p (templ
, arglist
))
8660 if (complain
& tf_error
)
8662 error ("constraints for %qD not satisfied", templ
);
8663 diagnose_constraints (location_of (var
), templ
, arglist
);
8665 return error_mark_node
;
8668 /* If a template-id refers to a specialization of a variable
8669 concept, then the expression is true if and only if the
8670 concept's constraints are satisfied by the given template
8673 NOTE: This is an extension of Concepts Lite TS that
8674 allows constraints to be used in expressions. */
8677 tree decl
= DECL_TEMPLATE_RESULT (templ
);
8678 return evaluate_variable_concept (decl
, arglist
);
8681 return instantiate_template (templ
, arglist
, complain
);
8688 /* True when we should also visit template parameters that occur in
8689 non-deduced contexts. */
8690 bool include_nondeduced_p
;
8691 hash_set
<tree
> *visited
;
8694 /* Called from for_each_template_parm via walk_tree. */
8697 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
8700 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
8701 tree_fn_t fn
= pfd
->fn
;
8702 void *data
= pfd
->data
;
8703 tree result
= NULL_TREE
;
8705 #define WALK_SUBTREE(NODE) \
8708 result = for_each_template_parm (NODE, fn, data, pfd->visited, \
8709 pfd->include_nondeduced_p); \
8710 if (result) goto out; \
8715 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
))
8716 WALK_SUBTREE (TYPE_CONTEXT (t
));
8718 switch (TREE_CODE (t
))
8721 if (TYPE_PTRMEMFUNC_P (t
))
8727 if (!TYPE_TEMPLATE_INFO (t
))
8730 WALK_SUBTREE (TYPE_TI_ARGS (t
));
8734 WALK_SUBTREE (TYPE_MIN_VALUE (t
));
8735 WALK_SUBTREE (TYPE_MAX_VALUE (t
));
8739 /* Since we're not going to walk subtrees, we have to do this
8741 WALK_SUBTREE (TYPE_METHOD_BASETYPE (t
));
8745 /* Check the return type. */
8746 WALK_SUBTREE (TREE_TYPE (t
));
8748 /* Check the parameter types. Since default arguments are not
8749 instantiated until they are needed, the TYPE_ARG_TYPES may
8750 contain expressions that involve template parameters. But,
8751 no-one should be looking at them yet. And, once they're
8752 instantiated, they don't contain template parameters, so
8753 there's no point in looking at them then, either. */
8757 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
8758 WALK_SUBTREE (TREE_VALUE (parm
));
8760 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8761 want walk_tree walking into them itself. */
8767 case UNDERLYING_TYPE
:
8768 if (pfd
->include_nondeduced_p
8769 && for_each_template_parm (TYPE_VALUES_RAW (t
), fn
, data
,
8771 pfd
->include_nondeduced_p
))
8772 return error_mark_node
;
8777 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
8778 WALK_SUBTREE (DECL_TI_ARGS (t
));
8783 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
))
8784 WALK_SUBTREE (DECL_INITIAL (t
));
8785 if (DECL_CONTEXT (t
)
8786 && pfd
->include_nondeduced_p
)
8787 WALK_SUBTREE (DECL_CONTEXT (t
));
8790 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8791 /* Record template parameters such as `T' inside `TT<T>'. */
8792 WALK_SUBTREE (TYPE_TI_ARGS (t
));
8795 case TEMPLATE_TEMPLATE_PARM
:
8796 case TEMPLATE_TYPE_PARM
:
8797 case TEMPLATE_PARM_INDEX
:
8798 if (fn
&& (*fn
)(t
, data
))
8805 /* A template template parameter is encountered. */
8806 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
8807 WALK_SUBTREE (TREE_TYPE (t
));
8809 /* Already substituted template template parameter */
8815 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t
));
8819 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8820 && pfd
->include_nondeduced_p
)
8821 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
8826 /* If there's no type, then this thing must be some expression
8827 involving template parameters. */
8828 if (!fn
&& !TREE_TYPE (t
))
8829 return error_mark_node
;
8834 case IMPLICIT_CONV_EXPR
:
8835 case REINTERPRET_CAST_EXPR
:
8836 case CONST_CAST_EXPR
:
8837 case STATIC_CAST_EXPR
:
8838 case DYNAMIC_CAST_EXPR
:
8842 case PSEUDO_DTOR_EXPR
:
8844 return error_mark_node
;
8853 /* We didn't find any template parameters we liked. */
8858 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8859 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8860 call FN with the parameter and the DATA.
8861 If FN returns nonzero, the iteration is terminated, and
8862 for_each_template_parm returns 1. Otherwise, the iteration
8863 continues. If FN never returns a nonzero value, the value
8864 returned by for_each_template_parm is 0. If FN is NULL, it is
8865 considered to be the function which always returns 1.
8867 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8868 parameters that occur in non-deduced contexts. When false, only
8869 visits those template parameters that can be deduced. */
8872 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8873 hash_set
<tree
> *visited
,
8874 bool include_nondeduced_p
)
8876 struct pair_fn_data pfd
;
8882 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8884 /* Walk the tree. (Conceptually, we would like to walk without
8885 duplicates, but for_each_template_parm_r recursively calls
8886 for_each_template_parm, so we would need to reorganize a fair
8887 bit to use walk_tree_without_duplicates, so we keep our own
8890 pfd
.visited
= visited
;
8892 pfd
.visited
= new hash_set
<tree
>;
8893 result
= cp_walk_tree (&t
,
8894 for_each_template_parm_r
,
8908 /* Returns true if T depends on any template parameter. */
8911 uses_template_parms (tree t
)
8917 int saved_processing_template_decl
;
8919 saved_processing_template_decl
= processing_template_decl
;
8920 if (!saved_processing_template_decl
)
8921 processing_template_decl
= 1;
8923 dependent_p
= dependent_type_p (t
);
8924 else if (TREE_CODE (t
) == TREE_VEC
)
8925 dependent_p
= any_dependent_template_arguments_p (t
);
8926 else if (TREE_CODE (t
) == TREE_LIST
)
8927 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8928 || uses_template_parms (TREE_CHAIN (t
)));
8929 else if (TREE_CODE (t
) == TYPE_DECL
)
8930 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8933 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8934 || TREE_CODE (t
) == OVERLOAD
8937 || TREE_CODE (t
) == TRAIT_EXPR
8938 || TREE_CODE (t
) == CONSTRUCTOR
8939 || CONSTANT_CLASS_P (t
))
8940 dependent_p
= (type_dependent_expression_p (t
)
8941 || value_dependent_expression_p (t
));
8944 gcc_assert (t
== error_mark_node
);
8945 dependent_p
= false;
8948 processing_template_decl
= saved_processing_template_decl
;
8953 /* Returns true iff current_function_decl is an incompletely instantiated
8954 template. Useful instead of processing_template_decl because the latter
8955 is set to 0 during instantiate_non_dependent_expr. */
8958 in_template_function (void)
8960 tree fn
= current_function_decl
;
8962 ++processing_template_decl
;
8963 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8964 && DECL_TEMPLATE_INFO (fn
)
8965 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8966 --processing_template_decl
;
8970 /* Returns true if T depends on any template parameter with level LEVEL. */
8973 uses_template_parms_level (tree t
, int level
)
8975 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8976 /*include_nondeduced_p=*/true);
8979 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8980 ill-formed translation unit, i.e. a variable or function that isn't
8981 usable in a constant expression. */
8984 neglectable_inst_p (tree d
)
8987 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8988 : decl_maybe_constant_var_p (d
)));
8991 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8992 neglectable and instantiated from within an erroneous instantiation. */
8995 limit_bad_template_recursion (tree decl
)
8997 struct tinst_level
*lev
= current_tinst_level
;
8998 int errs
= errorcount
+ sorrycount
;
8999 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
9002 for (; lev
; lev
= lev
->next
)
9003 if (neglectable_inst_p (lev
->decl
))
9006 return (lev
&& errs
> lev
->errors
);
9009 static int tinst_depth
;
9010 extern int max_tinst_depth
;
9013 static GTY(()) struct tinst_level
*last_error_tinst_level
;
9015 /* We're starting to instantiate D; record the template instantiation context
9016 for diagnostics and to restore it later. */
9019 push_tinst_level (tree d
)
9021 return push_tinst_level_loc (d
, input_location
);
9024 /* We're starting to instantiate D; record the template instantiation context
9025 at LOC for diagnostics and to restore it later. */
9028 push_tinst_level_loc (tree d
, location_t loc
)
9030 struct tinst_level
*new_level
;
9032 if (tinst_depth
>= max_tinst_depth
)
9034 fatal_error (input_location
,
9035 "template instantiation depth exceeds maximum of %d"
9036 " (use -ftemplate-depth= to increase the maximum)",
9041 /* If the current instantiation caused problems, don't let it instantiate
9042 anything else. Do allow deduction substitution and decls usable in
9043 constant expressions. */
9044 if (limit_bad_template_recursion (d
))
9047 new_level
= ggc_alloc
<tinst_level
> ();
9048 new_level
->decl
= d
;
9049 new_level
->locus
= loc
;
9050 new_level
->errors
= errorcount
+sorrycount
;
9051 new_level
->in_system_header_p
= in_system_header_at (input_location
);
9052 new_level
->next
= current_tinst_level
;
9053 current_tinst_level
= new_level
;
9056 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
9057 depth_reached
= tinst_depth
;
9062 /* We're done instantiating this template; return to the instantiation
9066 pop_tinst_level (void)
9068 /* Restore the filename and line number stashed away when we started
9069 this instantiation. */
9070 input_location
= current_tinst_level
->locus
;
9071 current_tinst_level
= current_tinst_level
->next
;
9075 /* We're instantiating a deferred template; restore the template
9076 instantiation context in which the instantiation was requested, which
9077 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
9080 reopen_tinst_level (struct tinst_level
*level
)
9082 struct tinst_level
*t
;
9085 for (t
= level
; t
; t
= t
->next
)
9088 current_tinst_level
= level
;
9090 if (current_tinst_level
)
9091 current_tinst_level
->errors
= errorcount
+sorrycount
;
9095 /* Returns the TINST_LEVEL which gives the original instantiation
9098 struct tinst_level
*
9099 outermost_tinst_level (void)
9101 struct tinst_level
*level
= current_tinst_level
;
9104 level
= level
->next
;
9108 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
9109 vector of template arguments, as for tsubst.
9111 Returns an appropriate tsubst'd friend declaration. */
9114 tsubst_friend_function (tree decl
, tree args
)
9118 if (TREE_CODE (decl
) == FUNCTION_DECL
9119 && DECL_TEMPLATE_INSTANTIATION (decl
)
9120 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
9121 /* This was a friend declared with an explicit template
9122 argument list, e.g.:
9126 to indicate that f was a template instantiation, not a new
9127 function declaration. Now, we have to figure out what
9128 instantiation of what template. */
9130 tree template_id
, arglist
, fns
;
9133 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
9135 /* Friend functions are looked up in the containing namespace scope.
9136 We must enter that scope, to avoid finding member functions of the
9137 current class with same name. */
9138 push_nested_namespace (ns
);
9139 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
9140 tf_warning_or_error
, NULL_TREE
,
9141 /*integral_constant_expression_p=*/false);
9142 pop_nested_namespace (ns
);
9143 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
9144 tf_warning_or_error
, NULL_TREE
);
9145 template_id
= lookup_template_function (fns
, arglist
);
9147 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
9148 tmpl
= determine_specialization (template_id
, new_friend
,
9150 /*need_member_template=*/0,
9151 TREE_VEC_LENGTH (args
),
9153 return instantiate_template (tmpl
, new_args
, tf_error
);
9156 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
9158 /* The NEW_FRIEND will look like an instantiation, to the
9159 compiler, but is not an instantiation from the point of view of
9160 the language. For example, we might have had:
9162 template <class T> struct S {
9163 template <class U> friend void f(T, U);
9166 Then, in S<int>, template <class U> void f(int, U) is not an
9167 instantiation of anything. */
9168 if (new_friend
== error_mark_node
)
9169 return error_mark_node
;
9171 DECL_USE_TEMPLATE (new_friend
) = 0;
9172 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
9174 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
9175 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
9176 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
9179 /* The mangled name for the NEW_FRIEND is incorrect. The function
9180 is not a template instantiation and should not be mangled like
9181 one. Therefore, we forget the mangling here; we'll recompute it
9182 later if we need it. */
9183 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
9185 SET_DECL_RTL (new_friend
, NULL
);
9186 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
9189 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
9192 tree new_friend_template_info
;
9193 tree new_friend_result_template_info
;
9195 int new_friend_is_defn
;
9197 /* We must save some information from NEW_FRIEND before calling
9198 duplicate decls since that function will free NEW_FRIEND if
9200 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
9201 new_friend_is_defn
=
9202 (DECL_INITIAL (DECL_TEMPLATE_RESULT
9203 (template_for_substitution (new_friend
)))
9205 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
9207 /* This declaration is a `primary' template. */
9208 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
9210 new_friend_result_template_info
9211 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
9214 new_friend_result_template_info
= NULL_TREE
;
9216 /* Make the init_value nonzero so pushdecl knows this is a defn. */
9217 if (new_friend_is_defn
)
9218 DECL_INITIAL (new_friend
) = error_mark_node
;
9220 /* Inside pushdecl_namespace_level, we will push into the
9221 current namespace. However, the friend function should go
9222 into the namespace of the template. */
9223 ns
= decl_namespace_context (new_friend
);
9224 push_nested_namespace (ns
);
9225 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
9226 pop_nested_namespace (ns
);
9228 if (old_decl
== error_mark_node
)
9229 return error_mark_node
;
9231 if (old_decl
!= new_friend
)
9233 /* This new friend declaration matched an existing
9234 declaration. For example, given:
9236 template <class T> void f(T);
9237 template <class U> class C {
9238 template <class T> friend void f(T) {}
9241 the friend declaration actually provides the definition
9242 of `f', once C has been instantiated for some type. So,
9243 old_decl will be the out-of-class template declaration,
9244 while new_friend is the in-class definition.
9246 But, if `f' was called before this point, the
9247 instantiation of `f' will have DECL_TI_ARGS corresponding
9248 to `T' but not to `U', references to which might appear
9249 in the definition of `f'. Previously, the most general
9250 template for an instantiation of `f' was the out-of-class
9251 version; now it is the in-class version. Therefore, we
9252 run through all specialization of `f', adding to their
9253 DECL_TI_ARGS appropriately. In particular, they need a
9254 new set of outer arguments, corresponding to the
9255 arguments for this class instantiation.
9257 The same situation can arise with something like this:
9260 template <class T> class C {
9264 when `C<int>' is instantiated. Now, `f(int)' is defined
9267 if (!new_friend_is_defn
)
9268 /* On the other hand, if the in-class declaration does
9269 *not* provide a definition, then we don't want to alter
9270 existing definitions. We can just leave everything
9275 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
9276 tree new_args
= TI_ARGS (new_friend_template_info
);
9278 /* Overwrite whatever template info was there before, if
9279 any, with the new template information pertaining to
9281 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
9283 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
9285 /* We should have called reregister_specialization in
9287 gcc_assert (retrieve_specialization (new_template
,
9291 /* Instantiate it if the global has already been used. */
9292 if (DECL_ODR_USED (old_decl
))
9293 instantiate_decl (old_decl
, /*defer_ok=*/true,
9294 /*expl_inst_class_mem_p=*/false);
9300 /* Indicate that the old function template is a partial
9302 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
9303 = new_friend_result_template_info
;
9305 gcc_assert (new_template
9306 == most_general_template (new_template
));
9307 gcc_assert (new_template
!= old_decl
);
9309 /* Reassign any specializations already in the hash table
9310 to the new more general template, and add the
9311 additional template args. */
9312 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
9316 tree spec
= TREE_VALUE (t
);
9319 elt
.tmpl
= old_decl
;
9320 elt
.args
= DECL_TI_ARGS (spec
);
9321 elt
.spec
= NULL_TREE
;
9323 decl_specializations
->remove_elt (&elt
);
9326 = add_outermost_template_args (new_args
,
9327 DECL_TI_ARGS (spec
));
9329 register_specialization
9330 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
9333 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
9337 /* The information from NEW_FRIEND has been merged into OLD_DECL
9338 by duplicate_decls. */
9339 new_friend
= old_decl
;
9344 tree context
= DECL_CONTEXT (new_friend
);
9348 template <class T> class C {
9349 template <class U> friend void C1<U>::f (); // case 1
9350 friend void C2<T>::f (); // case 2
9352 we only need to make sure CONTEXT is a complete type for
9353 case 2. To distinguish between the two cases, we note that
9354 CONTEXT of case 1 remains dependent type after tsubst while
9355 this isn't true for case 2. */
9356 ++processing_template_decl
;
9357 dependent_p
= dependent_type_p (context
);
9358 --processing_template_decl
;
9361 && !complete_type_or_else (context
, NULL_TREE
))
9362 return error_mark_node
;
9364 if (COMPLETE_TYPE_P (context
))
9366 tree fn
= new_friend
;
9367 /* do_friend adds the TEMPLATE_DECL for any member friend
9368 template even if it isn't a member template, i.e.
9369 template <class T> friend A<T>::f();
9370 Look through it in that case. */
9371 if (TREE_CODE (fn
) == TEMPLATE_DECL
9372 && !PRIMARY_TEMPLATE_P (fn
))
9373 fn
= DECL_TEMPLATE_RESULT (fn
);
9374 /* Check to see that the declaration is really present, and,
9375 possibly obtain an improved declaration. */
9376 fn
= check_classfn (context
, fn
, NULL_TREE
);
9386 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
9387 template arguments, as for tsubst.
9389 Returns an appropriate tsubst'd friend type or error_mark_node on
9393 tsubst_friend_class (tree friend_tmpl
, tree args
)
9399 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
9401 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
9402 return TREE_TYPE (t
);
9405 context
= CP_DECL_CONTEXT (friend_tmpl
);
9407 if (context
!= global_namespace
)
9409 if (TREE_CODE (context
) == NAMESPACE_DECL
)
9410 push_nested_namespace (context
);
9412 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
9415 /* Look for a class template declaration. We look for hidden names
9416 because two friend declarations of the same template are the
9417 same. For example, in:
9420 template <typename> friend class F;
9422 template <typename> struct B {
9423 template <typename> friend class F;
9426 both F templates are the same. */
9427 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
9428 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
9430 /* But, if we don't find one, it might be because we're in a
9431 situation like this:
9439 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
9440 for `S<int>', not the TEMPLATE_DECL. */
9441 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
9443 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
9444 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
9447 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
9449 /* The friend template has already been declared. Just
9450 check to see that the declarations match, and install any new
9451 default parameters. We must tsubst the default parameters,
9452 of course. We only need the innermost template parameters
9453 because that is all that redeclare_class_template will look
9455 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
9456 > TMPL_ARGS_DEPTH (args
))
9459 location_t saved_input_location
;
9460 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
9461 args
, tf_warning_or_error
);
9463 saved_input_location
= input_location
;
9464 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
9465 tree cons
= get_constraints (tmpl
);
9466 redeclare_class_template (TREE_TYPE (tmpl
), parms
, cons
);
9467 input_location
= saved_input_location
;
9471 friend_type
= TREE_TYPE (tmpl
);
9475 /* The friend template has not already been declared. In this
9476 case, the instantiation of the template class will cause the
9477 injection of this template into the global scope. */
9478 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
9479 if (tmpl
== error_mark_node
)
9480 return error_mark_node
;
9482 /* The new TMPL is not an instantiation of anything, so we
9483 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
9484 the new type because that is supposed to be the corresponding
9485 template decl, i.e., TMPL. */
9486 DECL_USE_TEMPLATE (tmpl
) = 0;
9487 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
9488 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
9489 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
9490 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
9492 /* Inject this template into the global scope. */
9493 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
9496 if (context
!= global_namespace
)
9498 if (TREE_CODE (context
) == NAMESPACE_DECL
)
9499 pop_nested_namespace (context
);
9501 pop_nested_class ();
9507 /* Returns zero if TYPE cannot be completed later due to circularity.
9508 Otherwise returns one. */
9511 can_complete_type_without_circularity (tree type
)
9513 if (type
== NULL_TREE
|| type
== error_mark_node
)
9515 else if (COMPLETE_TYPE_P (type
))
9517 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
9518 return can_complete_type_without_circularity (TREE_TYPE (type
));
9519 else if (CLASS_TYPE_P (type
)
9520 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
9526 static tree
tsubst_omp_clauses (tree
, bool, bool, tree
, tsubst_flags_t
, tree
);
9528 /* Apply any attributes which had to be deferred until instantiation
9529 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
9530 ARGS, COMPLAIN, IN_DECL are as tsubst. */
9533 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
9534 tree args
, tsubst_flags_t complain
, tree in_decl
)
9536 tree last_dep
= NULL_TREE
;
9540 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
9541 if (ATTR_IS_DEPENDENT (t
))
9544 attributes
= copy_list (attributes
);
9548 if (DECL_P (*decl_p
))
9550 if (TREE_TYPE (*decl_p
) == error_mark_node
)
9552 p
= &DECL_ATTRIBUTES (*decl_p
);
9555 p
= &TYPE_ATTRIBUTES (*decl_p
);
9559 tree late_attrs
= NULL_TREE
;
9560 tree
*q
= &late_attrs
;
9562 for (*p
= attributes
; *p
; )
9565 if (ATTR_IS_DEPENDENT (t
))
9567 *p
= TREE_CHAIN (t
);
9568 TREE_CHAIN (t
) = NULL_TREE
;
9569 if ((flag_openmp
|| flag_openmp_simd
|| flag_cilkplus
)
9570 && is_attribute_p ("omp declare simd",
9571 get_attribute_name (t
))
9574 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
9575 clauses
= tsubst_omp_clauses (clauses
, true, false, args
,
9577 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
9578 clauses
= finish_omp_clauses (clauses
, false, true);
9579 tree parms
= DECL_ARGUMENTS (*decl_p
);
9581 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
9583 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
9585 TREE_VALUE (t
) = NULL_TREE
;
9587 /* If the first attribute argument is an identifier, don't
9588 pass it through tsubst. Attributes like mode, format,
9589 cleanup and several target specific attributes expect it
9591 else if (attribute_takes_identifier_p (get_attribute_name (t
))
9595 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
9597 /*integral_constant_expression_p=*/false);
9598 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
9600 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
9603 else if (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
)))
9605 /* An attribute pack expansion. */
9606 tree purp
= TREE_PURPOSE (t
);
9607 tree pack
= (tsubst_pack_expansion
9608 (TREE_VALUE (t
), args
, complain
, in_decl
));
9609 int len
= TREE_VEC_LENGTH (pack
);
9610 for (int i
= 0; i
< len
; ++i
)
9612 tree elt
= TREE_VEC_ELT (pack
, i
);
9613 *q
= build_tree_list (purp
, elt
);
9614 q
= &TREE_CHAIN (*q
);
9620 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
9621 /*integral_constant_expression_p=*/false);
9623 q
= &TREE_CHAIN (t
);
9626 p
= &TREE_CHAIN (t
);
9629 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
9633 /* Perform (or defer) access check for typedefs that were referenced
9634 from within the template TMPL code.
9635 This is a subroutine of instantiate_decl and instantiate_class_template.
9636 TMPL is the template to consider and TARGS is the list of arguments of
9640 perform_typedefs_access_check (tree tmpl
, tree targs
)
9642 location_t saved_location
;
9644 qualified_typedef_usage_t
*iter
;
9647 || (!CLASS_TYPE_P (tmpl
)
9648 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
9651 saved_location
= input_location
;
9652 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
9654 tree type_decl
= iter
->typedef_decl
;
9655 tree type_scope
= iter
->context
;
9657 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
9660 if (uses_template_parms (type_decl
))
9661 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
9662 if (uses_template_parms (type_scope
))
9663 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
9665 /* Make access check error messages point to the location
9666 of the use of the typedef. */
9667 input_location
= iter
->locus
;
9668 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
9669 type_decl
, type_decl
,
9670 tf_warning_or_error
);
9672 input_location
= saved_location
;
9676 instantiate_class_template_1 (tree type
)
9678 tree templ
, args
, pattern
, t
, member
;
9682 unsigned int saved_maximum_field_alignment
;
9685 if (type
== error_mark_node
)
9686 return error_mark_node
;
9688 if (COMPLETE_OR_OPEN_TYPE_P (type
)
9689 || uses_template_parms (type
))
9692 /* Figure out which template is being instantiated. */
9693 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
9694 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
9696 /* Determine what specialization of the original template to
9698 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
9699 if (t
== error_mark_node
)
9701 TYPE_BEING_DEFINED (type
) = 1;
9702 return error_mark_node
;
9706 /* This TYPE is actually an instantiation of a partial
9707 specialization. We replace the innermost set of ARGS with
9708 the arguments appropriate for substitution. For example,
9711 template <class T> struct S {};
9712 template <class T> struct S<T*> {};
9714 and supposing that we are instantiating S<int*>, ARGS will
9715 presently be {int*} -- but we need {int}. */
9716 pattern
= TREE_TYPE (t
);
9717 args
= TREE_PURPOSE (t
);
9721 pattern
= TREE_TYPE (templ
);
9722 args
= CLASSTYPE_TI_ARGS (type
);
9725 /* If the template we're instantiating is incomplete, then clearly
9726 there's nothing we can do. */
9727 if (!COMPLETE_TYPE_P (pattern
))
9730 /* If we've recursively instantiated too many templates, stop. */
9731 if (! push_tinst_level (type
))
9734 /* Now we're really doing the instantiation. Mark the type as in
9735 the process of being defined. */
9736 TYPE_BEING_DEFINED (type
) = 1;
9738 /* We may be in the middle of deferred access check. Disable
9740 push_deferring_access_checks (dk_no_deferred
);
9742 int saved_unevaluated_operand
= cp_unevaluated_operand
;
9743 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
9745 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
9746 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
9747 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
9748 fn_context
= error_mark_node
;
9750 push_to_top_level ();
9753 cp_unevaluated_operand
= 0;
9754 c_inhibit_evaluation_warnings
= 0;
9756 /* Use #pragma pack from the template context. */
9757 saved_maximum_field_alignment
= maximum_field_alignment
;
9758 maximum_field_alignment
= TYPE_PRECISION (pattern
);
9760 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
9762 /* Set the input location to the most specialized template definition.
9763 This is needed if tsubsting causes an error. */
9764 typedecl
= TYPE_MAIN_DECL (pattern
);
9765 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
9766 DECL_SOURCE_LOCATION (typedecl
);
9768 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
9769 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
9770 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
9771 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
9772 if (ANON_AGGR_TYPE_P (pattern
))
9773 SET_ANON_AGGR_TYPE_P (type
);
9774 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
9776 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
9777 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
9778 /* Adjust visibility for template arguments. */
9779 determine_visibility (TYPE_MAIN_DECL (type
));
9781 if (CLASS_TYPE_P (type
))
9782 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
9784 pbinfo
= TYPE_BINFO (pattern
);
9786 /* We should never instantiate a nested class before its enclosing
9787 class; we need to look up the nested class by name before we can
9788 instantiate it, and that lookup should instantiate the enclosing
9790 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
9791 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
9793 base_list
= NULL_TREE
;
9794 if (BINFO_N_BASE_BINFOS (pbinfo
))
9800 /* We must enter the scope containing the type, as that is where
9801 the accessibility of types named in dependent bases are
9803 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
9805 /* Substitute into each of the bases to determine the actual
9807 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
9810 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
9811 tree expanded_bases
= NULL_TREE
;
9814 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
9817 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
9818 args
, tf_error
, NULL_TREE
);
9819 if (expanded_bases
== error_mark_node
)
9822 len
= TREE_VEC_LENGTH (expanded_bases
);
9825 for (idx
= 0; idx
< len
; idx
++)
9828 /* Extract the already-expanded base class. */
9829 base
= TREE_VEC_ELT (expanded_bases
, idx
);
9831 /* Substitute to figure out the base class. */
9832 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9835 if (base
== error_mark_node
)
9838 base_list
= tree_cons (access
, base
, base_list
);
9839 if (BINFO_VIRTUAL_P (pbase_binfo
))
9840 TREE_TYPE (base_list
) = integer_type_node
;
9844 /* The list is now in reverse order; correct that. */
9845 base_list
= nreverse (base_list
);
9848 pop_scope (pushed_scope
);
9850 /* Now call xref_basetypes to set up all the base-class
9852 xref_basetypes (type
, base_list
);
9854 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9855 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9856 args
, tf_error
, NULL_TREE
);
9857 fixup_attribute_variants (type
);
9859 /* Now that our base classes are set up, enter the scope of the
9860 class, so that name lookups into base classes, etc. will work
9861 correctly. This is precisely analogous to what we do in
9862 begin_class_definition when defining an ordinary non-template
9863 class, except we also need to push the enclosing classes. */
9864 push_nested_class (type
);
9866 /* Now members are processed in the order of declaration. */
9867 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9868 member
; member
= TREE_CHAIN (member
))
9870 tree t
= TREE_VALUE (member
);
9872 if (TREE_PURPOSE (member
))
9876 /* Build new CLASSTYPE_NESTED_UTDS. */
9879 bool class_template_p
;
9881 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9882 && TYPE_LANG_SPECIFIC (t
)
9883 && CLASSTYPE_IS_TEMPLATE (t
));
9884 /* If the member is a class template, then -- even after
9885 substitution -- there may be dependent types in the
9886 template argument list for the class. We increment
9887 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9888 that function will assume that no types are dependent
9889 when outside of a template. */
9890 if (class_template_p
)
9891 ++processing_template_decl
;
9892 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9893 if (class_template_p
)
9894 --processing_template_decl
;
9895 if (newtag
== error_mark_node
)
9898 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9900 tree name
= TYPE_IDENTIFIER (t
);
9902 if (class_template_p
)
9903 /* Unfortunately, lookup_template_class sets
9904 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9905 instantiation (i.e., for the type of a member
9906 template class nested within a template class.)
9907 This behavior is required for
9908 maybe_process_partial_specialization to work
9909 correctly, but is not accurate in this case;
9910 the TAG is not an instantiation of anything.
9911 (The corresponding TEMPLATE_DECL is an
9912 instantiation, but the TYPE is not.) */
9913 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9915 /* Now, we call pushtag to put this NEWTAG into the scope of
9916 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9917 pushtag calling push_template_decl. We don't have to do
9918 this for enums because it will already have been done in
9921 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9922 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9925 else if (DECL_DECLARES_FUNCTION_P (t
))
9927 /* Build new TYPE_METHODS. */
9930 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9931 ++processing_template_decl
;
9932 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9933 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9934 --processing_template_decl
;
9935 set_current_access_from_decl (r
);
9936 finish_member_declaration (r
);
9937 /* Instantiate members marked with attribute used. */
9938 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9940 if (TREE_CODE (r
) == FUNCTION_DECL
9941 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9942 cp_check_omp_declare_reduction (r
);
9944 else if (DECL_CLASS_TEMPLATE_P (t
)
9945 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
9946 /* A closure type for a lambda in a default argument for a
9947 member template. Ignore it; it will be instantiated with
9948 the default argument. */;
9951 /* Build new TYPE_FIELDS. */
9952 if (TREE_CODE (t
) == STATIC_ASSERT
)
9956 ++c_inhibit_evaluation_warnings
;
9958 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9959 tf_warning_or_error
, NULL_TREE
,
9960 /*integral_constant_expression_p=*/true);
9961 --c_inhibit_evaluation_warnings
;
9963 finish_static_assert (condition
,
9964 STATIC_ASSERT_MESSAGE (t
),
9965 STATIC_ASSERT_SOURCE_LOCATION (t
),
9968 else if (TREE_CODE (t
) != CONST_DECL
)
9971 tree vec
= NULL_TREE
;
9974 /* The file and line for this declaration, to
9975 assist in error message reporting. Since we
9976 called push_tinst_level above, we don't need to
9978 input_location
= DECL_SOURCE_LOCATION (t
);
9980 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9981 ++processing_template_decl
;
9982 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9983 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9984 --processing_template_decl
;
9986 if (TREE_CODE (r
) == TREE_VEC
)
9988 /* A capture pack became multiple fields. */
9990 len
= TREE_VEC_LENGTH (vec
);
9993 for (int i
= 0; i
< len
; ++i
)
9996 r
= TREE_VEC_ELT (vec
, i
);
10001 [t]he initialization (and any associated
10002 side-effects) of a static data member does
10003 not occur unless the static data member is
10004 itself used in a way that requires the
10005 definition of the static data member to
10008 Therefore, we do not substitute into the
10009 initialized for the static data member here. */
10010 finish_static_data_member_decl
10012 /*init=*/NULL_TREE
,
10013 /*init_const_expr_p=*/false,
10014 /*asmspec_tree=*/NULL_TREE
,
10016 /* Instantiate members marked with attribute used. */
10017 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
10020 else if (TREE_CODE (r
) == FIELD_DECL
)
10022 /* Determine whether R has a valid type and can be
10023 completed later. If R is invalid, then its type
10024 is replaced by error_mark_node. */
10025 tree rtype
= TREE_TYPE (r
);
10026 if (can_complete_type_without_circularity (rtype
))
10027 complete_type (rtype
);
10029 if (TREE_CODE (r
) == FIELD_DECL
10030 && TREE_CODE (rtype
) == ARRAY_TYPE
10031 && COMPLETE_TYPE_P (TREE_TYPE (rtype
))
10032 && !COMPLETE_TYPE_P (rtype
))
10034 /* Flexible array mmembers of elements
10035 of complete type have an incomplete type
10036 and that's okay. */
10038 else if (!COMPLETE_TYPE_P (rtype
))
10040 cxx_incomplete_type_error (r
, rtype
);
10041 TREE_TYPE (r
) = error_mark_node
;
10045 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
10046 such a thing will already have been added to the field
10047 list by tsubst_enum in finish_member_declaration in the
10048 CLASSTYPE_NESTED_UTDS case above. */
10049 if (!(TREE_CODE (r
) == TYPE_DECL
10050 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
10051 && DECL_ARTIFICIAL (r
)))
10053 set_current_access_from_decl (r
);
10054 finish_member_declaration (r
);
10062 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
10063 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10065 /* Build new CLASSTYPE_FRIEND_CLASSES. */
10067 tree friend_type
= t
;
10068 bool adjust_processing_template_decl
= false;
10070 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
10072 /* template <class T> friend class C; */
10073 friend_type
= tsubst_friend_class (friend_type
, args
);
10074 adjust_processing_template_decl
= true;
10076 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
10078 /* template <class T> friend class C::D; */
10079 friend_type
= tsubst (friend_type
, args
,
10080 tf_warning_or_error
, NULL_TREE
);
10081 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
10082 friend_type
= TREE_TYPE (friend_type
);
10083 adjust_processing_template_decl
= true;
10085 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
10086 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
10088 /* This could be either
10092 when dependent_type_p is false or
10094 template <class U> friend class T::C;
10097 friend_type
= tsubst (friend_type
, args
,
10098 tf_warning_or_error
, NULL_TREE
);
10099 /* Bump processing_template_decl for correct
10100 dependent_type_p calculation. */
10101 ++processing_template_decl
;
10102 if (dependent_type_p (friend_type
))
10103 adjust_processing_template_decl
= true;
10104 --processing_template_decl
;
10106 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
10107 && hidden_name_p (TYPE_NAME (friend_type
)))
10111 where C hasn't been declared yet. Let's lookup name
10112 from namespace scope directly, bypassing any name that
10113 come from dependent base class. */
10114 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
10116 /* The call to xref_tag_from_type does injection for friend
10118 push_nested_namespace (ns
);
10120 xref_tag_from_type (friend_type
, NULL_TREE
,
10121 /*tag_scope=*/ts_current
);
10122 pop_nested_namespace (ns
);
10124 else if (uses_template_parms (friend_type
))
10125 /* friend class C<T>; */
10126 friend_type
= tsubst (friend_type
, args
,
10127 tf_warning_or_error
, NULL_TREE
);
10132 where C is already declared or
10134 friend class C<int>;
10136 We don't have to do anything in these cases. */
10138 if (adjust_processing_template_decl
)
10139 /* Trick make_friend_class into realizing that the friend
10140 we're adding is a template, not an ordinary class. It's
10141 important that we use make_friend_class since it will
10142 perform some error-checking and output cross-reference
10144 ++processing_template_decl
;
10146 if (friend_type
!= error_mark_node
)
10147 make_friend_class (type
, friend_type
, /*complain=*/false);
10149 if (adjust_processing_template_decl
)
10150 --processing_template_decl
;
10154 /* Build new DECL_FRIENDLIST. */
10157 /* The file and line for this declaration, to
10158 assist in error message reporting. Since we
10159 called push_tinst_level above, we don't need to
10161 input_location
= DECL_SOURCE_LOCATION (t
);
10163 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10165 ++processing_template_decl
;
10166 push_deferring_access_checks (dk_no_check
);
10169 r
= tsubst_friend_function (t
, args
);
10170 add_friend (type
, r
, /*complain=*/false);
10171 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10173 pop_deferring_access_checks ();
10174 --processing_template_decl
;
10182 /* Restore these before substituting into the lambda capture
10184 cp_unevaluated_operand
= saved_unevaluated_operand
;
10185 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10188 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
10190 tree decl
= lambda_function (type
);
10193 if (!DECL_TEMPLATE_INFO (decl
)
10194 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
10196 /* Set function_depth to avoid garbage collection. */
10198 instantiate_decl (decl
, false, false);
10202 /* We need to instantiate the capture list from the template
10203 after we've instantiated the closure members, but before we
10204 consider adding the conversion op. Also keep any captures
10205 that may have been added during instantiation of the op(). */
10206 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
10208 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
10209 args
, tf_warning_or_error
, NULL_TREE
,
10212 LAMBDA_EXPR_CAPTURE_LIST (expr
)
10213 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
10215 maybe_add_lambda_conv_op (type
);
10218 gcc_assert (errorcount
);
10221 /* Set the file and line number information to whatever is given for
10222 the class itself. This puts error messages involving generated
10223 implicit functions at a predictable point, and the same point
10224 that would be used for non-template classes. */
10225 input_location
= DECL_SOURCE_LOCATION (typedecl
);
10227 unreverse_member_declarations (type
);
10228 finish_struct_1 (type
);
10229 TYPE_BEING_DEFINED (type
) = 0;
10231 /* We don't instantiate default arguments for member functions. 14.7.1:
10233 The implicit instantiation of a class template specialization causes
10234 the implicit instantiation of the declarations, but not of the
10235 definitions or default arguments, of the class member functions,
10236 member classes, static data members and member templates.... */
10238 /* Some typedefs referenced from within the template code need to be access
10239 checked at template instantiation time, i.e now. These types were
10240 added to the template at parsing time. Let's get those and perform
10241 the access checks then. */
10242 perform_typedefs_access_check (pattern
, args
);
10243 perform_deferred_access_checks (tf_warning_or_error
);
10244 pop_nested_class ();
10245 maximum_field_alignment
= saved_maximum_field_alignment
;
10247 pop_from_top_level ();
10248 pop_deferring_access_checks ();
10249 pop_tinst_level ();
10251 /* The vtable for a template class can be emitted in any translation
10252 unit in which the class is instantiated. When there is no key
10253 method, however, finish_struct_1 will already have added TYPE to
10254 the keyed_classes list. */
10255 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
10256 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
10261 /* Wrapper for instantiate_class_template_1. */
10264 instantiate_class_template (tree type
)
10267 timevar_push (TV_TEMPLATE_INST
);
10268 ret
= instantiate_class_template_1 (type
);
10269 timevar_pop (TV_TEMPLATE_INST
);
10274 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10280 else if (TYPE_P (t
))
10281 r
= tsubst (t
, args
, complain
, in_decl
);
10284 if (!(complain
& tf_warning
))
10285 ++c_inhibit_evaluation_warnings
;
10286 r
= tsubst_expr (t
, args
, complain
, in_decl
,
10287 /*integral_constant_expression_p=*/true);
10288 if (!(complain
& tf_warning
))
10289 --c_inhibit_evaluation_warnings
;
10294 /* Given a function parameter pack TMPL_PARM and some function parameters
10295 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
10296 and set *SPEC_P to point at the next point in the list. */
10299 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
10301 /* Collect all of the extra "packed" parameters into an
10305 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
10306 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
10307 tree spec_parm
= *spec_p
;
10310 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
10312 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
10315 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
10316 parmvec
= make_tree_vec (len
);
10317 parmtypevec
= make_tree_vec (len
);
10318 spec_parm
= *spec_p
;
10319 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
10321 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
10322 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
10325 /* Build the argument packs. */
10326 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
10327 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
10328 TREE_TYPE (argpack
) = argtypepack
;
10329 *spec_p
= spec_parm
;
10334 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
10335 NONTYPE_ARGUMENT_PACK. */
10338 make_fnparm_pack (tree spec_parm
)
10340 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
10343 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
10344 pack expansion with no extra args, 2 if it has extra args, or 0
10345 if it is not a pack expansion. */
10348 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
10350 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
10351 if (i
>= TREE_VEC_LENGTH (vec
))
10353 tree elt
= TREE_VEC_ELT (vec
, i
);
10355 /* A decl pack is itself an expansion. */
10356 elt
= TREE_TYPE (elt
);
10357 if (!PACK_EXPANSION_P (elt
))
10359 if (PACK_EXPANSION_EXTRA_ARGS (elt
))
10365 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
10368 make_argument_pack_select (tree arg_pack
, unsigned index
)
10370 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
10372 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
10373 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
10378 /* This is a subroutine of tsubst_pack_expansion.
10380 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
10381 mechanism to store the (non complete list of) arguments of the
10382 substitution and return a non substituted pack expansion, in order
10383 to wait for when we have enough arguments to really perform the
10387 use_pack_expansion_extra_args_p (tree parm_packs
,
10389 bool has_empty_arg
)
10391 /* If one pack has an expansion and another pack has a normal
10392 argument or if one pack has an empty argument and an another
10393 one hasn't then tsubst_pack_expansion cannot perform the
10394 substitution and need to fall back on the
10395 PACK_EXPANSION_EXTRA mechanism. */
10396 if (parm_packs
== NULL_TREE
)
10398 else if (has_empty_arg
)
10401 bool has_expansion_arg
= false;
10402 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
10404 bool has_non_expansion_arg
= false;
10405 for (tree parm_pack
= parm_packs
;
10407 parm_pack
= TREE_CHAIN (parm_pack
))
10409 tree arg
= TREE_VALUE (parm_pack
);
10411 int exp
= argument_pack_element_is_expansion_p (arg
, i
);
10413 /* We can't substitute a pack expansion with extra args into
10417 has_expansion_arg
= true;
10419 has_non_expansion_arg
= true;
10422 if (has_expansion_arg
&& has_non_expansion_arg
)
10428 /* [temp.variadic]/6 says that:
10430 The instantiation of a pack expansion [...]
10431 produces a list E1,E2, ..., En, where N is the number of elements
10432 in the pack expansion parameters.
10434 This subroutine of tsubst_pack_expansion produces one of these Ei.
10436 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
10437 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
10438 PATTERN, and each TREE_VALUE is its corresponding argument pack.
10439 INDEX is the index 'i' of the element Ei to produce. ARGS,
10440 COMPLAIN, and IN_DECL are the same parameters as for the
10441 tsubst_pack_expansion function.
10443 The function returns the resulting Ei upon successful completion,
10444 or error_mark_node.
10446 Note that this function possibly modifies the ARGS parameter, so
10447 it's the responsibility of the caller to restore it. */
10450 gen_elem_of_pack_expansion_instantiation (tree pattern
,
10453 tree args
/* This parm gets
10455 tsubst_flags_t complain
,
10459 bool ith_elem_is_expansion
= false;
10461 /* For each parameter pack, change the substitution of the parameter
10462 pack to the ith argument in its argument pack, then expand the
10464 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
10466 tree parm
= TREE_PURPOSE (pack
);
10467 tree arg_pack
= TREE_VALUE (pack
);
10468 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
10470 ith_elem_is_expansion
|=
10471 argument_pack_element_is_expansion_p (arg_pack
, index
);
10473 /* Select the Ith argument from the pack. */
10474 if (TREE_CODE (parm
) == PARM_DECL
10475 || TREE_CODE (parm
) == FIELD_DECL
)
10479 aps
= make_argument_pack_select (arg_pack
, index
);
10480 if (!mark_used (parm
, complain
) && !(complain
& tf_error
))
10481 return error_mark_node
;
10482 register_local_specialization (aps
, parm
);
10485 aps
= retrieve_local_specialization (parm
);
10490 template_parm_level_and_index (parm
, &level
, &idx
);
10494 aps
= make_argument_pack_select (arg_pack
, index
);
10495 /* Update the corresponding argument. */
10496 TMPL_ARG (args
, level
, idx
) = aps
;
10499 /* Re-use the ARGUMENT_PACK_SELECT. */
10500 aps
= TMPL_ARG (args
, level
, idx
);
10502 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
10505 /* Substitute into the PATTERN with the (possibly altered)
10507 if (pattern
== in_decl
)
10508 /* Expanding a fixed parameter pack from
10509 coerce_template_parameter_pack. */
10510 t
= tsubst_decl (pattern
, args
, complain
);
10511 else if (pattern
== error_mark_node
)
10512 t
= error_mark_node
;
10513 else if (constraint_p (pattern
))
10515 if (processing_template_decl
)
10516 t
= tsubst_constraint (pattern
, args
, complain
, in_decl
);
10518 t
= (constraints_satisfied_p (pattern
, args
)
10519 ? boolean_true_node
: boolean_false_node
);
10521 else if (!TYPE_P (pattern
))
10522 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
10523 /*integral_constant_expression_p=*/false);
10525 t
= tsubst (pattern
, args
, complain
, in_decl
);
10527 /* If the Ith argument pack element is a pack expansion, then
10528 the Ith element resulting from the substituting is going to
10529 be a pack expansion as well. */
10530 if (ith_elem_is_expansion
)
10531 t
= make_pack_expansion (t
);
10536 /* When the unexpanded parameter pack in a fold expression expands to an empty
10537 sequence, the value of the expression is as follows; the program is
10538 ill-formed if the operator is not listed in this table.
10549 expand_empty_fold (tree t
, tsubst_flags_t complain
)
10551 tree_code code
= (tree_code
)TREE_INT_CST_LOW (TREE_OPERAND (t
, 0));
10552 if (!FOLD_EXPR_MODIFY_P (t
))
10556 return integer_one_node
;
10558 return integer_zero_node
;
10560 return integer_minus_one_node
;
10562 return integer_zero_node
;
10563 case TRUTH_ANDIF_EXPR
:
10564 return boolean_true_node
;
10565 case TRUTH_ORIF_EXPR
:
10566 return boolean_false_node
;
10567 case COMPOUND_EXPR
:
10573 if (complain
& tf_error
)
10574 error_at (location_of (t
),
10575 "fold of empty expansion over %O", code
);
10576 return error_mark_node
;
10579 /* Given a fold-expression T and a current LEFT and RIGHT operand,
10580 form an expression that combines the two terms using the
10584 fold_expression (tree t
, tree left
, tree right
, tsubst_flags_t complain
)
10586 tree op
= FOLD_EXPR_OP (t
);
10587 tree_code code
= (tree_code
)TREE_INT_CST_LOW (op
);
10589 // Handle compound assignment operators.
10590 if (FOLD_EXPR_MODIFY_P (t
))
10591 return build_x_modify_expr (input_location
, left
, code
, right
, complain
);
10595 case COMPOUND_EXPR
:
10596 return build_x_compound_expr (input_location
, left
, right
, complain
);
10598 return build_m_component_ref (left
, right
, complain
);
10600 return build_x_binary_op (input_location
, code
,
10601 left
, TREE_CODE (left
),
10602 right
, TREE_CODE (right
),
10608 /* Substitute ARGS into the pack of a fold expression T. */
10611 tsubst_fold_expr_pack (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10613 return tsubst_pack_expansion (FOLD_EXPR_PACK (t
), args
, complain
, in_decl
);
10616 /* Substitute ARGS into the pack of a fold expression T. */
10619 tsubst_fold_expr_init (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10621 return tsubst_expr (FOLD_EXPR_INIT (t
), args
, complain
, in_decl
, false);
10624 /* Expand a PACK of arguments into a grouped as left fold.
10625 Given a pack containing elements A0, A1, ..., An and an
10626 operator @, this builds the expression:
10628 ((A0 @ A1) @ A2) ... @ An
10630 Note that PACK must not be empty.
10632 The operator is defined by the original fold expression T. */
10635 expand_left_fold (tree t
, tree pack
, tsubst_flags_t complain
)
10637 tree left
= TREE_VEC_ELT (pack
, 0);
10638 for (int i
= 1; i
< TREE_VEC_LENGTH (pack
); ++i
)
10640 tree right
= TREE_VEC_ELT (pack
, i
);
10641 left
= fold_expression (t
, left
, right
, complain
);
10646 /* Substitute into a unary left fold expression. */
10649 tsubst_unary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
10652 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
10653 if (pack
== error_mark_node
)
10654 return error_mark_node
;
10655 if (TREE_VEC_LENGTH (pack
) == 0)
10656 return expand_empty_fold (t
, complain
);
10658 return expand_left_fold (t
, pack
, complain
);
10661 /* Substitute into a binary left fold expression.
10663 Do ths by building a single (non-empty) vector of argumnts and
10664 building the expression from those elements. */
10667 tsubst_binary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
10670 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
10671 if (pack
== error_mark_node
)
10672 return error_mark_node
;
10673 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
10674 if (init
== error_mark_node
)
10675 return error_mark_node
;
10677 tree vec
= make_tree_vec (TREE_VEC_LENGTH (pack
) + 1);
10678 TREE_VEC_ELT (vec
, 0) = init
;
10679 for (int i
= 0; i
< TREE_VEC_LENGTH (pack
); ++i
)
10680 TREE_VEC_ELT (vec
, i
+ 1) = TREE_VEC_ELT (pack
, i
);
10682 return expand_left_fold (t
, vec
, complain
);
10685 /* Expand a PACK of arguments into a grouped as right fold.
10686 Given a pack containing elementns A0, A1, ..., and an
10687 operator @, this builds the expression:
10689 A0@ ... (An-2 @ (An-1 @ An))
10691 Note that PACK must not be empty.
10693 The operator is defined by the original fold expression T. */
10696 expand_right_fold (tree t
, tree pack
, tsubst_flags_t complain
)
10698 // Build the expression.
10699 int n
= TREE_VEC_LENGTH (pack
);
10700 tree right
= TREE_VEC_ELT (pack
, n
- 1);
10701 for (--n
; n
!= 0; --n
)
10703 tree left
= TREE_VEC_ELT (pack
, n
- 1);
10704 right
= fold_expression (t
, left
, right
, complain
);
10709 /* Substitute into a unary right fold expression. */
10712 tsubst_unary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
10715 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
10716 if (pack
== error_mark_node
)
10717 return error_mark_node
;
10718 if (TREE_VEC_LENGTH (pack
) == 0)
10719 return expand_empty_fold (t
, complain
);
10721 return expand_right_fold (t
, pack
, complain
);
10724 /* Substitute into a binary right fold expression.
10726 Do ths by building a single (non-empty) vector of arguments and
10727 building the expression from those elements. */
10730 tsubst_binary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
10733 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
10734 if (pack
== error_mark_node
)
10735 return error_mark_node
;
10736 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
10737 if (init
== error_mark_node
)
10738 return error_mark_node
;
10740 int n
= TREE_VEC_LENGTH (pack
);
10741 tree vec
= make_tree_vec (n
+ 1);
10742 for (int i
= 0; i
< n
; ++i
)
10743 TREE_VEC_ELT (vec
, i
) = TREE_VEC_ELT (pack
, i
);
10744 TREE_VEC_ELT (vec
, n
) = init
;
10746 return expand_right_fold (t
, vec
, complain
);
10750 /* Substitute ARGS into T, which is an pack expansion
10751 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
10752 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
10753 (if only a partial substitution could be performed) or
10754 ERROR_MARK_NODE if there was an error. */
10756 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
10760 tree pack
, packs
= NULL_TREE
;
10761 bool unsubstituted_packs
= false;
10764 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
10765 bool need_local_specializations
= false;
10768 gcc_assert (PACK_EXPANSION_P (t
));
10769 pattern
= PACK_EXPANSION_PATTERN (t
);
10771 /* Add in any args remembered from an earlier partial instantiation. */
10772 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
10774 levels
= TMPL_ARGS_DEPTH (args
);
10776 /* Determine the argument packs that will instantiate the parameter
10777 packs used in the expansion expression. While we're at it,
10778 compute the number of arguments to be expanded and make sure it
10780 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
10781 pack
= TREE_CHAIN (pack
))
10783 tree parm_pack
= TREE_VALUE (pack
);
10784 tree arg_pack
= NULL_TREE
;
10785 tree orig_arg
= NULL_TREE
;
10788 if (TREE_CODE (parm_pack
) == BASES
)
10790 if (BASES_DIRECT (parm_pack
))
10791 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
10792 args
, complain
, in_decl
, false));
10794 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
10795 args
, complain
, in_decl
, false));
10797 if (TREE_CODE (parm_pack
) == PARM_DECL
)
10799 /* We know we have correct local_specializations if this
10800 expansion is at function scope, or if we're dealing with a
10801 local parameter in a requires expression; for the latter,
10802 tsubst_requires_expr set it up appropriately. */
10803 if (PACK_EXPANSION_LOCAL_P (t
) || CONSTRAINT_VAR_P (parm_pack
))
10804 arg_pack
= retrieve_local_specialization (parm_pack
);
10807 /* We can't rely on local_specializations for a parameter
10808 name used later in a function declaration (such as in a
10809 late-specified return type). Even if it exists, it might
10810 have the wrong value for a recursive call. Just make a
10811 dummy decl, since it's only used for its type. */
10812 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
10813 if (arg_pack
&& DECL_PACK_P (arg_pack
))
10814 /* Partial instantiation of the parm_pack, we can't build
10815 up an argument pack yet. */
10816 arg_pack
= NULL_TREE
;
10818 arg_pack
= make_fnparm_pack (arg_pack
);
10819 need_local_specializations
= true;
10822 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
10823 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
10827 template_parm_level_and_index (parm_pack
, &level
, &idx
);
10829 if (level
<= levels
)
10830 arg_pack
= TMPL_ARG (args
, level
, idx
);
10833 orig_arg
= arg_pack
;
10834 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
10835 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
10837 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
10838 /* This can only happen if we forget to expand an argument
10839 pack somewhere else. Just return an error, silently. */
10841 result
= make_tree_vec (1);
10842 TREE_VEC_ELT (result
, 0) = error_mark_node
;
10849 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
10851 /* Don't bother trying to do a partial substitution with
10852 incomplete packs; we'll try again after deduction. */
10853 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
10858 else if (len
!= my_len
)
10860 if (!(complain
& tf_error
))
10861 /* Fail quietly. */;
10862 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
10863 error ("mismatched argument pack lengths while expanding "
10867 error ("mismatched argument pack lengths while expanding "
10870 return error_mark_node
;
10873 /* Keep track of the parameter packs and their corresponding
10875 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
10876 TREE_TYPE (packs
) = orig_arg
;
10880 /* We can't substitute for this parameter pack. We use a flag as
10881 well as the missing_level counter because function parameter
10882 packs don't have a level. */
10883 unsubstituted_packs
= true;
10887 /* If the expansion is just T..., return the matching argument pack, unless
10888 we need to call convert_from_reference on all the elements. This is an
10889 important optimization; see c++/68422. */
10890 if (!unsubstituted_packs
10891 && TREE_PURPOSE (packs
) == pattern
)
10893 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
10894 /* Types need no adjustment, nor does sizeof..., and if we still have
10895 some pack expansion args we won't do anything yet. */
10896 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
10897 || PACK_EXPANSION_SIZEOF_P (t
)
10898 || pack_expansion_args_count (args
))
10900 /* Also optimize expression pack expansions if we can tell that the
10901 elements won't have reference type. */
10902 tree type
= TREE_TYPE (pattern
);
10903 if (type
&& TREE_CODE (type
) != REFERENCE_TYPE
10904 && !PACK_EXPANSION_P (type
)
10905 && !WILDCARD_TYPE_P (type
))
10907 /* Otherwise use the normal path so we get convert_from_reference. */
10910 /* We cannot expand this expansion expression, because we don't have
10911 all of the argument packs we need. */
10912 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
10914 /* We got some full packs, but we can't substitute them in until we
10915 have values for all the packs. So remember these until then. */
10917 t
= make_pack_expansion (pattern
);
10918 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
10921 else if (unsubstituted_packs
)
10923 /* There were no real arguments, we're just replacing a parameter
10924 pack with another version of itself. Substitute into the
10925 pattern and return a PACK_EXPANSION_*. The caller will need to
10927 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
10928 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
10929 /*integral_constant_expression_p=*/false);
10931 t
= tsubst (pattern
, args
, complain
, in_decl
);
10932 t
= make_pack_expansion (t
);
10936 gcc_assert (len
>= 0);
10938 if (need_local_specializations
)
10940 /* We're in a late-specified return type, so create our own local
10941 specializations map; the current map is either NULL or (in the
10942 case of recursive unification) might have bindings that we don't
10943 want to use or alter. */
10944 saved_local_specializations
= local_specializations
;
10945 local_specializations
= new hash_map
<tree
, tree
>;
10948 /* For each argument in each argument pack, substitute into the
10950 result
= make_tree_vec (len
);
10951 for (i
= 0; i
< len
; ++i
)
10953 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
10957 TREE_VEC_ELT (result
, i
) = t
;
10958 if (t
== error_mark_node
)
10960 result
= error_mark_node
;
10965 /* Update ARGS to restore the substitution from parameter packs to
10966 their argument packs. */
10967 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
10969 tree parm
= TREE_PURPOSE (pack
);
10971 if (TREE_CODE (parm
) == PARM_DECL
10972 || TREE_CODE (parm
) == FIELD_DECL
)
10973 register_local_specialization (TREE_TYPE (pack
), parm
);
10978 if (TREE_VALUE (pack
) == NULL_TREE
)
10981 template_parm_level_and_index (parm
, &level
, &idx
);
10983 /* Update the corresponding argument. */
10984 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
10985 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
10988 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
10992 if (need_local_specializations
)
10994 delete local_specializations
;
10995 local_specializations
= saved_local_specializations
;
11001 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
11002 TMPL. We do this using DECL_PARM_INDEX, which should work even with
11003 parameter packs; all parms generated from a function parameter pack will
11004 have the same DECL_PARM_INDEX. */
11007 get_pattern_parm (tree parm
, tree tmpl
)
11009 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
11012 if (DECL_ARTIFICIAL (parm
))
11014 for (patparm
= DECL_ARGUMENTS (pattern
);
11015 patparm
; patparm
= DECL_CHAIN (patparm
))
11016 if (DECL_ARTIFICIAL (patparm
)
11017 && DECL_NAME (parm
) == DECL_NAME (patparm
))
11022 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
11023 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
11024 gcc_assert (DECL_PARM_INDEX (patparm
)
11025 == DECL_PARM_INDEX (parm
));
11031 /* Substitute ARGS into the vector or list of template arguments T. */
11034 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11037 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
11040 if (t
== error_mark_node
)
11041 return error_mark_node
;
11043 len
= TREE_VEC_LENGTH (t
);
11044 elts
= XALLOCAVEC (tree
, len
);
11046 for (i
= 0; i
< len
; i
++)
11048 tree orig_arg
= TREE_VEC_ELT (t
, i
);
11051 if (TREE_CODE (orig_arg
) == TREE_VEC
)
11052 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
11053 else if (PACK_EXPANSION_P (orig_arg
))
11055 /* Substitute into an expansion expression. */
11056 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
11058 if (TREE_CODE (new_arg
) == TREE_VEC
)
11059 /* Add to the expanded length adjustment the number of
11060 expanded arguments. We subtract one from this
11061 measurement, because the argument pack expression
11062 itself is already counted as 1 in
11063 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
11064 the argument pack is empty. */
11065 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
11067 else if (ARGUMENT_PACK_P (orig_arg
))
11069 /* Substitute into each of the arguments. */
11070 new_arg
= TYPE_P (orig_arg
)
11071 ? cxx_make_type (TREE_CODE (orig_arg
))
11072 : make_node (TREE_CODE (orig_arg
));
11074 SET_ARGUMENT_PACK_ARGS (
11076 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
11077 args
, complain
, in_decl
));
11079 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
11080 new_arg
= error_mark_node
;
11082 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
11083 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
11084 complain
, in_decl
);
11085 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
11087 if (TREE_TYPE (new_arg
) == error_mark_node
)
11088 new_arg
= error_mark_node
;
11092 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
11094 if (new_arg
== error_mark_node
)
11095 return error_mark_node
;
11098 if (new_arg
!= orig_arg
)
11105 /* Make space for the expanded arguments coming from template
11107 t
= make_tree_vec (len
+ expanded_len_adjust
);
11108 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
11109 arguments for a member template.
11110 In that case each TREE_VEC in ORIG_T represents a level of template
11111 arguments, and ORIG_T won't carry any non defaulted argument count.
11112 It will rather be the nested TREE_VECs that will carry one.
11113 In other words, ORIG_T carries a non defaulted argument count only
11114 if it doesn't contain any nested TREE_VEC. */
11115 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
11117 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
11118 count
+= expanded_len_adjust
;
11119 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
11121 for (i
= 0, out
= 0; i
< len
; i
++)
11123 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
11124 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
11125 && TREE_CODE (elts
[i
]) == TREE_VEC
)
11129 /* Now expand the template argument pack "in place". */
11130 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
11131 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
11135 TREE_VEC_ELT (t
, out
) = elts
[i
];
11143 /* Return the result of substituting ARGS into the template parameters
11144 given by PARMS. If there are m levels of ARGS and m + n levels of
11145 PARMS, then the result will contain n levels of PARMS. For
11146 example, if PARMS is `template <class T> template <class U>
11147 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
11148 result will be `template <int*, double, class V>'. */
11151 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
11153 tree r
= NULL_TREE
;
11156 /* When substituting into a template, we must set
11157 PROCESSING_TEMPLATE_DECL as the template parameters may be
11158 dependent if they are based on one-another, and the dependency
11159 predicates are short-circuit outside of templates. */
11160 ++processing_template_decl
;
11162 for (new_parms
= &r
;
11163 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
11164 new_parms
= &(TREE_CHAIN (*new_parms
)),
11165 parms
= TREE_CHAIN (parms
))
11168 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
11171 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
11175 if (parms
== error_mark_node
)
11178 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
11180 if (tuple
== error_mark_node
)
11183 TREE_VEC_ELT (new_vec
, i
) =
11184 tsubst_template_parm (tuple
, args
, complain
);
11188 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
11189 - TMPL_ARGS_DEPTH (args
)),
11190 new_vec
, NULL_TREE
);
11193 --processing_template_decl
;
11198 /* Return the result of substituting ARGS into one template parameter
11199 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
11200 parameter and which TREE_PURPOSE is the default argument of the
11201 template parameter. */
11204 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
11206 tree default_value
, parm_decl
;
11208 if (args
== NULL_TREE
11210 || t
== error_mark_node
)
11213 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
11215 default_value
= TREE_PURPOSE (t
);
11216 parm_decl
= TREE_VALUE (t
);
11218 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
11219 if (TREE_CODE (parm_decl
) == PARM_DECL
11220 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
11221 parm_decl
= error_mark_node
;
11222 default_value
= tsubst_template_arg (default_value
, args
,
11223 complain
, NULL_TREE
);
11225 return build_tree_list (default_value
, parm_decl
);
11228 /* Substitute the ARGS into the indicated aggregate (or enumeration)
11229 type T. If T is not an aggregate or enumeration type, it is
11230 handled as if by tsubst. IN_DECL is as for tsubst. If
11231 ENTERING_SCOPE is nonzero, T is the context for a template which
11232 we are presently tsubst'ing. Return the substituted value. */
11235 tsubst_aggr_type (tree t
,
11237 tsubst_flags_t complain
,
11239 int entering_scope
)
11241 if (t
== NULL_TREE
)
11244 switch (TREE_CODE (t
))
11247 if (TYPE_PTRMEMFUNC_P (t
))
11248 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
11250 /* Else fall through. */
11251 case ENUMERAL_TYPE
:
11253 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
11258 int saved_unevaluated_operand
;
11259 int saved_inhibit_evaluation_warnings
;
11261 /* In "sizeof(X<I>)" we need to evaluate "I". */
11262 saved_unevaluated_operand
= cp_unevaluated_operand
;
11263 cp_unevaluated_operand
= 0;
11264 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
11265 c_inhibit_evaluation_warnings
= 0;
11267 /* First, determine the context for the type we are looking
11269 context
= TYPE_CONTEXT (t
);
11270 if (context
&& TYPE_P (context
))
11272 context
= tsubst_aggr_type (context
, args
, complain
,
11273 in_decl
, /*entering_scope=*/1);
11274 /* If context is a nested class inside a class template,
11275 it may still need to be instantiated (c++/33959). */
11276 context
= complete_type (context
);
11279 /* Then, figure out what arguments are appropriate for the
11280 type we are trying to find. For example, given:
11282 template <class T> struct S;
11283 template <class T, class U> void f(T, U) { S<U> su; }
11285 and supposing that we are instantiating f<int, double>,
11286 then our ARGS will be {int, double}, but, when looking up
11287 S we only want {double}. */
11288 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
11289 complain
, in_decl
);
11290 if (argvec
== error_mark_node
)
11291 r
= error_mark_node
;
11294 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
11295 entering_scope
, complain
);
11296 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
11299 cp_unevaluated_operand
= saved_unevaluated_operand
;
11300 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
11305 /* This is not a template type, so there's nothing to do. */
11309 return tsubst (t
, args
, complain
, in_decl
);
11313 /* Substitute into the default argument ARG (a default argument for
11314 FN), which has the indicated TYPE. */
11317 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
11319 tree saved_class_ptr
= NULL_TREE
;
11320 tree saved_class_ref
= NULL_TREE
;
11321 int errs
= errorcount
+ sorrycount
;
11323 /* This can happen in invalid code. */
11324 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11327 /* This default argument came from a template. Instantiate the
11328 default argument here, not in tsubst. In the case of
11337 we must be careful to do name lookup in the scope of S<T>,
11338 rather than in the current class. */
11339 push_access_scope (fn
);
11340 /* The "this" pointer is not valid in a default argument. */
11343 saved_class_ptr
= current_class_ptr
;
11344 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
11345 saved_class_ref
= current_class_ref
;
11346 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
11349 push_deferring_access_checks(dk_no_deferred
);
11350 /* The default argument expression may cause implicitly defined
11351 member functions to be synthesized, which will result in garbage
11352 collection. We must treat this situation as if we were within
11353 the body of function so as to avoid collecting live data on the
11356 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
11357 complain
, NULL_TREE
,
11358 /*integral_constant_expression_p=*/false);
11360 pop_deferring_access_checks();
11362 /* Restore the "this" pointer. */
11365 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
11366 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
11369 if (errorcount
+sorrycount
> errs
11370 && (complain
& tf_warning_or_error
))
11371 inform (input_location
,
11372 " when instantiating default argument for call to %D", fn
);
11374 /* Make sure the default argument is reasonable. */
11375 arg
= check_default_argument (type
, arg
, complain
);
11377 pop_access_scope (fn
);
11382 /* Substitute into all the default arguments for FN. */
11385 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
11390 tmpl_args
= DECL_TI_ARGS (fn
);
11392 /* If this function is not yet instantiated, we certainly don't need
11393 its default arguments. */
11394 if (uses_template_parms (tmpl_args
))
11396 /* Don't do this again for clones. */
11397 if (DECL_CLONED_FUNCTION_P (fn
))
11400 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
11402 arg
= TREE_CHAIN (arg
))
11403 if (TREE_PURPOSE (arg
))
11404 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
11406 TREE_PURPOSE (arg
),
11410 /* Substitute the ARGS into the T, which is a _DECL. Return the
11411 result of the substitution. Issue error and warning messages under
11412 control of COMPLAIN. */
11415 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
11417 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
11418 location_t saved_loc
;
11419 tree r
= NULL_TREE
;
11421 hashval_t hash
= 0;
11423 /* Set the filename and linenumber to improve error-reporting. */
11424 saved_loc
= input_location
;
11425 input_location
= DECL_SOURCE_LOCATION (t
);
11427 switch (TREE_CODE (t
))
11429 case TEMPLATE_DECL
:
11431 /* We can get here when processing a member function template,
11432 member class template, or template template parameter. */
11433 tree decl
= DECL_TEMPLATE_RESULT (t
);
11438 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
11440 /* Template template parameter is treated here. */
11441 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11442 if (new_type
== error_mark_node
)
11443 r
= error_mark_node
;
11444 /* If we get a real template back, return it. This can happen in
11445 the context of most_specialized_partial_spec. */
11446 else if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
11449 /* The new TEMPLATE_DECL was built in
11450 reduce_template_parm_level. */
11451 r
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (new_type
);
11455 /* We might already have an instance of this template.
11456 The ARGS are for the surrounding class type, so the
11457 full args contain the tsubst'd args for the context,
11458 plus the innermost args from the template decl. */
11459 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
11460 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
11461 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
11462 /* Because this is a template, the arguments will still be
11463 dependent, even after substitution. If
11464 PROCESSING_TEMPLATE_DECL is not set, the dependency
11465 predicates will short-circuit. */
11466 ++processing_template_decl
;
11467 full_args
= tsubst_template_args (tmpl_args
, args
,
11468 complain
, in_decl
);
11469 --processing_template_decl
;
11470 if (full_args
== error_mark_node
)
11471 RETURN (error_mark_node
);
11473 /* If this is a default template template argument,
11474 tsubst might not have changed anything. */
11475 if (full_args
== tmpl_args
)
11478 hash
= hash_tmpl_and_args (t
, full_args
);
11479 spec
= retrieve_specialization (t
, full_args
, hash
);
11480 if (spec
!= NULL_TREE
)
11486 /* Make a new template decl. It will be similar to the
11487 original, but will record the current template arguments.
11488 We also create a new function declaration, which is just
11489 like the old one, but points to this new template, rather
11490 than the old one. */
11492 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
11493 DECL_CHAIN (r
) = NULL_TREE
;
11495 // Build new template info linking to the original template decl.
11496 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
11498 if (TREE_CODE (decl
) == TYPE_DECL
11499 && !TYPE_DECL_ALIAS_P (decl
))
11502 ++processing_template_decl
;
11503 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11504 --processing_template_decl
;
11505 if (new_type
== error_mark_node
)
11506 RETURN (error_mark_node
);
11508 TREE_TYPE (r
) = new_type
;
11509 /* For a partial specialization, we need to keep pointing to
11510 the primary template. */
11511 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
11512 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
11513 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
11514 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
11515 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
11520 ++processing_template_decl
;
11521 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
11522 --processing_template_decl
;
11523 if (new_decl
== error_mark_node
)
11524 RETURN (error_mark_node
);
11526 DECL_TEMPLATE_RESULT (r
) = new_decl
;
11527 DECL_TI_TEMPLATE (new_decl
) = r
;
11528 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
11529 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
11530 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
11533 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11534 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
11535 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
11537 /* The template parameters for this new template are all the
11538 template parameters for the old template, except the
11539 outermost level of parameters. */
11540 DECL_TEMPLATE_PARMS (r
)
11541 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
11544 if (PRIMARY_TEMPLATE_P (t
))
11545 DECL_PRIMARY_TEMPLATE (r
) = r
;
11547 if (TREE_CODE (decl
) != TYPE_DECL
&& !VAR_P (decl
))
11548 /* Record this non-type partial instantiation. */
11549 register_specialization (r
, t
,
11550 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
11555 case FUNCTION_DECL
:
11558 tree argvec
= NULL_TREE
;
11566 /* Nobody should be tsubst'ing into non-template functions. */
11567 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
11569 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
11574 /* If T is not dependent, just return it. We have to
11575 increment PROCESSING_TEMPLATE_DECL because
11576 value_dependent_expression_p assumes that nothing is
11577 dependent when PROCESSING_TEMPLATE_DECL is zero. */
11578 ++processing_template_decl
;
11579 dependent_p
= value_dependent_expression_p (t
);
11580 --processing_template_decl
;
11584 /* Calculate the most general template of which R is a
11585 specialization, and the complete set of arguments used to
11587 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
11588 argvec
= tsubst_template_args (DECL_TI_ARGS
11589 (DECL_TEMPLATE_RESULT
11590 (DECL_TI_TEMPLATE (t
))),
11591 args
, complain
, in_decl
);
11592 if (argvec
== error_mark_node
)
11593 RETURN (error_mark_node
);
11595 /* Check to see if we already have this specialization. */
11596 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11597 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11605 /* We can see more levels of arguments than parameters if
11606 there was a specialization of a member template, like
11609 template <class T> struct S { template <class U> void f(); }
11610 template <> template <class U> void S<int>::f(U);
11612 Here, we'll be substituting into the specialization,
11613 because that's where we can find the code we actually
11614 want to generate, but we'll have enough arguments for
11615 the most general template.
11617 We also deal with the peculiar case:
11619 template <class T> struct S {
11620 template <class U> friend void f();
11622 template <class U> void f() {}
11624 template void f<double>();
11626 Here, the ARGS for the instantiation of will be {int,
11627 double}. But, we only need as many ARGS as there are
11628 levels of template parameters in CODE_PATTERN. We are
11629 careful not to get fooled into reducing the ARGS in
11632 template <class T> struct S { template <class U> void f(U); }
11633 template <class T> template <> void S<T>::f(int) {}
11635 which we can spot because the pattern will be a
11636 specialization in this case. */
11637 args_depth
= TMPL_ARGS_DEPTH (args
);
11639 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
11640 if (args_depth
> parms_depth
11641 && !DECL_TEMPLATE_SPECIALIZATION (t
))
11642 args
= get_innermost_template_args (args
, parms_depth
);
11646 /* This special case arises when we have something like this:
11648 template <class T> struct S {
11649 friend void f<int>(int, double);
11652 Here, the DECL_TI_TEMPLATE for the friend declaration
11653 will be an IDENTIFIER_NODE. We are being called from
11654 tsubst_friend_function, and we want only to create a
11655 new decl (R) with appropriate types so that we can call
11656 determine_specialization. */
11657 gen_tmpl
= NULL_TREE
;
11660 if (DECL_CLASS_SCOPE_P (t
))
11662 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
11666 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
11667 complain
, t
, /*entering_scope=*/1);
11672 ctx
= DECL_CONTEXT (t
);
11674 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11675 if (type
== error_mark_node
)
11676 RETURN (error_mark_node
);
11678 /* If we hit excessive deduction depth, the type is bogus even if
11679 it isn't error_mark_node, so don't build a decl. */
11680 if (excessive_deduction_depth
)
11681 RETURN (error_mark_node
);
11683 /* We do NOT check for matching decls pushed separately at this
11684 point, as they may not represent instantiations of this
11685 template, and in any case are considered separate under the
11688 DECL_USE_TEMPLATE (r
) = 0;
11689 TREE_TYPE (r
) = type
;
11690 /* Clear out the mangled name and RTL for the instantiation. */
11691 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11692 SET_DECL_RTL (r
, NULL
);
11693 /* Leave DECL_INITIAL set on deleted instantiations. */
11694 if (!DECL_DELETED_FN (r
))
11695 DECL_INITIAL (r
) = NULL_TREE
;
11696 DECL_CONTEXT (r
) = ctx
;
11698 /* OpenMP UDRs have the only argument a reference to the declared
11699 type. We want to diagnose if the declared type is a reference,
11700 which is invalid, but as references to references are usually
11701 quietly merged, diagnose it here. */
11702 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
11705 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
11706 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
11707 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
11708 error_at (DECL_SOURCE_LOCATION (t
),
11709 "reference type %qT in "
11710 "%<#pragma omp declare reduction%>", argtype
);
11711 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
11712 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
11716 if (member
&& DECL_CONV_FN_P (r
))
11717 /* Type-conversion operator. Reconstruct the name, in
11718 case it's the name of one of the template's parameters. */
11719 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
11721 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
11723 DECL_RESULT (r
) = NULL_TREE
;
11725 TREE_STATIC (r
) = 0;
11726 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
11727 DECL_EXTERNAL (r
) = 1;
11728 /* If this is an instantiation of a function with internal
11729 linkage, we already know what object file linkage will be
11730 assigned to the instantiation. */
11731 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
11732 DECL_DEFER_OUTPUT (r
) = 0;
11733 DECL_CHAIN (r
) = NULL_TREE
;
11734 DECL_PENDING_INLINE_INFO (r
) = 0;
11735 DECL_PENDING_INLINE_P (r
) = 0;
11736 DECL_SAVED_TREE (r
) = NULL_TREE
;
11737 DECL_STRUCT_FUNCTION (r
) = NULL
;
11739 /* We'll re-clone as appropriate in instantiate_template. */
11740 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
11742 /* If we aren't complaining now, return on error before we register
11743 the specialization so that we'll complain eventually. */
11744 if ((complain
& tf_error
) == 0
11745 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
11746 && !grok_op_properties (r
, /*complain=*/false))
11747 RETURN (error_mark_node
);
11749 /* When instantiating a constrained member, substitute
11750 into the constraints to create a new constraint. */
11751 if (tree ci
= get_constraints (t
))
11754 ci
= tsubst_constraint_info (ci
, argvec
, complain
, NULL_TREE
);
11755 set_constraints (r
, ci
);
11758 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
11759 this in the special friend case mentioned above where
11760 GEN_TMPL is NULL. */
11763 DECL_TEMPLATE_INFO (r
)
11764 = build_template_info (gen_tmpl
, argvec
);
11765 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11768 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11770 /* We instantiated this while substituting into
11771 the type earlier (template/friend54.C). */
11774 /* We're not supposed to instantiate default arguments
11775 until they are called, for a template. But, for a
11778 template <class T> void f ()
11779 { extern void g(int i = T()); }
11781 we should do the substitution when the template is
11782 instantiated. We handle the member function case in
11783 instantiate_class_template since the default arguments
11784 might refer to other members of the class. */
11786 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
11787 && !uses_template_parms (argvec
))
11788 tsubst_default_arguments (r
, complain
);
11791 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
11793 /* Copy the list of befriending classes. */
11794 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
11796 friends
= &TREE_CHAIN (*friends
))
11798 *friends
= copy_node (*friends
);
11799 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
11804 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
11806 maybe_retrofit_in_chrg (r
);
11807 if (DECL_CONSTRUCTOR_P (r
))
11808 grok_ctor_properties (ctx
, r
);
11809 if (DECL_INHERITED_CTOR_BASE (r
))
11810 deduce_inheriting_ctor (r
);
11811 /* If this is an instantiation of a member template, clone it.
11812 If it isn't, that'll be handled by
11813 clone_constructors_and_destructors. */
11814 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
11815 clone_function_decl (r
, /*update_method_vec_p=*/0);
11817 else if ((complain
& tf_error
) != 0
11818 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
11819 && !grok_op_properties (r
, /*complain=*/true))
11820 RETURN (error_mark_node
);
11822 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
11823 SET_DECL_FRIEND_CONTEXT (r
,
11824 tsubst (DECL_FRIEND_CONTEXT (t
),
11825 args
, complain
, in_decl
));
11827 /* Possibly limit visibility based on template args. */
11828 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11829 if (DECL_VISIBILITY_SPECIFIED (t
))
11831 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11832 DECL_ATTRIBUTES (r
)
11833 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11835 determine_visibility (r
);
11836 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
11837 && !processing_template_decl
)
11838 defaulted_late_check (r
);
11840 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11841 args
, complain
, in_decl
);
11847 tree type
= NULL_TREE
;
11849 tree expanded_types
= NULL_TREE
;
11850 tree prev_r
= NULL_TREE
;
11851 tree first_r
= NULL_TREE
;
11853 if (DECL_PACK_P (t
))
11855 /* If there is a local specialization that isn't a
11856 parameter pack, it means that we're doing a "simple"
11857 substitution from inside tsubst_pack_expansion. Just
11858 return the local specialization (which will be a single
11860 tree spec
= retrieve_local_specialization (t
);
11862 && TREE_CODE (spec
) == PARM_DECL
11863 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
11866 /* Expand the TYPE_PACK_EXPANSION that provides the types for
11867 the parameters in this function parameter pack. */
11868 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
11869 complain
, in_decl
);
11870 if (TREE_CODE (expanded_types
) == TREE_VEC
)
11872 len
= TREE_VEC_LENGTH (expanded_types
);
11874 /* Zero-length parameter packs are boring. Just substitute
11877 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
11882 /* All we did was update the type. Make a note of that. */
11883 type
= expanded_types
;
11884 expanded_types
= NULL_TREE
;
11888 /* Loop through all of the parameters we'll build. When T is
11889 a function parameter pack, LEN is the number of expanded
11890 types in EXPANDED_TYPES; otherwise, LEN is 1. */
11892 for (i
= 0; i
< len
; ++i
)
11896 if (DECL_TEMPLATE_PARM_P (t
))
11897 SET_DECL_TEMPLATE_PARM_P (r
);
11899 if (expanded_types
)
11900 /* We're on the Ith parameter of the function parameter
11903 /* Get the Ith type. */
11904 type
= TREE_VEC_ELT (expanded_types
, i
);
11906 /* Rename the parameter to include the index. */
11908 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11911 /* We're dealing with a normal parameter. */
11912 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11914 type
= type_decays_to (type
);
11915 TREE_TYPE (r
) = type
;
11916 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11918 if (DECL_INITIAL (r
))
11920 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
11921 DECL_INITIAL (r
) = TREE_TYPE (r
);
11923 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
11924 complain
, in_decl
);
11927 DECL_CONTEXT (r
) = NULL_TREE
;
11929 if (!DECL_TEMPLATE_PARM_P (r
))
11930 DECL_ARG_TYPE (r
) = type_passed_as (type
);
11932 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11933 args
, complain
, in_decl
);
11935 /* Keep track of the first new parameter we
11936 generate. That's what will be returned to the
11941 /* Build a proper chain of parameters when substituting
11942 into a function parameter pack. */
11944 DECL_CHAIN (prev_r
) = r
;
11947 /* If cp_unevaluated_operand is set, we're just looking for a
11948 single dummy parameter, so don't keep going. */
11949 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
11950 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
11951 complain
, DECL_CHAIN (t
));
11953 /* FIRST_R contains the start of the chain we've built. */
11960 tree type
= NULL_TREE
;
11961 tree vec
= NULL_TREE
;
11962 tree expanded_types
= NULL_TREE
;
11965 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
11967 /* This field is a lambda capture pack. Return a TREE_VEC of
11968 the expanded fields to instantiate_class_template_1 and
11969 store them in the specializations hash table as a
11970 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
11971 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
11972 complain
, in_decl
);
11973 if (TREE_CODE (expanded_types
) == TREE_VEC
)
11975 len
= TREE_VEC_LENGTH (expanded_types
);
11976 vec
= make_tree_vec (len
);
11980 /* All we did was update the type. Make a note of that. */
11981 type
= expanded_types
;
11982 expanded_types
= NULL_TREE
;
11986 for (int i
= 0; i
< len
; ++i
)
11989 if (expanded_types
)
11991 type
= TREE_VEC_ELT (expanded_types
, i
);
11993 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11996 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11998 if (type
== error_mark_node
)
11999 RETURN (error_mark_node
);
12000 TREE_TYPE (r
) = type
;
12001 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
12003 if (DECL_C_BIT_FIELD (r
))
12004 /* For bit-fields, DECL_INITIAL gives the number of bits. For
12005 non-bit-fields DECL_INITIAL is a non-static data member
12006 initializer, which gets deferred instantiation. */
12008 = tsubst_expr (DECL_INITIAL (t
), args
,
12010 /*integral_constant_expression_p=*/true);
12011 else if (DECL_INITIAL (t
))
12013 /* Set up DECL_TEMPLATE_INFO so that we can get at the
12014 NSDMI in perform_member_init. Still set DECL_INITIAL
12015 so that we know there is one. */
12016 DECL_INITIAL (r
) = void_node
;
12017 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
12018 retrofit_lang_decl (r
);
12019 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
12021 /* We don't have to set DECL_CONTEXT here; it is set by
12022 finish_member_declaration. */
12023 DECL_CHAIN (r
) = NULL_TREE
;
12025 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
12026 args
, complain
, in_decl
);
12029 TREE_VEC_ELT (vec
, i
) = r
;
12035 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
12036 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
12037 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
12038 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
12039 TREE_TYPE (pack
) = tpack
;
12040 register_specialization (pack
, t
, args
, false, 0);
12046 /* We reach here only for member using decls. We also need to check
12047 uses_template_parms because DECL_DEPENDENT_P is not set for a
12048 using-declaration that designates a member of the current
12049 instantiation (c++/53549). */
12050 if (DECL_DEPENDENT_P (t
)
12051 || uses_template_parms (USING_DECL_SCOPE (t
)))
12053 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
12054 complain
, in_decl
);
12055 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
12056 r
= do_class_using_decl (inst_scope
, name
);
12058 r
= error_mark_node
;
12061 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
12062 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
12068 DECL_CHAIN (r
) = NULL_TREE
;
12075 tree argvec
= NULL_TREE
;
12076 tree gen_tmpl
= NULL_TREE
;
12078 tree tmpl
= NULL_TREE
;
12080 tree type
= NULL_TREE
;
12083 if (TREE_TYPE (t
) == error_mark_node
)
12084 RETURN (error_mark_node
);
12086 if (TREE_CODE (t
) == TYPE_DECL
12087 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
12089 /* If this is the canonical decl, we don't have to
12090 mess with instantiations, and often we can't (for
12091 typename, template type parms and such). Note that
12092 TYPE_NAME is not correct for the above test if
12093 we've copied the type for a typedef. */
12094 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12095 if (type
== error_mark_node
)
12096 RETURN (error_mark_node
);
12097 r
= TYPE_NAME (type
);
12101 /* Check to see if we already have the specialization we
12104 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
12106 /* T is a static data member or namespace-scope entity.
12107 We have to substitute into namespace-scope variables
12108 (not just variable templates) because of cases like:
12110 template <class T> void f() { extern T t; }
12112 where the entity referenced is not known until
12113 instantiation time. */
12115 ctx
= DECL_CONTEXT (t
);
12116 if (DECL_CLASS_SCOPE_P (t
))
12118 ctx
= tsubst_aggr_type (ctx
, args
,
12120 in_decl
, /*entering_scope=*/1);
12121 /* If CTX is unchanged, then T is in fact the
12122 specialization we want. That situation occurs when
12123 referencing a static data member within in its own
12124 class. We can use pointer equality, rather than
12125 same_type_p, because DECL_CONTEXT is always
12127 if (ctx
== DECL_CONTEXT (t
)
12128 /* ... unless T is a member template; in which
12129 case our caller can be willing to create a
12130 specialization of that template represented
12132 && !(DECL_TI_TEMPLATE (t
)
12133 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
12139 tmpl
= DECL_TI_TEMPLATE (t
);
12140 gen_tmpl
= most_general_template (tmpl
);
12141 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
12142 if (argvec
!= error_mark_node
)
12143 argvec
= (coerce_innermost_template_parms
12144 (DECL_TEMPLATE_PARMS (gen_tmpl
),
12145 argvec
, t
, complain
,
12146 /*all*/true, /*defarg*/true));
12147 if (argvec
== error_mark_node
)
12148 RETURN (error_mark_node
);
12149 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
12150 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
12155 /* A local variable. */
12157 /* Subsequent calls to pushdecl will fill this in. */
12159 spec
= retrieve_local_specialization (t
);
12161 /* If we already have the specialization we need, there is
12162 nothing more to do. */
12169 /* Create a new node for the specialization we need. */
12171 if (type
== NULL_TREE
)
12173 if (is_typedef_decl (t
))
12174 type
= DECL_ORIGINAL_TYPE (t
);
12176 type
= TREE_TYPE (t
);
12178 && VAR_HAD_UNKNOWN_BOUND (t
)
12179 && type
!= error_mark_node
)
12180 type
= strip_array_domain (type
);
12181 type
= tsubst (type
, args
, complain
, in_decl
);
12185 /* Even if the original location is out of scope, the
12186 newly substituted one is not. */
12187 DECL_DEAD_FOR_LOCAL (r
) = 0;
12188 DECL_INITIALIZED_P (r
) = 0;
12189 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
12190 if (type
== error_mark_node
)
12191 RETURN (error_mark_node
);
12192 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12194 /* It may seem that this case cannot occur, since:
12199 declares a function, not a variable. However:
12202 template <typename T> void g() { T t; }
12203 template void g<f>();
12205 is an attempt to declare a variable with function
12207 error ("variable %qD has function type",
12208 /* R is not yet sufficiently initialized, so we
12209 just use its name. */
12211 RETURN (error_mark_node
);
12213 type
= complete_type (type
);
12214 /* Wait until cp_finish_decl to set this again, to handle
12215 circular dependency (template/instantiate6.C). */
12216 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
12217 type
= check_var_type (DECL_NAME (r
), type
);
12219 if (DECL_HAS_VALUE_EXPR_P (t
))
12221 tree ve
= DECL_VALUE_EXPR (t
);
12222 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
12223 /*constant_expression_p=*/false);
12224 if (REFERENCE_REF_P (ve
))
12226 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
12227 ve
= TREE_OPERAND (ve
, 0);
12229 SET_DECL_VALUE_EXPR (r
, ve
);
12231 if (CP_DECL_THREAD_LOCAL_P (r
)
12232 && !processing_template_decl
)
12233 set_decl_tls_model (r
, decl_default_tls_model (r
));
12235 else if (DECL_SELF_REFERENCE_P (t
))
12236 SET_DECL_SELF_REFERENCE_P (r
);
12237 TREE_TYPE (r
) = type
;
12238 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
12239 DECL_CONTEXT (r
) = ctx
;
12240 /* Clear out the mangled name and RTL for the instantiation. */
12241 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
12242 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
12243 SET_DECL_RTL (r
, NULL
);
12244 /* The initializer must not be expanded until it is required;
12245 see [temp.inst]. */
12246 DECL_INITIAL (r
) = NULL_TREE
;
12247 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
12248 SET_DECL_RTL (r
, NULL
);
12249 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
12252 /* Possibly limit visibility based on template args. */
12253 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
12254 if (DECL_VISIBILITY_SPECIFIED (t
))
12256 DECL_VISIBILITY_SPECIFIED (r
) = 0;
12257 DECL_ATTRIBUTES (r
)
12258 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
12260 determine_visibility (r
);
12265 /* A static data member declaration is always marked
12266 external when it is declared in-class, even if an
12267 initializer is present. We mimic the non-template
12268 processing here. */
12269 DECL_EXTERNAL (r
) = 1;
12270 if (DECL_NAMESPACE_SCOPE_P (t
))
12271 DECL_NOT_REALLY_EXTERN (r
) = 1;
12273 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
12274 SET_DECL_IMPLICIT_INSTANTIATION (r
);
12275 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
12277 else if (!cp_unevaluated_operand
)
12278 register_local_specialization (r
, t
);
12280 DECL_CHAIN (r
) = NULL_TREE
;
12282 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
12284 args
, complain
, in_decl
);
12286 /* Preserve a typedef that names a type. */
12287 if (is_typedef_decl (r
))
12289 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
12290 set_underlying_type (r
);
12291 if (TYPE_DECL_ALIAS_P (r
) && type
!= error_mark_node
)
12292 /* An alias template specialization can be dependent
12293 even if its underlying type is not. */
12294 TYPE_DEPENDENT_P_VALID (TREE_TYPE (r
)) = false;
12297 layout_decl (r
, 0);
12302 gcc_unreachable ();
12307 /* Restore the file and line information. */
12308 input_location
= saved_loc
;
12313 /* Substitute into the ARG_TYPES of a function type.
12314 If END is a TREE_CHAIN, leave it and any following types
12318 tsubst_arg_types (tree arg_types
,
12321 tsubst_flags_t complain
,
12324 tree remaining_arg_types
;
12325 tree type
= NULL_TREE
;
12327 tree expanded_args
= NULL_TREE
;
12330 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
12333 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
12334 args
, end
, complain
, in_decl
);
12335 if (remaining_arg_types
== error_mark_node
)
12336 return error_mark_node
;
12338 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
12340 /* For a pack expansion, perform substitution on the
12341 entire expression. Later on, we'll handle the arguments
12343 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
12344 args
, complain
, in_decl
);
12346 if (TREE_CODE (expanded_args
) == TREE_VEC
)
12347 /* So that we'll spin through the parameters, one by one. */
12348 i
= TREE_VEC_LENGTH (expanded_args
);
12351 /* We only partially substituted into the parameter
12352 pack. Our type is TYPE_PACK_EXPANSION. */
12353 type
= expanded_args
;
12354 expanded_args
= NULL_TREE
;
12362 type
= TREE_VEC_ELT (expanded_args
, i
);
12364 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
12366 if (type
== error_mark_node
)
12367 return error_mark_node
;
12368 if (VOID_TYPE_P (type
))
12370 if (complain
& tf_error
)
12372 error ("invalid parameter type %qT", type
);
12374 error ("in declaration %q+D", in_decl
);
12376 return error_mark_node
;
12379 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
12380 return error_mark_node
;
12382 /* Do array-to-pointer, function-to-pointer conversion, and ignore
12383 top-level qualifiers as required. */
12384 type
= cv_unqualified (type_decays_to (type
));
12386 /* We do not substitute into default arguments here. The standard
12387 mandates that they be instantiated only when needed, which is
12388 done in build_over_call. */
12389 default_arg
= TREE_PURPOSE (arg_types
);
12391 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
12393 /* We've instantiated a template before its default arguments
12394 have been parsed. This can happen for a nested template
12395 class, and is not an error unless we require the default
12396 argument in a call of this function. */
12397 remaining_arg_types
=
12398 tree_cons (default_arg
, type
, remaining_arg_types
);
12399 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
12402 remaining_arg_types
=
12403 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
12406 return remaining_arg_types
;
12409 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
12410 *not* handle the exception-specification for FNTYPE, because the
12411 initial substitution of explicitly provided template parameters
12412 during argument deduction forbids substitution into the
12413 exception-specification:
12417 All references in the function type of the function template to the
12418 corresponding template parameters are replaced by the specified tem-
12419 plate argument values. If a substitution in a template parameter or
12420 in the function type of the function template results in an invalid
12421 type, type deduction fails. [Note: The equivalent substitution in
12422 exception specifications is done only when the function is instanti-
12423 ated, at which point a program is ill-formed if the substitution
12424 results in an invalid type.] */
12427 tsubst_function_type (tree t
,
12429 tsubst_flags_t complain
,
12433 tree arg_types
= NULL_TREE
;
12436 /* The TYPE_CONTEXT is not used for function/method types. */
12437 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
12439 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
12441 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
12443 if (late_return_type_p
)
12445 /* Substitute the argument types. */
12446 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
12447 complain
, in_decl
);
12448 if (arg_types
== error_mark_node
)
12449 return error_mark_node
;
12451 tree save_ccp
= current_class_ptr
;
12452 tree save_ccr
= current_class_ref
;
12453 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
12454 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
12455 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
12458 /* DR 1207: 'this' is in scope in the trailing return type. */
12459 inject_this_parameter (this_type
, cp_type_quals (this_type
));
12462 /* Substitute the return type. */
12463 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12467 current_class_ptr
= save_ccp
;
12468 current_class_ref
= save_ccr
;
12472 /* Substitute the return type. */
12473 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12475 if (return_type
== error_mark_node
)
12476 return error_mark_node
;
12477 /* DR 486 clarifies that creation of a function type with an
12478 invalid return type is a deduction failure. */
12479 if (TREE_CODE (return_type
) == ARRAY_TYPE
12480 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
12482 if (complain
& tf_error
)
12484 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
12485 error ("function returning an array");
12487 error ("function returning a function");
12489 return error_mark_node
;
12492 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
12493 return error_mark_node
;
12495 if (!late_return_type_p
)
12497 /* Substitute the argument types. */
12498 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
12499 complain
, in_decl
);
12500 if (arg_types
== error_mark_node
)
12501 return error_mark_node
;
12504 /* Construct a new type node and return it. */
12505 if (TREE_CODE (t
) == FUNCTION_TYPE
)
12507 fntype
= build_function_type (return_type
, arg_types
);
12508 fntype
= apply_memfn_quals (fntype
,
12509 type_memfn_quals (t
),
12510 type_memfn_rqual (t
));
12514 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
12515 /* Don't pick up extra function qualifiers from the basetype. */
12516 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
12517 if (! MAYBE_CLASS_TYPE_P (r
))
12521 Type deduction may fail for any of the following
12524 -- Attempting to create "pointer to member of T" when T
12525 is not a class type. */
12526 if (complain
& tf_error
)
12527 error ("creating pointer to member function of non-class type %qT",
12529 return error_mark_node
;
12532 fntype
= build_method_type_directly (r
, return_type
,
12533 TREE_CHAIN (arg_types
));
12534 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
12536 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
12538 if (late_return_type_p
)
12539 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
12544 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
12545 ARGS into that specification, and return the substituted
12546 specification. If there is no specification, return NULL_TREE. */
12549 tsubst_exception_specification (tree fntype
,
12551 tsubst_flags_t complain
,
12558 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
12559 new_specs
= NULL_TREE
;
12560 if (specs
&& TREE_PURPOSE (specs
))
12562 /* A noexcept-specifier. */
12563 tree expr
= TREE_PURPOSE (specs
);
12564 if (TREE_CODE (expr
) == INTEGER_CST
)
12568 /* Defer instantiation of noexcept-specifiers to avoid
12569 excessive instantiations (c++/49107). */
12570 new_specs
= make_node (DEFERRED_NOEXCEPT
);
12571 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
12573 /* We already partially instantiated this member template,
12574 so combine the new args with the old. */
12575 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
12576 = DEFERRED_NOEXCEPT_PATTERN (expr
);
12577 DEFERRED_NOEXCEPT_ARGS (new_specs
)
12578 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
12582 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
12583 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
12587 new_specs
= tsubst_copy_and_build
12588 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
12589 /*integral_constant_expression_p=*/true);
12590 new_specs
= build_noexcept_spec (new_specs
, complain
);
12594 if (! TREE_VALUE (specs
))
12601 tree expanded_specs
= NULL_TREE
;
12603 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
12605 /* Expand the pack expansion type. */
12606 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
12610 if (expanded_specs
== error_mark_node
)
12611 return error_mark_node
;
12612 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
12613 len
= TREE_VEC_LENGTH (expanded_specs
);
12616 /* We're substituting into a member template, so
12617 we got a TYPE_PACK_EXPANSION back. Add that
12618 expansion and move on. */
12619 gcc_assert (TREE_CODE (expanded_specs
)
12620 == TYPE_PACK_EXPANSION
);
12621 new_specs
= add_exception_specifier (new_specs
,
12624 specs
= TREE_CHAIN (specs
);
12629 for (i
= 0; i
< len
; ++i
)
12631 if (expanded_specs
)
12632 spec
= TREE_VEC_ELT (expanded_specs
, i
);
12634 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
12635 if (spec
== error_mark_node
)
12637 new_specs
= add_exception_specifier (new_specs
, spec
,
12641 specs
= TREE_CHAIN (specs
);
12647 /* Take the tree structure T and replace template parameters used
12648 therein with the argument vector ARGS. IN_DECL is an associated
12649 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
12650 Issue error and warning messages under control of COMPLAIN. Note
12651 that we must be relatively non-tolerant of extensions here, in
12652 order to preserve conformance; if we allow substitutions that
12653 should not be allowed, we may allow argument deductions that should
12654 not succeed, and therefore report ambiguous overload situations
12655 where there are none. In theory, we could allow the substitution,
12656 but indicate that it should have failed, and allow our caller to
12657 make sure that the right thing happens, but we don't try to do this
12660 This function is used for dealing with types, decls and the like;
12661 for expressions, use tsubst_expr or tsubst_copy. */
12664 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12666 enum tree_code code
;
12667 tree type
, r
= NULL_TREE
;
12669 if (t
== NULL_TREE
|| t
== error_mark_node
12670 || t
== integer_type_node
12671 || t
== void_type_node
12672 || t
== char_type_node
12673 || t
== unknown_type_node
12674 || TREE_CODE (t
) == NAMESPACE_DECL
12675 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
12679 return tsubst_decl (t
, args
, complain
);
12681 if (args
== NULL_TREE
)
12684 code
= TREE_CODE (t
);
12686 if (code
== IDENTIFIER_NODE
)
12687 type
= IDENTIFIER_TYPE_VALUE (t
);
12689 type
= TREE_TYPE (t
);
12691 gcc_assert (type
!= unknown_type_node
);
12693 /* Reuse typedefs. We need to do this to handle dependent attributes,
12694 such as attribute aligned. */
12696 && typedef_variant_p (t
))
12698 tree decl
= TYPE_NAME (t
);
12700 if (alias_template_specialization_p (t
))
12702 /* DECL represents an alias template and we want to
12704 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
12705 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
12706 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
12708 else if (DECL_CLASS_SCOPE_P (decl
)
12709 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
12710 && uses_template_parms (DECL_CONTEXT (decl
)))
12712 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
12713 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
12714 r
= retrieve_specialization (tmpl
, gen_args
, 0);
12716 else if (DECL_FUNCTION_SCOPE_P (decl
)
12717 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
12718 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
12719 r
= retrieve_local_specialization (decl
);
12721 /* The typedef is from a non-template context. */
12727 r
= cp_build_qualified_type_real
12728 (r
, cp_type_quals (t
) | cp_type_quals (r
),
12729 complain
| tf_ignore_bad_quals
);
12734 /* We don't have an instantiation yet, so drop the typedef. */
12735 int quals
= cp_type_quals (t
);
12736 t
= DECL_ORIGINAL_TYPE (decl
);
12737 t
= cp_build_qualified_type_real (t
, quals
,
12738 complain
| tf_ignore_bad_quals
);
12743 && code
!= TYPENAME_TYPE
12744 && code
!= TEMPLATE_TYPE_PARM
12745 && code
!= IDENTIFIER_NODE
12746 && code
!= FUNCTION_TYPE
12747 && code
!= METHOD_TYPE
)
12748 type
= tsubst (type
, args
, complain
, in_decl
);
12749 if (type
== error_mark_node
)
12750 return error_mark_node
;
12756 case ENUMERAL_TYPE
:
12757 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
12758 /*entering_scope=*/0);
12761 case IDENTIFIER_NODE
:
12772 if (t
== integer_type_node
)
12775 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
)
12777 if (!TYPE_MAX_VALUE (t
))
12778 return compute_array_index_type (NULL_TREE
, NULL_TREE
, complain
);
12780 if (TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
12785 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
12787 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
12788 /*integral_constant_expression_p=*/false);
12790 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
12792 if (TREE_CODE (max
) == NOP_EXPR
12793 && TREE_SIDE_EFFECTS (omax
)
12794 && !TREE_TYPE (max
))
12795 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
12797 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
12798 with TREE_SIDE_EFFECTS that indicates this is not an integral
12799 constant expression. */
12800 if (processing_template_decl
12801 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
12803 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
12804 TREE_SIDE_EFFECTS (max
) = 1;
12807 return compute_array_index_type (NULL_TREE
, max
, complain
);
12810 case TEMPLATE_TYPE_PARM
:
12811 case TEMPLATE_TEMPLATE_PARM
:
12812 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12813 case TEMPLATE_PARM_INDEX
:
12818 tree arg
= NULL_TREE
;
12820 /* Early in template argument deduction substitution, we don't
12821 want to reduce the level of 'auto', or it will be confused
12822 with a normal template parm in subsequent deduction. */
12823 if (is_auto (t
) && (complain
& tf_partial
))
12828 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
12829 template_parm_level_and_index (t
, &level
, &idx
);
12831 levels
= TMPL_ARGS_DEPTH (args
);
12832 if (level
<= levels
12833 && TREE_VEC_LENGTH (TMPL_ARGS_LEVEL (args
, level
)) > 0)
12835 arg
= TMPL_ARG (args
, level
, idx
);
12837 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
12839 /* See through ARGUMENT_PACK_SELECT arguments. */
12840 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
12841 /* If the selected argument is an expansion E, that most
12842 likely means we were called from
12843 gen_elem_of_pack_expansion_instantiation during the
12844 substituting of pack an argument pack (which Ith
12845 element is a pack expansion, where I is
12846 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
12847 In this case, the Ith element resulting from this
12848 substituting is going to be a pack expansion, which
12849 pattern is the pattern of E. Let's return the
12851 gen_elem_of_pack_expansion_instantiation will
12852 build the resulting pack expansion from it. */
12853 if (PACK_EXPANSION_P (arg
))
12855 /* Make sure we aren't throwing away arg info. */
12856 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
12857 arg
= PACK_EXPANSION_PATTERN (arg
);
12862 if (arg
== error_mark_node
)
12863 return error_mark_node
;
12864 else if (arg
!= NULL_TREE
)
12866 if (ARGUMENT_PACK_P (arg
))
12867 /* If ARG is an argument pack, we don't actually want to
12868 perform a substitution here, because substitutions
12869 for argument packs are only done
12870 element-by-element. We can get to this point when
12871 substituting the type of a non-type template
12872 parameter pack, when that type actually contains
12873 template parameter packs from an outer template, e.g.,
12875 template<typename... Types> struct A {
12876 template<Types... Values> struct B { };
12880 if (code
== TEMPLATE_TYPE_PARM
)
12883 gcc_assert (TYPE_P (arg
));
12885 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
12887 return cp_build_qualified_type_real
12888 (arg
, quals
, complain
| tf_ignore_bad_quals
);
12890 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
12892 /* We are processing a type constructed from a
12893 template template parameter. */
12894 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
12895 args
, complain
, in_decl
);
12896 if (argvec
== error_mark_node
)
12897 return error_mark_node
;
12899 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
12900 || TREE_CODE (arg
) == TEMPLATE_DECL
12901 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
12903 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
12904 /* Consider this code:
12906 template <template <class> class Template>
12908 template <class Arg> using Bind = Template<Arg>;
12911 template <template <class> class Template, class Arg>
12912 using Instantiate = Template<Arg>; //#0
12914 template <template <class> class Template,
12917 Instantiate<Internal<Template>::template Bind,
12920 When #1 is parsed, the
12921 BOUND_TEMPLATE_TEMPLATE_PARM representing the
12922 parameter `Template' in #0 matches the
12923 UNBOUND_CLASS_TEMPLATE representing the argument
12924 `Internal<Template>::template Bind'; We then want
12925 to assemble the type `Bind<Argument>' that can't
12926 be fully created right now, because
12927 `Internal<Template>' not being complete, the Bind
12928 template cannot be looked up in that context. So
12929 we need to "store" `Bind<Argument>' for later
12930 when the context of Bind becomes complete. Let's
12931 store that in a TYPENAME_TYPE. */
12932 return make_typename_type (TYPE_CONTEXT (arg
),
12933 build_nt (TEMPLATE_ID_EXPR
,
12934 TYPE_IDENTIFIER (arg
),
12939 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
12940 are resolving nested-types in the signature of a
12941 member function templates. Otherwise ARG is a
12942 TEMPLATE_DECL and is the real template to be
12944 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
12945 arg
= TYPE_NAME (arg
);
12947 r
= lookup_template_class (arg
,
12949 DECL_CONTEXT (arg
),
12950 /*entering_scope=*/0,
12952 return cp_build_qualified_type_real
12953 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
12956 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
12957 return convert_from_reference (unshare_expr (arg
));
12961 /* This can happen during the attempted tsubst'ing in
12962 unify. This means that we don't yet have any information
12963 about the template parameter in question. */
12966 /* If we get here, we must have been looking at a parm for a
12967 more deeply nested template. Make a new version of this
12968 template parameter, but with a lower level. */
12971 case TEMPLATE_TYPE_PARM
:
12972 case TEMPLATE_TEMPLATE_PARM
:
12973 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12974 if (cp_type_quals (t
))
12976 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
12977 r
= cp_build_qualified_type_real
12978 (r
, cp_type_quals (t
),
12979 complain
| (code
== TEMPLATE_TYPE_PARM
12980 ? tf_ignore_bad_quals
: 0));
12982 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
12983 && PLACEHOLDER_TYPE_CONSTRAINTS (t
)
12984 && (r
= (TEMPLATE_PARM_DESCENDANTS
12985 (TEMPLATE_TYPE_PARM_INDEX (t
))))
12986 && (r
= TREE_TYPE (r
))
12987 && !PLACEHOLDER_TYPE_CONSTRAINTS (r
))
12988 /* Break infinite recursion when substituting the constraints
12989 of a constrained placeholder. */;
12993 TEMPLATE_TYPE_PARM_INDEX (r
)
12994 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
12995 r
, levels
, args
, complain
);
12996 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
12997 TYPE_MAIN_VARIANT (r
) = r
;
12998 TYPE_POINTER_TO (r
) = NULL_TREE
;
12999 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
13001 /* Propagate constraints on placeholders. */
13002 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
13003 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
13004 PLACEHOLDER_TYPE_CONSTRAINTS (r
)
13005 = tsubst_constraint (constr
, args
, complain
, in_decl
);
13007 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
13008 /* We have reduced the level of the template
13009 template parameter, but not the levels of its
13010 template parameters, so canonical_type_parameter
13011 will not be able to find the canonical template
13012 template parameter for this level. Thus, we
13013 require structural equality checking to compare
13014 TEMPLATE_TEMPLATE_PARMs. */
13015 SET_TYPE_STRUCTURAL_EQUALITY (r
);
13016 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
13017 SET_TYPE_STRUCTURAL_EQUALITY (r
);
13019 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
13021 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
13023 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
13024 complain
, in_decl
);
13025 if (argvec
== error_mark_node
)
13026 return error_mark_node
;
13028 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
13029 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
13034 case TEMPLATE_PARM_INDEX
:
13035 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
13039 gcc_unreachable ();
13047 tree purpose
, value
, chain
;
13049 if (t
== void_list_node
)
13052 purpose
= TREE_PURPOSE (t
);
13055 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
13056 if (purpose
== error_mark_node
)
13057 return error_mark_node
;
13059 value
= TREE_VALUE (t
);
13062 value
= tsubst (value
, args
, complain
, in_decl
);
13063 if (value
== error_mark_node
)
13064 return error_mark_node
;
13066 chain
= TREE_CHAIN (t
);
13067 if (chain
&& chain
!= void_type_node
)
13069 chain
= tsubst (chain
, args
, complain
, in_decl
);
13070 if (chain
== error_mark_node
)
13071 return error_mark_node
;
13073 if (purpose
== TREE_PURPOSE (t
)
13074 && value
== TREE_VALUE (t
)
13075 && chain
== TREE_CHAIN (t
))
13077 return hash_tree_cons (purpose
, value
, chain
);
13081 /* We should never be tsubsting a binfo. */
13082 gcc_unreachable ();
13085 /* A vector of template arguments. */
13086 gcc_assert (!type
);
13087 return tsubst_template_args (t
, args
, complain
, in_decl
);
13090 case REFERENCE_TYPE
:
13092 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
13097 Type deduction may fail for any of the following
13100 -- Attempting to create a pointer to reference type.
13101 -- Attempting to create a reference to a reference type or
13102 a reference to void.
13104 Core issue 106 says that creating a reference to a reference
13105 during instantiation is no longer a cause for failure. We
13106 only enforce this check in strict C++98 mode. */
13107 if ((TREE_CODE (type
) == REFERENCE_TYPE
13108 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
13109 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
13111 static location_t last_loc
;
13113 /* We keep track of the last time we issued this error
13114 message to avoid spewing a ton of messages during a
13115 single bad template instantiation. */
13116 if (complain
& tf_error
13117 && last_loc
!= input_location
)
13119 if (VOID_TYPE_P (type
))
13120 error ("forming reference to void");
13121 else if (code
== POINTER_TYPE
)
13122 error ("forming pointer to reference type %qT", type
);
13124 error ("forming reference to reference type %qT", type
);
13125 last_loc
= input_location
;
13128 return error_mark_node
;
13130 else if (TREE_CODE (type
) == FUNCTION_TYPE
13131 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
13132 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
13134 if (complain
& tf_error
)
13136 if (code
== POINTER_TYPE
)
13137 error ("forming pointer to qualified function type %qT",
13140 error ("forming reference to qualified function type %qT",
13143 return error_mark_node
;
13145 else if (code
== POINTER_TYPE
)
13147 r
= build_pointer_type (type
);
13148 if (TREE_CODE (type
) == METHOD_TYPE
)
13149 r
= build_ptrmemfunc_type (r
);
13151 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
13152 /* In C++0x, during template argument substitution, when there is an
13153 attempt to create a reference to a reference type, reference
13154 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
13156 "If a template-argument for a template-parameter T names a type
13157 that is a reference to a type A, an attempt to create the type
13158 'lvalue reference to cv T' creates the type 'lvalue reference to
13159 A,' while an attempt to create the type type rvalue reference to
13160 cv T' creates the type T"
13162 r
= cp_build_reference_type
13164 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
13166 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
13167 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
13169 if (r
!= error_mark_node
)
13170 /* Will this ever be needed for TYPE_..._TO values? */
13177 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
13178 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
13182 Type deduction may fail for any of the following
13185 -- Attempting to create "pointer to member of T" when T
13186 is not a class type. */
13187 if (complain
& tf_error
)
13188 error ("creating pointer to member of non-class type %qT", r
);
13189 return error_mark_node
;
13191 if (TREE_CODE (type
) == REFERENCE_TYPE
)
13193 if (complain
& tf_error
)
13194 error ("creating pointer to member reference type %qT", type
);
13195 return error_mark_node
;
13197 if (VOID_TYPE_P (type
))
13199 if (complain
& tf_error
)
13200 error ("creating pointer to member of type void");
13201 return error_mark_node
;
13203 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
13204 if (TREE_CODE (type
) == FUNCTION_TYPE
)
13206 /* The type of the implicit object parameter gets its
13207 cv-qualifiers from the FUNCTION_TYPE. */
13210 = build_memfn_type (type
, r
, type_memfn_quals (type
),
13211 type_memfn_rqual (type
));
13212 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
13213 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
13217 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
13221 case FUNCTION_TYPE
:
13226 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
13227 if (fntype
== error_mark_node
)
13228 return error_mark_node
;
13230 /* Substitute the exception specification. */
13231 specs
= tsubst_exception_specification (t
, args
, complain
,
13232 in_decl
, /*defer_ok*/true);
13233 if (specs
== error_mark_node
)
13234 return error_mark_node
;
13236 fntype
= build_exception_variant (fntype
, specs
);
13241 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
13242 if (domain
== error_mark_node
)
13243 return error_mark_node
;
13245 /* As an optimization, we avoid regenerating the array type if
13246 it will obviously be the same as T. */
13247 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
13250 /* These checks should match the ones in create_array_type_for_decl.
13254 The deduction may fail for any of the following reasons:
13256 -- Attempting to create an array with an element type that
13257 is void, a function type, or a reference type, or [DR337]
13258 an abstract class type. */
13259 if (VOID_TYPE_P (type
)
13260 || TREE_CODE (type
) == FUNCTION_TYPE
13261 || (TREE_CODE (type
) == ARRAY_TYPE
13262 && TYPE_DOMAIN (type
) == NULL_TREE
)
13263 || TREE_CODE (type
) == REFERENCE_TYPE
)
13265 if (complain
& tf_error
)
13266 error ("creating array of %qT", type
);
13267 return error_mark_node
;
13270 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
13271 return error_mark_node
;
13273 r
= build_cplus_array_type (type
, domain
);
13275 if (TYPE_USER_ALIGN (t
))
13277 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
13278 TYPE_USER_ALIGN (r
) = 1;
13284 case TYPENAME_TYPE
:
13286 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
13287 in_decl
, /*entering_scope=*/1);
13288 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
13289 complain
, in_decl
);
13291 if (ctx
== error_mark_node
|| f
== error_mark_node
)
13292 return error_mark_node
;
13294 if (!MAYBE_CLASS_TYPE_P (ctx
))
13296 if (complain
& tf_error
)
13297 error ("%qT is not a class, struct, or union type", ctx
);
13298 return error_mark_node
;
13300 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
13302 /* Normally, make_typename_type does not require that the CTX
13303 have complete type in order to allow things like:
13305 template <class T> struct S { typename S<T>::X Y; };
13307 But, such constructs have already been resolved by this
13308 point, so here CTX really should have complete type, unless
13309 it's a partial instantiation. */
13310 ctx
= complete_type (ctx
);
13311 if (!COMPLETE_TYPE_P (ctx
))
13313 if (complain
& tf_error
)
13314 cxx_incomplete_type_error (NULL_TREE
, ctx
);
13315 return error_mark_node
;
13319 f
= make_typename_type (ctx
, f
, typename_type
,
13320 complain
| tf_keep_type_decl
);
13321 if (f
== error_mark_node
)
13323 if (TREE_CODE (f
) == TYPE_DECL
)
13325 complain
|= tf_ignore_bad_quals
;
13329 if (TREE_CODE (f
) != TYPENAME_TYPE
)
13331 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
13333 if (complain
& tf_error
)
13334 error ("%qT resolves to %qT, which is not an enumeration type",
13337 return error_mark_node
;
13339 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
13341 if (complain
& tf_error
)
13342 error ("%qT resolves to %qT, which is is not a class type",
13345 return error_mark_node
;
13349 return cp_build_qualified_type_real
13350 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
13353 case UNBOUND_CLASS_TEMPLATE
:
13355 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
13356 in_decl
, /*entering_scope=*/1);
13357 tree name
= TYPE_IDENTIFIER (t
);
13358 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
13360 if (ctx
== error_mark_node
|| name
== error_mark_node
)
13361 return error_mark_node
;
13364 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
13365 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
13372 ++cp_unevaluated_operand
;
13373 ++c_inhibit_evaluation_warnings
;
13375 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
13377 /*integral_constant_expression_p=*/false);
13379 --cp_unevaluated_operand
;
13380 --c_inhibit_evaluation_warnings
;
13382 type
= finish_typeof (type
);
13383 return cp_build_qualified_type_real (type
,
13385 | cp_type_quals (type
),
13389 case DECLTYPE_TYPE
:
13393 ++cp_unevaluated_operand
;
13394 ++c_inhibit_evaluation_warnings
;
13396 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
13397 complain
|tf_decltype
, in_decl
,
13398 /*function_p*/false,
13399 /*integral_constant_expression*/false);
13401 --cp_unevaluated_operand
;
13402 --c_inhibit_evaluation_warnings
;
13404 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
13405 type
= lambda_capture_field_type (type
,
13406 DECLTYPE_FOR_INIT_CAPTURE (t
));
13407 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
13408 type
= lambda_proxy_type (type
);
13411 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
13412 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
13414 /* In a template ~id could be either a complement expression
13415 or an unqualified-id naming a destructor; if instantiating
13416 it produces an expression, it's not an id-expression or
13419 type
= finish_decltype_type (type
, id
, complain
);
13421 return cp_build_qualified_type_real (type
,
13423 | cp_type_quals (type
),
13424 complain
| tf_ignore_bad_quals
);
13427 case UNDERLYING_TYPE
:
13429 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
13430 complain
, in_decl
);
13431 return finish_underlying_type (type
);
13434 case TYPE_ARGUMENT_PACK
:
13435 case NONTYPE_ARGUMENT_PACK
:
13437 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
13439 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
13443 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
13445 /* For template nontype argument packs, also substitute into
13447 if (code
== NONTYPE_ARGUMENT_PACK
)
13448 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13467 /* We should use one of the expression tsubsts for these codes. */
13468 gcc_unreachable ();
13471 sorry ("use of %qs in template", get_tree_code_name (code
));
13472 return error_mark_node
;
13476 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
13477 type of the expression on the left-hand side of the "." or "->"
13481 tsubst_baselink (tree baselink
, tree object_type
,
13482 tree args
, tsubst_flags_t complain
, tree in_decl
)
13485 tree qualifying_scope
;
13488 tree template_args
= 0;
13489 bool template_id_p
= false;
13490 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
13492 /* A baselink indicates a function from a base class. Both the
13493 BASELINK_ACCESS_BINFO and the base class referenced may
13494 indicate bases of the template class, rather than the
13495 instantiated class. In addition, lookups that were not
13496 ambiguous before may be ambiguous now. Therefore, we perform
13497 the lookup again. */
13498 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
13499 qualifying_scope
= tsubst (qualifying_scope
, args
,
13500 complain
, in_decl
);
13501 fns
= BASELINK_FUNCTIONS (baselink
);
13502 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
13503 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
13505 template_id_p
= true;
13506 template_args
= TREE_OPERAND (fns
, 1);
13507 fns
= TREE_OPERAND (fns
, 0);
13509 template_args
= tsubst_template_args (template_args
, args
,
13510 complain
, in_decl
);
13512 name
= DECL_NAME (get_first_fn (fns
));
13513 if (IDENTIFIER_TYPENAME_P (name
))
13514 name
= mangle_conv_op_name_for_type (optype
);
13515 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
13517 return error_mark_node
;
13519 /* If lookup found a single function, mark it as used at this
13520 point. (If it lookup found multiple functions the one selected
13521 later by overload resolution will be marked as used at that
13523 if (BASELINK_P (baselink
))
13524 fns
= BASELINK_FUNCTIONS (baselink
);
13525 if (!template_id_p
&& !really_overloaded_fn (fns
)
13526 && !mark_used (OVL_CURRENT (fns
), complain
) && !(complain
& tf_error
))
13527 return error_mark_node
;
13529 /* Add back the template arguments, if present. */
13530 if (BASELINK_P (baselink
) && template_id_p
)
13531 BASELINK_FUNCTIONS (baselink
)
13532 = build_nt (TEMPLATE_ID_EXPR
,
13533 BASELINK_FUNCTIONS (baselink
),
13535 /* Update the conversion operator type. */
13536 BASELINK_OPTYPE (baselink
) = optype
;
13539 object_type
= current_class_type
;
13542 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
13548 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
13549 true if the qualified-id will be a postfix-expression in-and-of
13550 itself; false if more of the postfix-expression follows the
13551 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
13555 tsubst_qualified_id (tree qualified_id
, tree args
,
13556 tsubst_flags_t complain
, tree in_decl
,
13557 bool done
, bool address_p
)
13563 tree template_args
;
13564 location_t loc
= UNKNOWN_LOCATION
;
13566 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
13568 /* Figure out what name to look up. */
13569 name
= TREE_OPERAND (qualified_id
, 1);
13570 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
13572 is_template
= true;
13573 loc
= EXPR_LOCATION (name
);
13574 template_args
= TREE_OPERAND (name
, 1);
13576 template_args
= tsubst_template_args (template_args
, args
,
13577 complain
, in_decl
);
13578 name
= TREE_OPERAND (name
, 0);
13582 is_template
= false;
13583 template_args
= NULL_TREE
;
13586 /* Substitute into the qualifying scope. When there are no ARGS, we
13587 are just trying to simplify a non-dependent expression. In that
13588 case the qualifying scope may be dependent, and, in any case,
13589 substituting will not help. */
13590 scope
= TREE_OPERAND (qualified_id
, 0);
13593 scope
= tsubst (scope
, args
, complain
, in_decl
);
13594 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
13599 if (dependent_scope_p (scope
))
13602 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
13603 return build_qualified_name (NULL_TREE
, scope
, expr
,
13604 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
13607 if (!BASELINK_P (name
) && !DECL_P (expr
))
13609 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
13611 /* A BIT_NOT_EXPR is used to represent a destructor. */
13612 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
13614 error ("qualifying type %qT does not match destructor name ~%qT",
13615 scope
, TREE_OPERAND (expr
, 0));
13616 expr
= error_mark_node
;
13619 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
13620 /*is_type_p=*/0, false);
13623 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
13624 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
13625 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
13627 if (complain
& tf_error
)
13629 error ("dependent-name %qE is parsed as a non-type, but "
13630 "instantiation yields a type", qualified_id
);
13631 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
13633 return error_mark_node
;
13639 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
13641 /* Remember that there was a reference to this entity. */
13642 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
13643 return error_mark_node
;
13646 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
13648 if (complain
& tf_error
)
13649 qualified_name_lookup_error (scope
,
13650 TREE_OPERAND (qualified_id
, 1),
13651 expr
, input_location
);
13652 return error_mark_node
;
13656 expr
= lookup_template_function (expr
, template_args
);
13658 if (expr
== error_mark_node
&& complain
& tf_error
)
13659 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
13660 expr
, input_location
);
13661 else if (TYPE_P (scope
))
13663 expr
= (adjust_result_of_qualified_name_lookup
13664 (expr
, scope
, current_nonlambda_class_type ()));
13665 expr
= (finish_qualified_id_expr
13666 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
13667 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
13668 /*template_arg_p=*/false, complain
));
13671 /* Expressions do not generally have reference type. */
13672 if (TREE_CODE (expr
) != SCOPE_REF
13673 /* However, if we're about to form a pointer-to-member, we just
13674 want the referenced member referenced. */
13675 && TREE_CODE (expr
) != OFFSET_REF
)
13676 expr
= convert_from_reference (expr
);
13681 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
13682 initializer, DECL is the substituted VAR_DECL. Other arguments are as
13686 tsubst_init (tree init
, tree decl
, tree args
,
13687 tsubst_flags_t complain
, tree in_decl
)
13692 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
13696 /* If we had an initializer but it
13697 instantiated to nothing,
13698 value-initialize the object. This will
13699 only occur when the initializer was a
13700 pack expansion where the parameter packs
13701 used in that expansion were of length
13703 init
= build_value_init (TREE_TYPE (decl
),
13705 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
13706 init
= get_target_expr_sfinae (init
, complain
);
13712 /* Like tsubst, but deals with expressions. This function just replaces
13713 template parms; to finish processing the resultant expression, use
13714 tsubst_copy_and_build or tsubst_expr. */
13717 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
13719 enum tree_code code
;
13722 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
13725 code
= TREE_CODE (t
);
13730 r
= retrieve_local_specialization (t
);
13732 if (r
== NULL_TREE
)
13734 /* We get here for a use of 'this' in an NSDMI. */
13735 if (DECL_NAME (t
) == this_identifier
13736 && current_function_decl
13737 && DECL_CONSTRUCTOR_P (current_function_decl
))
13738 return current_class_ptr
;
13740 /* This can happen for a parameter name used later in a function
13741 declaration (such as in a late-specified return type). Just
13742 make a dummy decl, since it's only used for its type. */
13743 gcc_assert (cp_unevaluated_operand
!= 0);
13744 r
= tsubst_decl (t
, args
, complain
);
13745 /* Give it the template pattern as its context; its true context
13746 hasn't been instantiated yet and this is good enough for
13748 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
13751 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
13752 r
= ARGUMENT_PACK_SELECT_ARG (r
);
13753 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
13754 return error_mark_node
;
13762 if (DECL_TEMPLATE_PARM_P (t
))
13763 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
13764 /* There is no need to substitute into namespace-scope
13766 if (DECL_NAMESPACE_SCOPE_P (t
))
13768 /* If ARGS is NULL, then T is known to be non-dependent. */
13769 if (args
== NULL_TREE
)
13770 return scalar_constant_value (t
);
13772 /* Unfortunately, we cannot just call lookup_name here.
13775 template <int I> int f() {
13777 struct S { void g() { E e = a; } };
13780 When we instantiate f<7>::S::g(), say, lookup_name is not
13781 clever enough to find f<7>::a. */
13783 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
13784 /*entering_scope=*/0);
13786 for (v
= TYPE_VALUES (enum_type
);
13788 v
= TREE_CHAIN (v
))
13789 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
13790 return TREE_VALUE (v
);
13792 /* We didn't find the name. That should never happen; if
13793 name-lookup found it during preliminary parsing, we
13794 should find it again here during instantiation. */
13795 gcc_unreachable ();
13800 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
13802 /* Check for a local specialization set up by
13803 tsubst_pack_expansion. */
13804 if (tree r
= retrieve_local_specialization (t
))
13806 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
13807 r
= ARGUMENT_PACK_SELECT_ARG (r
);
13811 /* When retrieving a capture pack from a generic lambda, remove the
13812 lambda call op's own template argument list from ARGS. Only the
13813 template arguments active for the closure type should be used to
13814 retrieve the pack specialization. */
13815 if (LAMBDA_FUNCTION_P (current_function_decl
)
13816 && (template_class_depth (DECL_CONTEXT (t
))
13817 != TMPL_ARGS_DEPTH (args
)))
13818 args
= strip_innermost_template_args (args
, 1);
13820 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
13821 tsubst_decl put in the hash table. */
13822 return retrieve_specialization (t
, args
, 0);
13825 if (DECL_CONTEXT (t
))
13829 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
13830 /*entering_scope=*/1);
13831 if (ctx
!= DECL_CONTEXT (t
))
13833 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
13836 if (complain
& tf_error
)
13837 error ("using invalid field %qD", t
);
13838 return error_mark_node
;
13847 case FUNCTION_DECL
:
13848 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
13849 r
= tsubst (t
, args
, complain
, in_decl
);
13850 else if (local_variable_p (t
))
13852 r
= retrieve_local_specialization (t
);
13853 if (r
== NULL_TREE
)
13855 /* First try name lookup to find the instantiation. */
13856 r
= lookup_name (DECL_NAME (t
));
13859 /* Make sure that the one we found is the one we want. */
13860 tree ctx
= DECL_CONTEXT (t
);
13861 if (DECL_LANG_SPECIFIC (ctx
) && DECL_TEMPLATE_INFO (ctx
))
13862 ctx
= tsubst (ctx
, args
, complain
, in_decl
);
13863 if (ctx
!= DECL_CONTEXT (r
))
13871 /* This can happen for a variable used in a
13872 late-specified return type of a local lambda, or for a
13873 local static or constant. Building a new VAR_DECL
13874 should be OK in all those cases. */
13875 r
= tsubst_decl (t
, args
, complain
);
13876 if (decl_maybe_constant_var_p (r
))
13878 /* We can't call cp_finish_decl, so handle the
13879 initializer by hand. */
13880 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
13881 complain
, in_decl
);
13882 if (!processing_template_decl
)
13883 init
= maybe_constant_init (init
);
13884 if (processing_template_decl
13885 ? potential_constant_expression (init
)
13886 : reduced_constant_expression_p (init
))
13887 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
13888 = TREE_CONSTANT (r
) = true;
13889 DECL_INITIAL (r
) = init
;
13891 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
13892 || decl_constant_var_p (r
)
13893 || errorcount
|| sorrycount
);
13894 if (!processing_template_decl
)
13896 if (TREE_STATIC (r
))
13897 rest_of_decl_compilation (r
, toplevel_bindings_p (),
13900 r
= process_outer_var_ref (r
, complain
);
13903 /* Remember this for subsequent uses. */
13904 if (local_specializations
)
13905 register_local_specialization (r
, t
);
13910 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
13911 return error_mark_node
;
13914 case NAMESPACE_DECL
:
13918 /* An OVERLOAD will always be a non-dependent overload set; an
13919 overload set from function scope will just be represented with an
13920 IDENTIFIER_NODE, and from class scope with a BASELINK. */
13921 gcc_assert (!uses_template_parms (t
));
13925 return tsubst_baselink (t
, current_nonlambda_class_type (),
13926 args
, complain
, in_decl
);
13928 case TEMPLATE_DECL
:
13929 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
13930 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
13931 args
, complain
, in_decl
);
13932 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
13933 return tsubst (t
, args
, complain
, in_decl
);
13934 else if (DECL_CLASS_SCOPE_P (t
)
13935 && uses_template_parms (DECL_CONTEXT (t
)))
13937 /* Template template argument like the following example need
13940 template <template <class> class TT> struct C {};
13941 template <class T> struct D {
13942 template <class U> struct E {};
13947 We are processing the template argument `E' in #1 for
13948 the template instantiation #2. Originally, `E' is a
13949 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
13950 have to substitute this with one having context `D<int>'. */
13952 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
13953 return lookup_field (context
, DECL_NAME(t
), 0, false);
13956 /* Ordinary template template argument. */
13960 case REINTERPRET_CAST_EXPR
:
13961 case CONST_CAST_EXPR
:
13962 case STATIC_CAST_EXPR
:
13963 case DYNAMIC_CAST_EXPR
:
13964 case IMPLICIT_CONV_EXPR
:
13968 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13969 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13970 return build1 (code
, type
, op0
);
13974 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
13976 tree expanded
, op
= TREE_OPERAND (t
, 0);
13979 if (SIZEOF_EXPR_TYPE_P (t
))
13980 op
= TREE_TYPE (op
);
13982 ++cp_unevaluated_operand
;
13983 ++c_inhibit_evaluation_warnings
;
13984 /* We only want to compute the number of arguments. */
13985 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
13986 --cp_unevaluated_operand
;
13987 --c_inhibit_evaluation_warnings
;
13989 if (TREE_CODE (expanded
) == TREE_VEC
)
13990 len
= TREE_VEC_LENGTH (expanded
);
13992 if (expanded
== error_mark_node
)
13993 return error_mark_node
;
13994 else if (PACK_EXPANSION_P (expanded
)
13995 || (TREE_CODE (expanded
) == TREE_VEC
13997 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
13999 if (TREE_CODE (expanded
) == TREE_VEC
)
14000 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
14002 PACK_EXPANSION_SIZEOF_P (expanded
) = true;
14004 if (TYPE_P (expanded
))
14005 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
14006 complain
& tf_error
);
14008 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
14009 complain
& tf_error
);
14012 return build_int_cst (size_type_node
, len
);
14014 if (SIZEOF_EXPR_TYPE_P (t
))
14016 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
14017 args
, complain
, in_decl
);
14018 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
14019 r
= build1 (SIZEOF_EXPR
,
14020 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
14021 SIZEOF_EXPR_TYPE_P (r
) = 1;
14028 case TRUTH_NOT_EXPR
:
14031 case UNARY_PLUS_EXPR
: /* Unary + */
14033 case AT_ENCODE_EXPR
:
14037 case REALPART_EXPR
:
14038 case IMAGPART_EXPR
:
14041 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14042 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14043 return build1 (code
, type
, op0
);
14046 case COMPONENT_REF
:
14051 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14052 name
= TREE_OPERAND (t
, 1);
14053 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
14055 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
14056 complain
, in_decl
);
14057 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
14059 else if (TREE_CODE (name
) == SCOPE_REF
14060 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
14062 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
14063 complain
, in_decl
);
14064 name
= TREE_OPERAND (name
, 1);
14065 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
14066 complain
, in_decl
);
14067 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
14068 name
= build_qualified_name (/*type=*/NULL_TREE
,
14070 /*template_p=*/false);
14072 else if (BASELINK_P (name
))
14073 name
= tsubst_baselink (name
,
14074 non_reference (TREE_TYPE (object
)),
14078 name
= tsubst_copy (name
, args
, complain
, in_decl
);
14079 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
14085 case TRUNC_DIV_EXPR
:
14086 case CEIL_DIV_EXPR
:
14087 case FLOOR_DIV_EXPR
:
14088 case ROUND_DIV_EXPR
:
14089 case EXACT_DIV_EXPR
:
14093 case TRUNC_MOD_EXPR
:
14094 case FLOOR_MOD_EXPR
:
14095 case TRUTH_ANDIF_EXPR
:
14096 case TRUTH_ORIF_EXPR
:
14097 case TRUTH_AND_EXPR
:
14098 case TRUTH_OR_EXPR
:
14111 case COMPOUND_EXPR
:
14114 case PREDECREMENT_EXPR
:
14115 case PREINCREMENT_EXPR
:
14116 case POSTDECREMENT_EXPR
:
14117 case POSTINCREMENT_EXPR
:
14119 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14120 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14121 return build_nt (code
, op0
, op1
);
14126 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14127 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14128 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
14129 QUALIFIED_NAME_IS_TEMPLATE (t
));
14134 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14135 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14136 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
14141 int n
= VL_EXP_OPERAND_LENGTH (t
);
14142 tree result
= build_vl_exp (CALL_EXPR
, n
);
14144 for (i
= 0; i
< n
; i
++)
14145 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
14146 complain
, in_decl
);
14152 case PSEUDO_DTOR_EXPR
:
14153 case VEC_PERM_EXPR
:
14155 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14156 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14157 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
14158 r
= build_nt (code
, op0
, op1
, op2
);
14159 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14165 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14166 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14167 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
14168 r
= build_nt (code
, op0
, op1
, op2
);
14169 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
14175 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14176 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14177 r
= build_nt (code
, op0
, op1
);
14178 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
14179 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
14183 case TEMPLATE_ID_EXPR
:
14185 /* Substituted template arguments */
14186 tree fn
= TREE_OPERAND (t
, 0);
14187 tree targs
= TREE_OPERAND (t
, 1);
14189 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
14191 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14193 return lookup_template_function (fn
, targs
);
14198 tree purpose
, value
, chain
;
14200 if (t
== void_list_node
)
14203 purpose
= TREE_PURPOSE (t
);
14205 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
14206 value
= TREE_VALUE (t
);
14208 value
= tsubst_copy (value
, args
, complain
, in_decl
);
14209 chain
= TREE_CHAIN (t
);
14210 if (chain
&& chain
!= void_type_node
)
14211 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
14212 if (purpose
== TREE_PURPOSE (t
)
14213 && value
== TREE_VALUE (t
)
14214 && chain
== TREE_CHAIN (t
))
14216 return tree_cons (purpose
, value
, chain
);
14221 case ENUMERAL_TYPE
:
14223 case TEMPLATE_TYPE_PARM
:
14224 case TEMPLATE_TEMPLATE_PARM
:
14225 case BOUND_TEMPLATE_TEMPLATE_PARM
:
14226 case TEMPLATE_PARM_INDEX
:
14228 case REFERENCE_TYPE
:
14230 case FUNCTION_TYPE
:
14233 case TYPENAME_TYPE
:
14234 case UNBOUND_CLASS_TEMPLATE
:
14236 case DECLTYPE_TYPE
:
14238 return tsubst (t
, args
, complain
, in_decl
);
14242 /* Fall through. */
14243 case IDENTIFIER_NODE
:
14244 if (IDENTIFIER_TYPENAME_P (t
))
14246 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14247 return mangle_conv_op_name_for_type (new_type
);
14253 /* This is handled by tsubst_copy_and_build. */
14254 gcc_unreachable ();
14258 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14259 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14260 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
14263 case CLEANUP_POINT_EXPR
:
14264 /* We shouldn't have built any of these during initial template
14265 generation. Instead, they should be built during instantiation
14266 in response to the saved STMT_IS_FULL_EXPR_P setting. */
14267 gcc_unreachable ();
14271 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14272 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14273 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14274 r
= build2 (code
, type
, op0
, op1
);
14275 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
14276 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
14277 && !(complain
& tf_error
))
14278 return error_mark_node
;
14282 case EXPR_PACK_EXPANSION
:
14283 error ("invalid use of pack expansion expression");
14284 return error_mark_node
;
14286 case NONTYPE_ARGUMENT_PACK
:
14287 error ("use %<...%> to expand argument pack");
14288 return error_mark_node
;
14291 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
14299 /* Instantiate any typedefs in the type. */
14300 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14301 r
= fold_convert (type
, t
);
14302 gcc_assert (TREE_CODE (r
) == code
);
14307 /* These can sometimes show up in a partial instantiation, but never
14308 involve template parms. */
14309 gcc_assert (!uses_template_parms (t
));
14312 case UNARY_LEFT_FOLD_EXPR
:
14313 return tsubst_unary_left_fold (t
, args
, complain
, in_decl
);
14314 case UNARY_RIGHT_FOLD_EXPR
:
14315 return tsubst_unary_right_fold (t
, args
, complain
, in_decl
);
14316 case BINARY_LEFT_FOLD_EXPR
:
14317 return tsubst_binary_left_fold (t
, args
, complain
, in_decl
);
14318 case BINARY_RIGHT_FOLD_EXPR
:
14319 return tsubst_binary_right_fold (t
, args
, complain
, in_decl
);
14322 /* We shouldn't get here, but keep going if !flag_checking. */
14324 gcc_unreachable ();
14329 /* Helper function for tsubst_omp_clauses, used for instantiation of
14330 OMP_CLAUSE_DECL of clauses. */
14333 tsubst_omp_clause_decl (tree decl
, tree args
, tsubst_flags_t complain
,
14336 if (decl
== NULL_TREE
)
14339 /* Handle an OpenMP array section represented as a TREE_LIST (or
14340 OMP_CLAUSE_DEPEND_KIND). An OMP_CLAUSE_DEPEND (with a depend
14341 kind of OMP_CLAUSE_DEPEND_SINK) can also be represented as a
14342 TREE_LIST. We can handle it exactly the same as an array section
14343 (purpose, value, and a chain), even though the nomenclature
14344 (low_bound, length, etc) is different. */
14345 if (TREE_CODE (decl
) == TREE_LIST
)
14348 = tsubst_expr (TREE_PURPOSE (decl
), args
, complain
, in_decl
,
14349 /*integral_constant_expression_p=*/false);
14350 tree length
= tsubst_expr (TREE_VALUE (decl
), args
, complain
, in_decl
,
14351 /*integral_constant_expression_p=*/false);
14352 tree chain
= tsubst_omp_clause_decl (TREE_CHAIN (decl
), args
, complain
,
14354 if (TREE_PURPOSE (decl
) == low_bound
14355 && TREE_VALUE (decl
) == length
14356 && TREE_CHAIN (decl
) == chain
)
14358 tree ret
= tree_cons (low_bound
, length
, chain
);
14359 OMP_CLAUSE_DEPEND_SINK_NEGATIVE (ret
)
14360 = OMP_CLAUSE_DEPEND_SINK_NEGATIVE (decl
);
14363 tree ret
= tsubst_expr (decl
, args
, complain
, in_decl
,
14364 /*integral_constant_expression_p=*/false);
14365 /* Undo convert_from_reference tsubst_expr could have called. */
14367 && REFERENCE_REF_P (ret
)
14368 && !REFERENCE_REF_P (decl
))
14369 ret
= TREE_OPERAND (ret
, 0);
14373 /* Like tsubst_copy, but specifically for OpenMP clauses. */
14376 tsubst_omp_clauses (tree clauses
, bool declare_simd
, bool allow_fields
,
14377 tree args
, tsubst_flags_t complain
, tree in_decl
)
14379 tree new_clauses
= NULL_TREE
, nc
, oc
;
14380 tree linear_no_step
= NULL_TREE
;
14382 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
14384 nc
= copy_node (oc
);
14385 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
14388 switch (OMP_CLAUSE_CODE (nc
))
14390 case OMP_CLAUSE_LASTPRIVATE
:
14391 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
14393 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
14394 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
14395 in_decl
, /*integral_constant_expression_p=*/false);
14396 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
14397 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
14400 case OMP_CLAUSE_PRIVATE
:
14401 case OMP_CLAUSE_SHARED
:
14402 case OMP_CLAUSE_FIRSTPRIVATE
:
14403 case OMP_CLAUSE_COPYIN
:
14404 case OMP_CLAUSE_COPYPRIVATE
:
14405 case OMP_CLAUSE_UNIFORM
:
14406 case OMP_CLAUSE_DEPEND
:
14407 case OMP_CLAUSE_FROM
:
14408 case OMP_CLAUSE_TO
:
14409 case OMP_CLAUSE_MAP
:
14410 case OMP_CLAUSE_USE_DEVICE
:
14411 case OMP_CLAUSE_USE_DEVICE_PTR
:
14412 case OMP_CLAUSE_IS_DEVICE_PTR
:
14413 OMP_CLAUSE_DECL (nc
)
14414 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
14417 case OMP_CLAUSE_IF
:
14418 case OMP_CLAUSE_NUM_THREADS
:
14419 case OMP_CLAUSE_SCHEDULE
:
14420 case OMP_CLAUSE_COLLAPSE
:
14421 case OMP_CLAUSE_FINAL
:
14422 case OMP_CLAUSE_DEVICE
:
14423 case OMP_CLAUSE_DIST_SCHEDULE
:
14424 case OMP_CLAUSE_NUM_TEAMS
:
14425 case OMP_CLAUSE_THREAD_LIMIT
:
14426 case OMP_CLAUSE_SAFELEN
:
14427 case OMP_CLAUSE_SIMDLEN
:
14428 case OMP_CLAUSE_NUM_TASKS
:
14429 case OMP_CLAUSE_GRAINSIZE
:
14430 case OMP_CLAUSE_PRIORITY
:
14431 case OMP_CLAUSE_ORDERED
:
14432 case OMP_CLAUSE_HINT
:
14433 case OMP_CLAUSE_NUM_GANGS
:
14434 case OMP_CLAUSE_NUM_WORKERS
:
14435 case OMP_CLAUSE_VECTOR_LENGTH
:
14436 case OMP_CLAUSE_WORKER
:
14437 case OMP_CLAUSE_VECTOR
:
14438 case OMP_CLAUSE_ASYNC
:
14439 case OMP_CLAUSE_WAIT
:
14440 OMP_CLAUSE_OPERAND (nc
, 0)
14441 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
14442 in_decl
, /*integral_constant_expression_p=*/false);
14444 case OMP_CLAUSE_REDUCTION
:
14445 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
14447 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
14448 if (TREE_CODE (placeholder
) == SCOPE_REF
)
14450 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
14451 complain
, in_decl
);
14452 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
14453 = build_qualified_name (NULL_TREE
, scope
,
14454 TREE_OPERAND (placeholder
, 1),
14458 gcc_assert (identifier_p (placeholder
));
14460 OMP_CLAUSE_DECL (nc
)
14461 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
14464 case OMP_CLAUSE_GANG
:
14465 case OMP_CLAUSE_ALIGNED
:
14466 OMP_CLAUSE_DECL (nc
)
14467 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
14469 OMP_CLAUSE_OPERAND (nc
, 1)
14470 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
14471 in_decl
, /*integral_constant_expression_p=*/false);
14473 case OMP_CLAUSE_LINEAR
:
14474 OMP_CLAUSE_DECL (nc
)
14475 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
14477 if (OMP_CLAUSE_LINEAR_STEP (oc
) == NULL_TREE
)
14479 gcc_assert (!linear_no_step
);
14480 linear_no_step
= nc
;
14482 else if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (oc
))
14483 OMP_CLAUSE_LINEAR_STEP (nc
)
14484 = tsubst_omp_clause_decl (OMP_CLAUSE_LINEAR_STEP (oc
), args
,
14485 complain
, in_decl
);
14487 OMP_CLAUSE_LINEAR_STEP (nc
)
14488 = tsubst_expr (OMP_CLAUSE_LINEAR_STEP (oc
), args
, complain
,
14490 /*integral_constant_expression_p=*/false);
14492 case OMP_CLAUSE_NOWAIT
:
14493 case OMP_CLAUSE_DEFAULT
:
14494 case OMP_CLAUSE_UNTIED
:
14495 case OMP_CLAUSE_MERGEABLE
:
14496 case OMP_CLAUSE_INBRANCH
:
14497 case OMP_CLAUSE_NOTINBRANCH
:
14498 case OMP_CLAUSE_PROC_BIND
:
14499 case OMP_CLAUSE_FOR
:
14500 case OMP_CLAUSE_PARALLEL
:
14501 case OMP_CLAUSE_SECTIONS
:
14502 case OMP_CLAUSE_TASKGROUP
:
14503 case OMP_CLAUSE_NOGROUP
:
14504 case OMP_CLAUSE_THREADS
:
14505 case OMP_CLAUSE_SIMD
:
14506 case OMP_CLAUSE_DEFAULTMAP
:
14507 case OMP_CLAUSE_INDEPENDENT
:
14508 case OMP_CLAUSE_AUTO
:
14509 case OMP_CLAUSE_SEQ
:
14511 case OMP_CLAUSE_TILE
:
14514 for (lnc
= OMP_CLAUSE_TILE_LIST (nc
),
14515 loc
= OMP_CLAUSE_TILE_LIST (oc
);
14517 loc
= TREE_CHAIN (loc
), lnc
= TREE_CHAIN (lnc
))
14519 TREE_VALUE (lnc
) = tsubst_expr (TREE_VALUE (loc
), args
,
14520 complain
, in_decl
, false);
14525 gcc_unreachable ();
14528 switch (OMP_CLAUSE_CODE (nc
))
14530 case OMP_CLAUSE_SHARED
:
14531 case OMP_CLAUSE_PRIVATE
:
14532 case OMP_CLAUSE_FIRSTPRIVATE
:
14533 case OMP_CLAUSE_LASTPRIVATE
:
14534 case OMP_CLAUSE_COPYPRIVATE
:
14535 case OMP_CLAUSE_LINEAR
:
14536 case OMP_CLAUSE_REDUCTION
:
14537 case OMP_CLAUSE_USE_DEVICE
:
14538 case OMP_CLAUSE_USE_DEVICE_PTR
:
14539 case OMP_CLAUSE_IS_DEVICE_PTR
:
14540 /* tsubst_expr on SCOPE_REF results in returning
14541 finish_non_static_data_member result. Undo that here. */
14542 if (TREE_CODE (OMP_CLAUSE_DECL (oc
)) == SCOPE_REF
14543 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (oc
), 1))
14544 == IDENTIFIER_NODE
))
14546 tree t
= OMP_CLAUSE_DECL (nc
);
14549 switch (TREE_CODE (v
))
14551 case COMPONENT_REF
:
14555 case POINTER_PLUS_EXPR
:
14556 v
= TREE_OPERAND (v
, 0);
14559 if (DECL_CONTEXT (v
) == current_function_decl
14560 && DECL_ARTIFICIAL (v
)
14561 && DECL_NAME (v
) == this_identifier
)
14562 OMP_CLAUSE_DECL (nc
) = TREE_OPERAND (t
, 1);
14569 else if (VAR_P (OMP_CLAUSE_DECL (oc
))
14570 && DECL_HAS_VALUE_EXPR_P (OMP_CLAUSE_DECL (oc
))
14571 && DECL_ARTIFICIAL (OMP_CLAUSE_DECL (oc
))
14572 && DECL_LANG_SPECIFIC (OMP_CLAUSE_DECL (oc
))
14573 && DECL_OMP_PRIVATIZED_MEMBER (OMP_CLAUSE_DECL (oc
)))
14575 tree decl
= OMP_CLAUSE_DECL (nc
);
14578 if (!DECL_LANG_SPECIFIC (decl
))
14579 retrofit_lang_decl (decl
);
14580 DECL_OMP_PRIVATIZED_MEMBER (decl
) = 1;
14589 new_clauses
= nreverse (new_clauses
);
14592 new_clauses
= finish_omp_clauses (new_clauses
, allow_fields
);
14593 if (linear_no_step
)
14594 for (nc
= new_clauses
; nc
; nc
= OMP_CLAUSE_CHAIN (nc
))
14595 if (nc
== linear_no_step
)
14597 OMP_CLAUSE_LINEAR_STEP (nc
) = NULL_TREE
;
14601 return new_clauses
;
14604 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
14607 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
14610 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
14612 tree purpose
, value
, chain
;
14617 if (TREE_CODE (t
) != TREE_LIST
)
14618 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14619 /*function_p=*/false,
14620 /*integral_constant_expression_p=*/false);
14622 if (t
== void_list_node
)
14625 purpose
= TREE_PURPOSE (t
);
14627 purpose
= RECUR (purpose
);
14628 value
= TREE_VALUE (t
);
14631 if (TREE_CODE (value
) != LABEL_DECL
)
14632 value
= RECUR (value
);
14635 value
= lookup_label (DECL_NAME (value
));
14636 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
14637 TREE_USED (value
) = 1;
14640 chain
= TREE_CHAIN (t
);
14641 if (chain
&& chain
!= void_type_node
)
14642 chain
= RECUR (chain
);
14643 return tree_cons (purpose
, value
, chain
);
14647 /* Used to temporarily communicate the list of #pragma omp parallel
14648 clauses to #pragma omp for instantiation if they are combined
14651 static tree
*omp_parallel_combined_clauses
;
14653 /* Substitute one OMP_FOR iterator. */
14656 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree orig_declv
,
14657 tree initv
, tree condv
, tree incrv
, tree
*clauses
,
14658 tree args
, tsubst_flags_t complain
, tree in_decl
,
14659 bool integral_constant_expression_p
)
14661 #define RECUR(NODE) \
14662 tsubst_expr ((NODE), args, complain, in_decl, \
14663 integral_constant_expression_p)
14664 tree decl
, init
, cond
, incr
;
14666 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
14667 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
14669 if (orig_declv
&& OMP_FOR_ORIG_DECLS (t
))
14671 tree o
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t
), i
);
14672 TREE_VEC_ELT (orig_declv
, i
) = RECUR (o
);
14675 decl
= TREE_OPERAND (init
, 0);
14676 init
= TREE_OPERAND (init
, 1);
14677 tree decl_expr
= NULL_TREE
;
14678 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
14680 /* We need to jump through some hoops to handle declarations in the
14681 for-init-statement, since we might need to handle auto deduction,
14682 but we need to keep control of initialization. */
14684 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
14685 decl
= tsubst_decl (decl
, args
, complain
);
14689 if (TREE_CODE (decl
) == SCOPE_REF
)
14691 decl
= RECUR (decl
);
14692 if (TREE_CODE (decl
) == COMPONENT_REF
)
14696 switch (TREE_CODE (v
))
14698 case COMPONENT_REF
:
14702 case POINTER_PLUS_EXPR
:
14703 v
= TREE_OPERAND (v
, 0);
14706 if (DECL_CONTEXT (v
) == current_function_decl
14707 && DECL_ARTIFICIAL (v
)
14708 && DECL_NAME (v
) == this_identifier
)
14710 decl
= TREE_OPERAND (decl
, 1);
14711 decl
= omp_privatize_field (decl
, false);
14721 decl
= RECUR (decl
);
14723 init
= RECUR (init
);
14725 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
14726 if (auto_node
&& init
)
14728 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
14730 gcc_assert (!type_dependent_expression_p (decl
));
14732 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
14736 /* Declare the variable, but don't let that initialize it. */
14737 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
14738 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
14740 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
14743 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
14744 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
14745 if (TREE_CODE (incr
) == MODIFY_EXPR
)
14747 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
14748 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
14749 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
14750 NOP_EXPR
, rhs
, complain
);
14753 incr
= RECUR (incr
);
14754 TREE_VEC_ELT (declv
, i
) = decl
;
14755 TREE_VEC_ELT (initv
, i
) = init
;
14756 TREE_VEC_ELT (condv
, i
) = cond
;
14757 TREE_VEC_ELT (incrv
, i
) = incr
;
14763 /* Declare and initialize the variable. */
14771 for (j
= (omp_parallel_combined_clauses
== NULL
? 1 : 0); j
< 2; j
++)
14773 for (pc
= j
? clauses
: omp_parallel_combined_clauses
; *pc
; )
14775 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
14776 && OMP_CLAUSE_DECL (*pc
) == decl
)
14778 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_LASTPRIVATE
14779 && OMP_CLAUSE_DECL (*pc
) == decl
)
14783 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
14785 *pc
= OMP_CLAUSE_CHAIN (c
);
14786 OMP_CLAUSE_CHAIN (c
) = *clauses
;
14789 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_FIRSTPRIVATE
14790 && OMP_CLAUSE_DECL (*pc
) == decl
)
14792 error ("iteration variable %qD should not be firstprivate",
14794 *pc
= OMP_CLAUSE_CHAIN (*pc
);
14796 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_REDUCTION
14797 && OMP_CLAUSE_DECL (*pc
) == decl
)
14799 error ("iteration variable %qD should not be reduction",
14801 *pc
= OMP_CLAUSE_CHAIN (*pc
);
14804 pc
= &OMP_CLAUSE_CHAIN (*pc
);
14809 if (*pc
== NULL_TREE
)
14811 tree c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
14812 OMP_CLAUSE_DECL (c
) = decl
;
14813 c
= finish_omp_clauses (c
, true);
14816 OMP_CLAUSE_CHAIN (c
) = *clauses
;
14821 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
14822 if (COMPARISON_CLASS_P (cond
))
14824 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
14825 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
14826 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
14829 cond
= RECUR (cond
);
14830 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
14831 switch (TREE_CODE (incr
))
14833 case PREINCREMENT_EXPR
:
14834 case PREDECREMENT_EXPR
:
14835 case POSTINCREMENT_EXPR
:
14836 case POSTDECREMENT_EXPR
:
14837 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
14838 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
14841 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
14842 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
14844 tree rhs
= TREE_OPERAND (incr
, 1);
14845 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
14846 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
14847 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
14848 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
14849 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
14853 incr
= RECUR (incr
);
14856 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
14857 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
14859 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
14860 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
14861 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
14862 TREE_TYPE (decl
), lhs
,
14863 RECUR (TREE_OPERAND (incr
, 2))));
14865 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
14866 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
14867 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
14869 tree rhs
= TREE_OPERAND (incr
, 2);
14870 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
14871 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
14872 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
14873 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
14874 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
14878 incr
= RECUR (incr
);
14881 incr
= RECUR (incr
);
14885 TREE_VEC_ELT (declv
, i
) = decl
;
14886 TREE_VEC_ELT (initv
, i
) = init
;
14887 TREE_VEC_ELT (condv
, i
) = cond
;
14888 TREE_VEC_ELT (incrv
, i
) = incr
;
14892 /* Helper function of tsubst_expr, find OMP_TEAMS inside
14893 of OMP_TARGET's body. */
14896 tsubst_find_omp_teams (tree
*tp
, int *walk_subtrees
, void *)
14898 *walk_subtrees
= 0;
14899 switch (TREE_CODE (*tp
))
14904 case STATEMENT_LIST
:
14905 *walk_subtrees
= 1;
14913 /* Like tsubst_copy for expressions, etc. but also does semantic
14917 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
14918 bool integral_constant_expression_p
)
14920 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
14921 #define RECUR(NODE) \
14922 tsubst_expr ((NODE), args, complain, in_decl, \
14923 integral_constant_expression_p)
14929 if (t
== NULL_TREE
|| t
== error_mark_node
)
14932 loc
= input_location
;
14933 if (EXPR_HAS_LOCATION (t
))
14934 input_location
= EXPR_LOCATION (t
);
14935 if (STATEMENT_CODE_P (TREE_CODE (t
)))
14936 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
14938 switch (TREE_CODE (t
))
14940 case STATEMENT_LIST
:
14942 tree_stmt_iterator i
;
14943 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
14944 RECUR (tsi_stmt (i
));
14948 case CTOR_INITIALIZER
:
14949 finish_mem_initializers (tsubst_initializer_list
14950 (TREE_OPERAND (t
, 0), args
));
14954 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
14958 tmp
= RECUR (EXPR_STMT_EXPR (t
));
14959 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
14960 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
14962 finish_expr_stmt (tmp
);
14966 do_using_directive (USING_STMT_NAMESPACE (t
));
14971 tree decl
, pattern_decl
;
14974 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
14975 if (TREE_CODE (decl
) == LABEL_DECL
)
14976 finish_label_decl (DECL_NAME (decl
));
14977 else if (TREE_CODE (decl
) == USING_DECL
)
14979 tree scope
= USING_DECL_SCOPE (decl
);
14980 tree name
= DECL_NAME (decl
);
14983 scope
= tsubst (scope
, args
, complain
, in_decl
);
14984 decl
= lookup_qualified_name (scope
, name
,
14985 /*is_type_p=*/false,
14986 /*complain=*/false);
14987 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
14988 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
14990 do_local_using_decl (decl
, scope
, name
);
14992 else if (DECL_PACK_P (decl
))
14994 /* Don't build up decls for a variadic capture proxy, we'll
14995 instantiate the elements directly as needed. */
15000 init
= DECL_INITIAL (decl
);
15001 decl
= tsubst (decl
, args
, complain
, in_decl
);
15002 if (decl
!= error_mark_node
)
15004 /* By marking the declaration as instantiated, we avoid
15005 trying to instantiate it. Since instantiate_decl can't
15006 handle local variables, and since we've already done
15007 all that needs to be done, that's the right thing to
15010 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
15012 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
15013 /* Anonymous aggregates are a special case. */
15014 finish_anon_union (decl
);
15015 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
15017 DECL_CONTEXT (decl
) = current_function_decl
;
15018 if (DECL_NAME (decl
) == this_identifier
)
15020 tree lam
= DECL_CONTEXT (current_function_decl
);
15021 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
15022 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
15024 insert_capture_proxy (decl
);
15026 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
15027 /* We already did a pushtag. */;
15028 else if (TREE_CODE (decl
) == FUNCTION_DECL
15029 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
15030 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
15032 DECL_CONTEXT (decl
) = NULL_TREE
;
15034 DECL_CONTEXT (decl
) = current_function_decl
;
15035 cp_check_omp_declare_reduction (decl
);
15039 int const_init
= false;
15040 maybe_push_decl (decl
);
15042 && DECL_PRETTY_FUNCTION_P (decl
))
15044 /* For __PRETTY_FUNCTION__ we have to adjust the
15046 const char *const name
15047 = cxx_printable_name (current_function_decl
, 2);
15048 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
15051 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
15054 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
15056 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
15065 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
15066 RECUR (FOR_INIT_STMT (t
));
15067 finish_for_init_stmt (stmt
);
15068 tmp
= RECUR (FOR_COND (t
));
15069 finish_for_cond (tmp
, stmt
, false);
15070 tmp
= RECUR (FOR_EXPR (t
));
15071 finish_for_expr (tmp
, stmt
);
15072 RECUR (FOR_BODY (t
));
15073 finish_for_stmt (stmt
);
15076 case RANGE_FOR_STMT
:
15079 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
15080 decl
= RANGE_FOR_DECL (t
);
15081 decl
= tsubst (decl
, args
, complain
, in_decl
);
15082 maybe_push_decl (decl
);
15083 expr
= RECUR (RANGE_FOR_EXPR (t
));
15084 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
15085 RECUR (RANGE_FOR_BODY (t
));
15086 finish_for_stmt (stmt
);
15091 stmt
= begin_while_stmt ();
15092 tmp
= RECUR (WHILE_COND (t
));
15093 finish_while_stmt_cond (tmp
, stmt
, false);
15094 RECUR (WHILE_BODY (t
));
15095 finish_while_stmt (stmt
);
15099 stmt
= begin_do_stmt ();
15100 RECUR (DO_BODY (t
));
15101 finish_do_body (stmt
);
15102 tmp
= RECUR (DO_COND (t
));
15103 finish_do_stmt (tmp
, stmt
, false);
15107 stmt
= begin_if_stmt ();
15108 tmp
= RECUR (IF_COND (t
));
15109 finish_if_stmt_cond (tmp
, stmt
);
15110 RECUR (THEN_CLAUSE (t
));
15111 finish_then_clause (stmt
);
15113 if (ELSE_CLAUSE (t
))
15115 begin_else_clause (stmt
);
15116 RECUR (ELSE_CLAUSE (t
));
15117 finish_else_clause (stmt
);
15120 finish_if_stmt (stmt
);
15124 if (BIND_EXPR_BODY_BLOCK (t
))
15125 stmt
= begin_function_body ();
15127 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
15128 ? BCS_TRY_BLOCK
: 0);
15130 RECUR (BIND_EXPR_BODY (t
));
15132 if (BIND_EXPR_BODY_BLOCK (t
))
15133 finish_function_body (stmt
);
15135 finish_compound_stmt (stmt
);
15139 finish_break_stmt ();
15142 case CONTINUE_STMT
:
15143 finish_continue_stmt ();
15147 stmt
= begin_switch_stmt ();
15148 tmp
= RECUR (SWITCH_STMT_COND (t
));
15149 finish_switch_cond (tmp
, stmt
);
15150 RECUR (SWITCH_STMT_BODY (t
));
15151 finish_switch_stmt (stmt
);
15154 case CASE_LABEL_EXPR
:
15156 tree low
= RECUR (CASE_LOW (t
));
15157 tree high
= RECUR (CASE_HIGH (t
));
15158 finish_case_label (EXPR_LOCATION (t
), low
, high
);
15164 tree decl
= LABEL_EXPR_LABEL (t
);
15167 label
= finish_label_stmt (DECL_NAME (decl
));
15168 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
15169 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
15174 tmp
= GOTO_DESTINATION (t
);
15175 if (TREE_CODE (tmp
) != LABEL_DECL
)
15176 /* Computed goto's must be tsubst'd into. On the other hand,
15177 non-computed gotos must not be; the identifier in question
15178 will have no binding. */
15181 tmp
= DECL_NAME (tmp
);
15182 finish_goto_stmt (tmp
);
15187 tree string
= RECUR (ASM_STRING (t
));
15188 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
15189 complain
, in_decl
);
15190 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
15191 complain
, in_decl
);
15192 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
15193 complain
, in_decl
);
15194 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
15195 complain
, in_decl
);
15196 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
15198 tree asm_expr
= tmp
;
15199 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
15200 asm_expr
= TREE_OPERAND (asm_expr
, 0);
15201 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
15208 stmt
= begin_try_block ();
15209 RECUR (TRY_STMTS (t
));
15210 finish_cleanup_try_block (stmt
);
15211 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
15215 tree compound_stmt
= NULL_TREE
;
15217 if (FN_TRY_BLOCK_P (t
))
15218 stmt
= begin_function_try_block (&compound_stmt
);
15220 stmt
= begin_try_block ();
15222 RECUR (TRY_STMTS (t
));
15224 if (FN_TRY_BLOCK_P (t
))
15225 finish_function_try_block (stmt
);
15227 finish_try_block (stmt
);
15229 RECUR (TRY_HANDLERS (t
));
15230 if (FN_TRY_BLOCK_P (t
))
15231 finish_function_handler_sequence (stmt
, compound_stmt
);
15233 finish_handler_sequence (stmt
);
15239 tree decl
= HANDLER_PARMS (t
);
15243 decl
= tsubst (decl
, args
, complain
, in_decl
);
15244 /* Prevent instantiate_decl from trying to instantiate
15245 this variable. We've already done all that needs to be
15247 if (decl
!= error_mark_node
)
15248 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
15250 stmt
= begin_handler ();
15251 finish_handler_parms (decl
, stmt
);
15252 RECUR (HANDLER_BODY (t
));
15253 finish_handler (stmt
);
15258 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
15259 if (CLASS_TYPE_P (tmp
))
15261 /* Local classes are not independent templates; they are
15262 instantiated along with their containing function. And this
15263 way we don't have to deal with pushing out of one local class
15264 to instantiate a member of another local class. */
15266 /* Closures are handled by the LAMBDA_EXPR. */
15267 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
15268 complete_type (tmp
);
15269 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
15270 if (!DECL_ARTIFICIAL (fn
))
15271 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
15275 case STATIC_ASSERT
:
15279 ++c_inhibit_evaluation_warnings
;
15281 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
15284 /*integral_constant_expression_p=*/true);
15285 --c_inhibit_evaluation_warnings
;
15287 finish_static_assert (condition
,
15288 STATIC_ASSERT_MESSAGE (t
),
15289 STATIC_ASSERT_SOURCE_LOCATION (t
),
15290 /*member_p=*/false);
15295 case OACC_PARALLEL
:
15296 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false, false, args
, complain
,
15298 stmt
= begin_omp_parallel ();
15299 RECUR (OMP_BODY (t
));
15300 finish_omp_construct (TREE_CODE (t
), stmt
, tmp
);
15304 r
= push_omp_privatization_clauses (OMP_PARALLEL_COMBINED (t
));
15305 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false, true,
15306 args
, complain
, in_decl
);
15307 if (OMP_PARALLEL_COMBINED (t
))
15308 omp_parallel_combined_clauses
= &tmp
;
15309 stmt
= begin_omp_parallel ();
15310 RECUR (OMP_PARALLEL_BODY (t
));
15311 gcc_assert (omp_parallel_combined_clauses
== NULL
);
15312 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
15313 = OMP_PARALLEL_COMBINED (t
);
15314 pop_omp_privatization_clauses (r
);
15318 r
= push_omp_privatization_clauses (false);
15319 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false, true,
15320 args
, complain
, in_decl
);
15321 stmt
= begin_omp_task ();
15322 RECUR (OMP_TASK_BODY (t
));
15323 finish_omp_task (tmp
, stmt
);
15324 pop_omp_privatization_clauses (r
);
15331 case OMP_DISTRIBUTE
:
15335 tree clauses
, body
, pre_body
;
15336 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
15337 tree orig_declv
= NULL_TREE
;
15338 tree incrv
= NULL_TREE
;
15341 r
= push_omp_privatization_clauses (OMP_FOR_INIT (t
) == NULL_TREE
);
15342 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
15343 TREE_CODE (t
) != OACC_LOOP
,
15344 args
, complain
, in_decl
);
15345 if (OMP_FOR_INIT (t
) != NULL_TREE
)
15347 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
15348 if (OMP_FOR_ORIG_DECLS (t
))
15349 orig_declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
15350 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
15351 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
15352 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
15355 stmt
= begin_omp_structured_block ();
15357 pre_body
= push_stmt_list ();
15358 RECUR (OMP_FOR_PRE_BODY (t
));
15359 pre_body
= pop_stmt_list (pre_body
);
15361 if (OMP_FOR_INIT (t
) != NULL_TREE
)
15362 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
15363 tsubst_omp_for_iterator (t
, i
, declv
, orig_declv
, initv
, condv
,
15364 incrv
, &clauses
, args
, complain
, in_decl
,
15365 integral_constant_expression_p
);
15366 omp_parallel_combined_clauses
= NULL
;
15368 body
= push_stmt_list ();
15369 RECUR (OMP_FOR_BODY (t
));
15370 body
= pop_stmt_list (body
);
15372 if (OMP_FOR_INIT (t
) != NULL_TREE
)
15373 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
,
15374 orig_declv
, initv
, condv
, incrv
, body
, pre_body
,
15378 t
= make_node (TREE_CODE (t
));
15379 TREE_TYPE (t
) = void_type_node
;
15380 OMP_FOR_BODY (t
) = body
;
15381 OMP_FOR_PRE_BODY (t
) = pre_body
;
15382 OMP_FOR_CLAUSES (t
) = clauses
;
15383 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
15387 add_stmt (finish_omp_structured_block (stmt
));
15388 pop_omp_privatization_clauses (r
);
15393 omp_parallel_combined_clauses
= NULL
;
15398 r
= push_omp_privatization_clauses (TREE_CODE (t
) == OMP_TEAMS
15399 && OMP_TEAMS_COMBINED (t
));
15400 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false, true,
15401 args
, complain
, in_decl
);
15402 stmt
= push_stmt_list ();
15403 RECUR (OMP_BODY (t
));
15404 stmt
= pop_stmt_list (stmt
);
15407 OMP_BODY (t
) = stmt
;
15408 OMP_CLAUSES (t
) = tmp
;
15410 pop_omp_privatization_clauses (r
);
15414 case OMP_TARGET_DATA
:
15416 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
15417 TREE_CODE (t
) != OACC_DATA
,
15418 args
, complain
, in_decl
);
15419 keep_next_level (true);
15420 stmt
= begin_omp_structured_block ();
15422 RECUR (OMP_BODY (t
));
15423 stmt
= finish_omp_structured_block (stmt
);
15426 OMP_BODY (t
) = stmt
;
15427 OMP_CLAUSES (t
) = tmp
;
15428 if (TREE_CODE (t
) == OMP_TARGET
&& OMP_TARGET_COMBINED (t
))
15430 tree teams
= cp_walk_tree (&stmt
, tsubst_find_omp_teams
, NULL
, NULL
);
15433 /* For combined target teams, ensure the num_teams and
15434 thread_limit clause expressions are evaluated on the host,
15435 before entering the target construct. */
15437 for (c
= OMP_TEAMS_CLAUSES (teams
);
15438 c
; c
= OMP_CLAUSE_CHAIN (c
))
15439 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
15440 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
15441 && TREE_CODE (OMP_CLAUSE_OPERAND (c
, 0)) != INTEGER_CST
)
15443 tree expr
= OMP_CLAUSE_OPERAND (c
, 0);
15444 expr
= force_target_expr (TREE_TYPE (expr
), expr
, tf_none
);
15445 if (expr
== error_mark_node
)
15447 tmp
= TARGET_EXPR_SLOT (expr
);
15449 OMP_CLAUSE_OPERAND (c
, 0) = expr
;
15450 tree tc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
15451 OMP_CLAUSE_FIRSTPRIVATE
);
15452 OMP_CLAUSE_DECL (tc
) = tmp
;
15453 OMP_CLAUSE_CHAIN (tc
) = OMP_TARGET_CLAUSES (t
);
15454 OMP_TARGET_CLAUSES (t
) = tc
;
15463 tmp
= tsubst_omp_clauses (OACC_DECLARE_CLAUSES (t
), false, false,
15464 args
, complain
, in_decl
);
15465 OACC_DECLARE_CLAUSES (t
) = tmp
;
15469 case OMP_TARGET_UPDATE
:
15470 case OMP_TARGET_ENTER_DATA
:
15471 case OMP_TARGET_EXIT_DATA
:
15472 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), false, true,
15473 args
, complain
, in_decl
);
15475 OMP_STANDALONE_CLAUSES (t
) = tmp
;
15479 case OACC_ENTER_DATA
:
15480 case OACC_EXIT_DATA
:
15482 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), false, false,
15483 args
, complain
, in_decl
);
15485 OMP_STANDALONE_CLAUSES (t
) = tmp
;
15490 tmp
= tsubst_omp_clauses (OMP_ORDERED_CLAUSES (t
), false, true,
15491 args
, complain
, in_decl
);
15492 stmt
= push_stmt_list ();
15493 RECUR (OMP_BODY (t
));
15494 stmt
= pop_stmt_list (stmt
);
15497 OMP_BODY (t
) = stmt
;
15498 OMP_ORDERED_CLAUSES (t
) = tmp
;
15504 case OMP_TASKGROUP
:
15505 stmt
= push_stmt_list ();
15506 RECUR (OMP_BODY (t
));
15507 stmt
= pop_stmt_list (stmt
);
15510 OMP_BODY (t
) = stmt
;
15515 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
15516 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
15518 tree op1
= TREE_OPERAND (t
, 1);
15519 tree rhs1
= NULL_TREE
;
15521 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
15523 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
15524 op1
= TREE_OPERAND (op1
, 1);
15526 lhs
= RECUR (TREE_OPERAND (op1
, 0));
15527 rhs
= RECUR (TREE_OPERAND (op1
, 1));
15528 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
15529 NULL_TREE
, NULL_TREE
, rhs1
,
15530 OMP_ATOMIC_SEQ_CST (t
));
15534 tree op1
= TREE_OPERAND (t
, 1);
15535 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
15536 tree rhs1
= NULL_TREE
;
15537 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
15538 enum tree_code opcode
= NOP_EXPR
;
15539 if (code
== OMP_ATOMIC_READ
)
15541 v
= RECUR (TREE_OPERAND (op1
, 0));
15542 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
15544 else if (code
== OMP_ATOMIC_CAPTURE_OLD
15545 || code
== OMP_ATOMIC_CAPTURE_NEW
)
15547 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
15548 v
= RECUR (TREE_OPERAND (op1
, 0));
15549 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
15550 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
15552 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
15553 op11
= TREE_OPERAND (op11
, 1);
15555 lhs
= RECUR (TREE_OPERAND (op11
, 0));
15556 rhs
= RECUR (TREE_OPERAND (op11
, 1));
15557 opcode
= TREE_CODE (op11
);
15558 if (opcode
== MODIFY_EXPR
)
15564 lhs
= RECUR (TREE_OPERAND (op1
, 0));
15565 rhs
= RECUR (TREE_OPERAND (op1
, 1));
15567 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
15568 OMP_ATOMIC_SEQ_CST (t
));
15572 case TRANSACTION_EXPR
:
15575 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
15576 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
15578 if (TRANSACTION_EXPR_IS_STMT (t
))
15580 tree body
= TRANSACTION_EXPR_BODY (t
);
15581 tree noex
= NULL_TREE
;
15582 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
15584 noex
= MUST_NOT_THROW_COND (body
);
15585 if (noex
== NULL_TREE
)
15586 noex
= boolean_true_node
;
15587 body
= TREE_OPERAND (body
, 0);
15589 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
15591 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
15595 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
15596 RECUR (TRANSACTION_EXPR_BODY (t
)),
15603 case MUST_NOT_THROW_EXPR
:
15605 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15606 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
15607 RETURN (build_must_not_throw_expr (op0
, cond
));
15610 case EXPR_PACK_EXPANSION
:
15611 error ("invalid use of pack expansion expression");
15612 RETURN (error_mark_node
);
15614 case NONTYPE_ARGUMENT_PACK
:
15615 error ("use %<...%> to expand argument pack");
15616 RETURN (error_mark_node
);
15618 case CILK_SPAWN_STMT
:
15619 cfun
->calls_cilk_spawn
= 1;
15620 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
15622 case CILK_SYNC_STMT
:
15623 RETURN (build_cilk_sync ());
15625 case COMPOUND_EXPR
:
15626 tmp
= RECUR (TREE_OPERAND (t
, 0));
15627 if (tmp
== NULL_TREE
)
15628 /* If the first operand was a statement, we're done with it. */
15629 RETURN (RECUR (TREE_OPERAND (t
, 1)));
15630 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
15631 RECUR (TREE_OPERAND (t
, 1)),
15634 case ANNOTATE_EXPR
:
15635 tmp
= RECUR (TREE_OPERAND (t
, 0));
15636 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
15637 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
15640 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
15642 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
15643 /*function_p=*/false,
15644 integral_constant_expression_p
));
15647 RETURN (NULL_TREE
);
15649 input_location
= loc
;
15655 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
15656 function. For description of the body see comment above
15657 cp_parser_omp_declare_reduction_exprs. */
15660 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
15662 if (t
== NULL_TREE
|| t
== error_mark_node
)
15665 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
15667 tree_stmt_iterator tsi
;
15670 memset (stmts
, 0, sizeof stmts
);
15671 for (i
= 0, tsi
= tsi_start (t
);
15672 i
< 7 && !tsi_end_p (tsi
);
15673 i
++, tsi_next (&tsi
))
15674 stmts
[i
] = tsi_stmt (tsi
);
15675 gcc_assert (tsi_end_p (tsi
));
15679 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
15680 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
15681 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
15682 args
, complain
, in_decl
);
15683 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
15684 args
, complain
, in_decl
);
15685 DECL_CONTEXT (omp_out
) = current_function_decl
;
15686 DECL_CONTEXT (omp_in
) = current_function_decl
;
15687 keep_next_level (true);
15688 tree block
= begin_omp_structured_block ();
15689 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
15690 block
= finish_omp_structured_block (block
);
15691 block
= maybe_cleanup_point_expr_void (block
);
15692 add_decl_expr (omp_out
);
15693 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
15694 TREE_NO_WARNING (omp_out
) = 1;
15695 add_decl_expr (omp_in
);
15696 finish_expr_stmt (block
);
15700 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
15701 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
15702 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
15703 args
, complain
, in_decl
);
15704 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
15705 args
, complain
, in_decl
);
15706 DECL_CONTEXT (omp_priv
) = current_function_decl
;
15707 DECL_CONTEXT (omp_orig
) = current_function_decl
;
15708 keep_next_level (true);
15709 tree block
= begin_omp_structured_block ();
15710 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
15711 block
= finish_omp_structured_block (block
);
15712 block
= maybe_cleanup_point_expr_void (block
);
15713 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
15714 add_decl_expr (omp_priv
);
15715 add_decl_expr (omp_orig
);
15716 finish_expr_stmt (block
);
15718 add_decl_expr (omp_orig
);
15722 /* T is a postfix-expression that is not being used in a function
15723 call. Return the substituted version of T. */
15726 tsubst_non_call_postfix_expression (tree t
, tree args
,
15727 tsubst_flags_t complain
,
15730 if (TREE_CODE (t
) == SCOPE_REF
)
15731 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
15732 /*done=*/false, /*address_p=*/false);
15734 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
15735 /*function_p=*/false,
15736 /*integral_constant_expression_p=*/false);
15741 /* Like tsubst but deals with expressions and performs semantic
15742 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
15745 tsubst_copy_and_build (tree t
,
15747 tsubst_flags_t complain
,
15750 bool integral_constant_expression_p
)
15752 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
15753 #define RECUR(NODE) \
15754 tsubst_copy_and_build (NODE, args, complain, in_decl, \
15755 /*function_p=*/false, \
15756 integral_constant_expression_p)
15761 if (t
== NULL_TREE
|| t
== error_mark_node
)
15764 loc
= input_location
;
15765 if (EXPR_HAS_LOCATION (t
))
15766 input_location
= EXPR_LOCATION (t
);
15768 /* N3276 decltype magic only applies to calls at the top level or on the
15769 right side of a comma. */
15770 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
15771 complain
&= ~tf_decltype
;
15773 switch (TREE_CODE (t
))
15777 /* Fall through. */
15778 case IDENTIFIER_NODE
:
15782 bool non_integral_constant_expression_p
;
15783 const char *error_msg
;
15785 if (IDENTIFIER_TYPENAME_P (t
))
15787 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15788 t
= mangle_conv_op_name_for_type (new_type
);
15791 /* Look up the name. */
15792 decl
= lookup_name (t
);
15794 /* By convention, expressions use ERROR_MARK_NODE to indicate
15795 failure, not NULL_TREE. */
15796 if (decl
== NULL_TREE
)
15797 decl
= error_mark_node
;
15799 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
15801 integral_constant_expression_p
,
15802 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
15803 &non_integral_constant_expression_p
,
15804 /*template_p=*/false,
15806 /*address_p=*/false,
15807 /*template_arg_p=*/false,
15812 if (!function_p
&& identifier_p (decl
))
15814 if (complain
& tf_error
)
15815 unqualified_name_lookup_error (decl
);
15816 decl
= error_mark_node
;
15821 case TEMPLATE_ID_EXPR
:
15824 tree templ
= RECUR (TREE_OPERAND (t
, 0));
15825 tree targs
= TREE_OPERAND (t
, 1);
15828 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
15829 if (targs
== error_mark_node
)
15830 return error_mark_node
;
15832 if (variable_template_p (templ
))
15834 templ
= lookup_template_variable (templ
, targs
);
15835 if (!any_dependent_template_arguments_p (targs
))
15837 templ
= finish_template_variable (templ
, complain
);
15840 RETURN (convert_from_reference (templ
));
15843 if (TREE_CODE (templ
) == COMPONENT_REF
)
15845 object
= TREE_OPERAND (templ
, 0);
15846 templ
= TREE_OPERAND (templ
, 1);
15849 object
= NULL_TREE
;
15850 templ
= lookup_template_function (templ
, targs
);
15853 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
15854 object
, templ
, NULL_TREE
));
15856 RETURN (baselink_for_fns (templ
));
15861 tree r
= RECUR (TREE_OPERAND (t
, 0));
15863 if (REFERENCE_REF_P (t
))
15865 /* A type conversion to reference type will be enclosed in
15866 such an indirect ref, but the substitution of the cast
15867 will have also added such an indirect ref. */
15868 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
15869 r
= convert_from_reference (r
);
15872 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
15873 complain
|decltype_flag
);
15879 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15880 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15881 RETURN (build_nop (type
, op0
));
15884 case IMPLICIT_CONV_EXPR
:
15886 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15887 tree expr
= RECUR (TREE_OPERAND (t
, 0));
15888 int flags
= LOOKUP_IMPLICIT
;
15889 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
15890 flags
= LOOKUP_NORMAL
;
15891 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
15897 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15898 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15899 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
15903 case REINTERPRET_CAST_EXPR
:
15904 case CONST_CAST_EXPR
:
15905 case DYNAMIC_CAST_EXPR
:
15906 case STATIC_CAST_EXPR
:
15909 tree op
, r
= NULL_TREE
;
15911 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15912 if (integral_constant_expression_p
15913 && !cast_valid_in_integral_constant_expression_p (type
))
15915 if (complain
& tf_error
)
15916 error ("a cast to a type other than an integral or "
15917 "enumeration type cannot appear in a constant-expression");
15918 RETURN (error_mark_node
);
15921 op
= RECUR (TREE_OPERAND (t
, 0));
15923 warning_sentinel
s(warn_useless_cast
);
15924 switch (TREE_CODE (t
))
15927 r
= build_functional_cast (type
, op
, complain
);
15929 case REINTERPRET_CAST_EXPR
:
15930 r
= build_reinterpret_cast (type
, op
, complain
);
15932 case CONST_CAST_EXPR
:
15933 r
= build_const_cast (type
, op
, complain
);
15935 case DYNAMIC_CAST_EXPR
:
15936 r
= build_dynamic_cast (type
, op
, complain
);
15938 case STATIC_CAST_EXPR
:
15939 r
= build_static_cast (type
, op
, complain
);
15942 gcc_unreachable ();
15948 case POSTDECREMENT_EXPR
:
15949 case POSTINCREMENT_EXPR
:
15950 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15951 args
, complain
, in_decl
);
15952 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
15953 complain
|decltype_flag
));
15955 case PREDECREMENT_EXPR
:
15956 case PREINCREMENT_EXPR
:
15960 case TRUTH_NOT_EXPR
:
15961 case UNARY_PLUS_EXPR
: /* Unary + */
15962 case REALPART_EXPR
:
15963 case IMAGPART_EXPR
:
15964 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
15965 RECUR (TREE_OPERAND (t
, 0)),
15966 complain
|decltype_flag
));
15968 case FIX_TRUNC_EXPR
:
15969 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
15973 op1
= TREE_OPERAND (t
, 0);
15974 if (TREE_CODE (op1
) == LABEL_DECL
)
15975 RETURN (finish_label_address_expr (DECL_NAME (op1
),
15976 EXPR_LOCATION (op1
)));
15977 if (TREE_CODE (op1
) == SCOPE_REF
)
15978 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
15979 /*done=*/true, /*address_p=*/true);
15981 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
15983 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
15984 complain
|decltype_flag
));
15989 case TRUNC_DIV_EXPR
:
15990 case CEIL_DIV_EXPR
:
15991 case FLOOR_DIV_EXPR
:
15992 case ROUND_DIV_EXPR
:
15993 case EXACT_DIV_EXPR
:
15997 case TRUNC_MOD_EXPR
:
15998 case FLOOR_MOD_EXPR
:
15999 case TRUTH_ANDIF_EXPR
:
16000 case TRUTH_ORIF_EXPR
:
16001 case TRUTH_AND_EXPR
:
16002 case TRUTH_OR_EXPR
:
16018 warning_sentinel
s1(warn_type_limits
);
16019 warning_sentinel
s2(warn_div_by_zero
);
16020 warning_sentinel
s3(warn_logical_op
);
16021 warning_sentinel
s4(warn_tautological_compare
);
16022 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16023 tree op1
= RECUR (TREE_OPERAND (t
, 1));
16024 tree r
= build_x_binary_op
16025 (input_location
, TREE_CODE (t
),
16027 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
16029 : TREE_CODE (TREE_OPERAND (t
, 0))),
16031 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
16033 : TREE_CODE (TREE_OPERAND (t
, 1))),
16035 complain
|decltype_flag
);
16036 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
16037 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
16042 case POINTER_PLUS_EXPR
:
16044 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16045 tree op1
= RECUR (TREE_OPERAND (t
, 1));
16046 return fold_build_pointer_plus (op0
, op1
);
16050 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
16051 /*address_p=*/false));
16053 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
16054 args
, complain
, in_decl
);
16055 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
16056 RECUR (TREE_OPERAND (t
, 1)),
16057 complain
|decltype_flag
));
16059 case ARRAY_NOTATION_REF
:
16061 tree start_index
, length
, stride
;
16062 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
16063 args
, complain
, in_decl
);
16064 start_index
= RECUR (ARRAY_NOTATION_START (t
));
16065 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
16066 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
16067 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
16068 length
, stride
, TREE_TYPE (op1
)));
16071 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
16072 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
16079 op1
= TREE_OPERAND (t
, 0);
16080 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
16081 op1
= TREE_TYPE (op1
);
16084 /* When there are no ARGS, we are trying to evaluate a
16085 non-dependent expression from the parser. Trying to do
16086 the substitutions may not work. */
16088 op1
= TREE_TYPE (op1
);
16092 ++cp_unevaluated_operand
;
16093 ++c_inhibit_evaluation_warnings
;
16095 op1
= tsubst (op1
, args
, complain
, in_decl
);
16097 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
16098 /*function_p=*/false,
16099 /*integral_constant_expression_p=*/
16101 --cp_unevaluated_operand
;
16102 --c_inhibit_evaluation_warnings
;
16105 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
16106 complain
& tf_error
);
16108 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
16109 complain
& tf_error
);
16110 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
16112 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
16114 if (!processing_template_decl
&& TYPE_P (op1
))
16116 r
= build_min (SIZEOF_EXPR
, size_type_node
,
16117 build1 (NOP_EXPR
, op1
, error_mark_node
));
16118 SIZEOF_EXPR_TYPE_P (r
) = 1;
16121 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
16122 TREE_SIDE_EFFECTS (r
) = 0;
16123 TREE_READONLY (r
) = 1;
16125 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
16130 case AT_ENCODE_EXPR
:
16132 op1
= TREE_OPERAND (t
, 0);
16133 ++cp_unevaluated_operand
;
16134 ++c_inhibit_evaluation_warnings
;
16135 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
16136 /*function_p=*/false,
16137 /*integral_constant_expression_p=*/false);
16138 --cp_unevaluated_operand
;
16139 --c_inhibit_evaluation_warnings
;
16140 RETURN (objc_build_encode_expr (op1
));
16143 case NOEXCEPT_EXPR
:
16144 op1
= TREE_OPERAND (t
, 0);
16145 ++cp_unevaluated_operand
;
16146 ++c_inhibit_evaluation_warnings
;
16147 ++cp_noexcept_operand
;
16148 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
16149 /*function_p=*/false,
16150 /*integral_constant_expression_p=*/false);
16151 --cp_unevaluated_operand
;
16152 --c_inhibit_evaluation_warnings
;
16153 --cp_noexcept_operand
;
16154 RETURN (finish_noexcept_expr (op1
, complain
));
16158 warning_sentinel
s(warn_div_by_zero
);
16159 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
16160 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
16161 tree r
= build_x_modify_expr
16162 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
16163 complain
|decltype_flag
);
16164 /* TREE_NO_WARNING must be set if either the expression was
16165 parenthesized or it uses an operator such as >>= rather
16166 than plain assignment. In the former case, it was already
16167 set and must be copied. In the latter case,
16168 build_x_modify_expr sets it and it must not be reset
16170 if (TREE_NO_WARNING (t
))
16171 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
16177 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
16178 args
, complain
, in_decl
);
16179 /* Remember that there was a reference to this entity. */
16181 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
16182 RETURN (error_mark_node
);
16183 RETURN (build_x_arrow (input_location
, op1
, complain
));
16187 tree placement
= RECUR (TREE_OPERAND (t
, 0));
16188 tree init
= RECUR (TREE_OPERAND (t
, 3));
16189 vec
<tree
, va_gc
> *placement_vec
;
16190 vec
<tree
, va_gc
> *init_vec
;
16193 if (placement
== NULL_TREE
)
16194 placement_vec
= NULL
;
16197 placement_vec
= make_tree_vector ();
16198 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
16199 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
16202 /* If there was an initializer in the original tree, but it
16203 instantiated to an empty list, then we should pass a
16204 non-NULL empty vector to tell build_new that it was an
16205 empty initializer() rather than no initializer. This can
16206 only happen when the initializer is a pack expansion whose
16207 parameter packs are of length zero. */
16208 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
16212 init_vec
= make_tree_vector ();
16213 if (init
== void_node
)
16214 gcc_assert (init_vec
!= NULL
);
16217 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
16218 vec_safe_push (init_vec
, TREE_VALUE (init
));
16222 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
16223 tree op2
= RECUR (TREE_OPERAND (t
, 2));
16224 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
16225 NEW_EXPR_USE_GLOBAL (t
),
16228 if (placement_vec
!= NULL
)
16229 release_tree_vector (placement_vec
);
16230 if (init_vec
!= NULL
)
16231 release_tree_vector (init_vec
);
16238 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16239 tree op1
= RECUR (TREE_OPERAND (t
, 1));
16240 RETURN (delete_sanity (op0
, op1
,
16241 DELETE_EXPR_USE_VEC (t
),
16242 DELETE_EXPR_USE_GLOBAL (t
),
16246 case COMPOUND_EXPR
:
16248 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
16249 complain
& ~tf_decltype
, in_decl
,
16250 /*function_p=*/false,
16251 integral_constant_expression_p
);
16252 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
16254 RECUR (TREE_OPERAND (t
, 1)),
16255 complain
|decltype_flag
));
16261 vec
<tree
, va_gc
> *call_args
;
16262 unsigned int nargs
, i
;
16267 function
= CALL_EXPR_FN (t
);
16268 /* When we parsed the expression, we determined whether or
16269 not Koenig lookup should be performed. */
16270 koenig_p
= KOENIG_LOOKUP_P (t
);
16271 if (TREE_CODE (function
) == SCOPE_REF
)
16273 qualified_p
= true;
16274 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
16276 /*address_p=*/false);
16278 else if (koenig_p
&& identifier_p (function
))
16280 /* Do nothing; calling tsubst_copy_and_build on an identifier
16281 would incorrectly perform unqualified lookup again.
16283 Note that we can also have an IDENTIFIER_NODE if the earlier
16284 unqualified lookup found a member function; in that case
16285 koenig_p will be false and we do want to do the lookup
16286 again to find the instantiated member function.
16288 FIXME but doing that causes c++/15272, so we need to stop
16289 using IDENTIFIER_NODE in that situation. */
16290 qualified_p
= false;
16294 if (TREE_CODE (function
) == COMPONENT_REF
)
16296 tree op
= TREE_OPERAND (function
, 1);
16298 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
16299 || (BASELINK_P (op
)
16300 && BASELINK_QUALIFIED_P (op
)));
16303 qualified_p
= false;
16305 if (TREE_CODE (function
) == ADDR_EXPR
16306 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
16307 /* Avoid error about taking the address of a constructor. */
16308 function
= TREE_OPERAND (function
, 0);
16310 function
= tsubst_copy_and_build (function
, args
, complain
,
16313 integral_constant_expression_p
);
16315 if (BASELINK_P (function
))
16316 qualified_p
= true;
16319 nargs
= call_expr_nargs (t
);
16320 call_args
= make_tree_vector ();
16321 for (i
= 0; i
< nargs
; ++i
)
16323 tree arg
= CALL_EXPR_ARG (t
, i
);
16325 if (!PACK_EXPANSION_P (arg
))
16326 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
16329 /* Expand the pack expansion and push each entry onto
16331 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
16332 if (TREE_CODE (arg
) == TREE_VEC
)
16334 unsigned int len
, j
;
16336 len
= TREE_VEC_LENGTH (arg
);
16337 for (j
= 0; j
< len
; ++j
)
16339 tree value
= TREE_VEC_ELT (arg
, j
);
16340 if (value
!= NULL_TREE
)
16341 value
= convert_from_reference (value
);
16342 vec_safe_push (call_args
, value
);
16347 /* A partial substitution. Add one entry. */
16348 vec_safe_push (call_args
, arg
);
16353 /* We do not perform argument-dependent lookup if normal
16354 lookup finds a non-function, in accordance with the
16355 expected resolution of DR 218. */
16357 && ((is_overloaded_fn (function
)
16358 /* If lookup found a member function, the Koenig lookup is
16359 not appropriate, even if an unqualified-name was used
16360 to denote the function. */
16361 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
16362 || identifier_p (function
))
16363 /* Only do this when substitution turns a dependent call
16364 into a non-dependent call. */
16365 && type_dependent_expression_p_push (t
)
16366 && !any_type_dependent_arguments_p (call_args
))
16367 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
16369 if (identifier_p (function
)
16370 && !any_type_dependent_arguments_p (call_args
))
16372 if (koenig_p
&& (complain
& tf_warning_or_error
))
16374 /* For backwards compatibility and good diagnostics, try
16375 the unqualified lookup again if we aren't in SFINAE
16377 tree unq
= (tsubst_copy_and_build
16378 (function
, args
, complain
, in_decl
, true,
16379 integral_constant_expression_p
));
16380 if (unq
== error_mark_node
)
16381 RETURN (error_mark_node
);
16383 if (unq
!= function
)
16386 if (INDIRECT_REF_P (fn
))
16387 fn
= TREE_OPERAND (fn
, 0);
16388 if (TREE_CODE (fn
) == COMPONENT_REF
)
16389 fn
= TREE_OPERAND (fn
, 1);
16390 if (is_overloaded_fn (fn
))
16391 fn
= get_first_fn (fn
);
16392 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
16393 "%qD was not declared in this scope, "
16394 "and no declarations were found by "
16395 "argument-dependent lookup at the point "
16396 "of instantiation", function
))
16399 /* Can't say anything more. */;
16400 else if (DECL_CLASS_SCOPE_P (fn
))
16402 location_t loc
= EXPR_LOC_OR_LOC (t
,
16405 "declarations in dependent base %qT are "
16406 "not found by unqualified lookup",
16407 DECL_CLASS_CONTEXT (fn
));
16408 if (current_class_ptr
)
16410 "use %<this->%D%> instead", function
);
16413 "use %<%T::%D%> instead",
16414 current_class_name
, function
);
16417 inform (DECL_SOURCE_LOCATION (fn
),
16418 "%qD declared here, later in the "
16419 "translation unit", fn
);
16424 if (identifier_p (function
))
16426 if (complain
& tf_error
)
16427 unqualified_name_lookup_error (function
);
16428 release_tree_vector (call_args
);
16429 RETURN (error_mark_node
);
16433 /* Remember that there was a reference to this entity. */
16434 if (DECL_P (function
)
16435 && !mark_used (function
, complain
) && !(complain
& tf_error
))
16436 RETURN (error_mark_node
);
16438 /* Put back tf_decltype for the actual call. */
16439 complain
|= decltype_flag
;
16441 if (TREE_CODE (function
) == OFFSET_REF
)
16442 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
16444 else if (TREE_CODE (function
) == COMPONENT_REF
)
16446 tree instance
= TREE_OPERAND (function
, 0);
16447 tree fn
= TREE_OPERAND (function
, 1);
16449 if (processing_template_decl
16450 && (type_dependent_expression_p (instance
)
16451 || (!BASELINK_P (fn
)
16452 && TREE_CODE (fn
) != FIELD_DECL
)
16453 || type_dependent_expression_p (fn
)
16454 || any_type_dependent_arguments_p (call_args
)))
16455 ret
= build_nt_call_vec (function
, call_args
);
16456 else if (!BASELINK_P (fn
))
16457 ret
= finish_call_expr (function
, &call_args
,
16458 /*disallow_virtual=*/false,
16459 /*koenig_p=*/false,
16462 ret
= (build_new_method_call
16464 &call_args
, NULL_TREE
,
16465 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
16470 ret
= finish_call_expr (function
, &call_args
,
16471 /*disallow_virtual=*/qualified_p
,
16475 release_tree_vector (call_args
);
16482 tree cond
= RECUR (TREE_OPERAND (t
, 0));
16483 tree folded_cond
= fold_non_dependent_expr (cond
);
16486 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
16488 if (integer_zerop (folded_cond
))
16490 ++c_inhibit_evaluation_warnings
;
16491 exp1
= RECUR (TREE_OPERAND (t
, 1));
16492 --c_inhibit_evaluation_warnings
;
16493 exp2
= RECUR (TREE_OPERAND (t
, 2));
16497 exp1
= RECUR (TREE_OPERAND (t
, 1));
16498 ++c_inhibit_evaluation_warnings
;
16499 exp2
= RECUR (TREE_OPERAND (t
, 2));
16500 --c_inhibit_evaluation_warnings
;
16502 cond
= folded_cond
;
16506 exp1
= RECUR (TREE_OPERAND (t
, 1));
16507 exp2
= RECUR (TREE_OPERAND (t
, 2));
16510 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
16511 cond
, exp1
, exp2
, complain
));
16514 case PSEUDO_DTOR_EXPR
:
16516 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16517 tree op1
= RECUR (TREE_OPERAND (t
, 1));
16518 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
16519 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
16525 tree purpose
, value
, chain
;
16527 if (t
== void_list_node
)
16530 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
16531 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
16533 /* We have pack expansions, so expand those and
16534 create a new list out of it. */
16535 tree purposevec
= NULL_TREE
;
16536 tree valuevec
= NULL_TREE
;
16540 /* Expand the argument expressions. */
16541 if (TREE_PURPOSE (t
))
16542 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
16543 complain
, in_decl
);
16544 if (TREE_VALUE (t
))
16545 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
16546 complain
, in_decl
);
16548 /* Build the rest of the list. */
16549 chain
= TREE_CHAIN (t
);
16550 if (chain
&& chain
!= void_type_node
)
16551 chain
= RECUR (chain
);
16553 /* Determine the number of arguments. */
16554 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
16556 len
= TREE_VEC_LENGTH (purposevec
);
16557 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
16559 else if (TREE_CODE (valuevec
) == TREE_VEC
)
16560 len
= TREE_VEC_LENGTH (valuevec
);
16563 /* Since we only performed a partial substitution into
16564 the argument pack, we only RETURN (a single list
16566 if (purposevec
== TREE_PURPOSE (t
)
16567 && valuevec
== TREE_VALUE (t
)
16568 && chain
== TREE_CHAIN (t
))
16571 RETURN (tree_cons (purposevec
, valuevec
, chain
));
16574 /* Convert the argument vectors into a TREE_LIST */
16578 /* Grab the Ith values. */
16580 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
16583 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
16586 /* Build the list (backwards). */
16587 chain
= tree_cons (purpose
, value
, chain
);
16593 purpose
= TREE_PURPOSE (t
);
16595 purpose
= RECUR (purpose
);
16596 value
= TREE_VALUE (t
);
16598 value
= RECUR (value
);
16599 chain
= TREE_CHAIN (t
);
16600 if (chain
&& chain
!= void_type_node
)
16601 chain
= RECUR (chain
);
16602 if (purpose
== TREE_PURPOSE (t
)
16603 && value
== TREE_VALUE (t
)
16604 && chain
== TREE_CHAIN (t
))
16606 RETURN (tree_cons (purpose
, value
, chain
));
16609 case COMPONENT_REF
:
16616 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
16617 args
, complain
, in_decl
);
16618 /* Remember that there was a reference to this entity. */
16619 if (DECL_P (object
)
16620 && !mark_used (object
, complain
) && !(complain
& tf_error
))
16621 RETURN (error_mark_node
);
16622 object_type
= TREE_TYPE (object
);
16624 member
= TREE_OPERAND (t
, 1);
16625 if (BASELINK_P (member
))
16626 member
= tsubst_baselink (member
,
16627 non_reference (TREE_TYPE (object
)),
16628 args
, complain
, in_decl
);
16630 member
= tsubst_copy (member
, args
, complain
, in_decl
);
16631 if (member
== error_mark_node
)
16632 RETURN (error_mark_node
);
16634 if (type_dependent_expression_p (object
))
16635 /* We can't do much here. */;
16636 else if (!CLASS_TYPE_P (object_type
))
16638 if (scalarish_type_p (object_type
))
16640 tree s
= NULL_TREE
;
16641 tree dtor
= member
;
16643 if (TREE_CODE (dtor
) == SCOPE_REF
)
16645 s
= TREE_OPERAND (dtor
, 0);
16646 dtor
= TREE_OPERAND (dtor
, 1);
16648 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
16650 dtor
= TREE_OPERAND (dtor
, 0);
16652 RETURN (finish_pseudo_destructor_expr
16653 (object
, s
, dtor
, input_location
));
16657 else if (TREE_CODE (member
) == SCOPE_REF
16658 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
16660 /* Lookup the template functions now that we know what the
16662 tree scope
= TREE_OPERAND (member
, 0);
16663 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
16664 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
16665 member
= lookup_qualified_name (scope
, tmpl
,
16666 /*is_type_p=*/false,
16667 /*complain=*/false);
16668 if (BASELINK_P (member
))
16670 BASELINK_FUNCTIONS (member
)
16671 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
16673 member
= (adjust_result_of_qualified_name_lookup
16674 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
16679 qualified_name_lookup_error (scope
, tmpl
, member
,
16681 RETURN (error_mark_node
);
16684 else if (TREE_CODE (member
) == SCOPE_REF
16685 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
16686 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
16688 if (complain
& tf_error
)
16690 if (TYPE_P (TREE_OPERAND (member
, 0)))
16691 error ("%qT is not a class or namespace",
16692 TREE_OPERAND (member
, 0));
16694 error ("%qD is not a class or namespace",
16695 TREE_OPERAND (member
, 0));
16697 RETURN (error_mark_node
);
16699 else if (TREE_CODE (member
) == FIELD_DECL
)
16701 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
16702 if (TREE_CODE (r
) == COMPONENT_REF
)
16703 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
16707 r
= finish_class_member_access_expr (object
, member
,
16708 /*template_p=*/false,
16710 if (TREE_CODE (r
) == COMPONENT_REF
)
16711 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
16716 RETURN (build_throw
16717 (RECUR (TREE_OPERAND (t
, 0))));
16721 vec
<constructor_elt
, va_gc
> *n
;
16722 constructor_elt
*ce
;
16723 unsigned HOST_WIDE_INT idx
;
16724 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16725 bool process_index_p
;
16727 bool need_copy_p
= false;
16730 if (type
== error_mark_node
)
16731 RETURN (error_mark_node
);
16733 /* digest_init will do the wrong thing if we let it. */
16734 if (type
&& TYPE_PTRMEMFUNC_P (type
))
16737 /* We do not want to process the index of aggregate
16738 initializers as they are identifier nodes which will be
16739 looked up by digest_init. */
16740 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
16742 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
16743 newlen
= vec_safe_length (n
);
16744 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
16746 if (ce
->index
&& process_index_p
16747 /* An identifier index is looked up in the type
16748 being initialized, not the current scope. */
16749 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
16750 ce
->index
= RECUR (ce
->index
);
16752 if (PACK_EXPANSION_P (ce
->value
))
16754 /* Substitute into the pack expansion. */
16755 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
16758 if (ce
->value
== error_mark_node
16759 || PACK_EXPANSION_P (ce
->value
))
16761 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
16762 /* Just move the argument into place. */
16763 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
16766 /* Update the length of the final CONSTRUCTOR
16767 arguments vector, and note that we will need to
16769 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
16770 need_copy_p
= true;
16774 ce
->value
= RECUR (ce
->value
);
16779 vec
<constructor_elt
, va_gc
> *old_n
= n
;
16781 vec_alloc (n
, newlen
);
16782 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
16784 if (TREE_CODE (ce
->value
) == TREE_VEC
)
16786 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
16787 for (i
= 0; i
< len
; ++i
)
16788 CONSTRUCTOR_APPEND_ELT (n
, 0,
16789 TREE_VEC_ELT (ce
->value
, i
));
16792 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
16796 r
= build_constructor (init_list_type_node
, n
);
16797 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
16799 if (TREE_HAS_CONSTRUCTOR (t
))
16800 RETURN (finish_compound_literal (type
, r
, complain
));
16802 TREE_TYPE (r
) = type
;
16808 tree operand_0
= TREE_OPERAND (t
, 0);
16809 if (TYPE_P (operand_0
))
16811 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
16812 RETURN (get_typeid (operand_0
, complain
));
16816 operand_0
= RECUR (operand_0
);
16817 RETURN (build_typeid (operand_0
, complain
));
16824 else if (DECL_PACK_P (t
))
16826 /* We don't build decls for an instantiation of a
16827 variadic capture proxy, we instantiate the elements
16829 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
16830 return RECUR (DECL_VALUE_EXPR (t
));
16836 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
16837 /* ??? We're doing a subset of finish_id_expression here. */
16839 && !processing_template_decl
16840 && !cp_unevaluated_operand
16841 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
16842 && CP_DECL_THREAD_LOCAL_P (r
))
16844 if (tree wrap
= get_tls_wrapper_fn (r
))
16845 /* Replace an evaluated use of the thread_local variable with
16846 a call to its wrapper. */
16847 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
16849 else if (outer_automatic_var_p (r
))
16851 r
= process_outer_var_ref (r
, complain
);
16852 if (is_capture_proxy (r
))
16853 register_local_specialization (r
, t
);
16856 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
16857 /* If the original type was a reference, we'll be wrapped in
16858 the appropriate INDIRECT_REF. */
16859 r
= convert_from_reference (r
);
16865 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16866 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
16867 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
16870 case OFFSETOF_EXPR
:
16871 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0)),
16872 EXPR_LOCATION (t
)));
16876 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
16877 complain
, in_decl
);
16879 tree type2
= TRAIT_EXPR_TYPE2 (t
);
16880 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
16881 type2
= RECUR (type2
);
16883 type2
= tsubst (type2
, args
, complain
, in_decl
);
16885 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
16890 tree old_stmt_expr
= cur_stmt_expr
;
16891 tree stmt_expr
= begin_stmt_expr ();
16893 cur_stmt_expr
= stmt_expr
;
16894 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
16895 integral_constant_expression_p
);
16896 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
16897 cur_stmt_expr
= old_stmt_expr
;
16899 /* If the resulting list of expression statement is empty,
16900 fold it further into void_node. */
16901 if (empty_expr_stmt_p (stmt_expr
))
16902 stmt_expr
= void_node
;
16904 RETURN (stmt_expr
);
16909 tree r
= build_lambda_expr ();
16911 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
16912 LAMBDA_EXPR_CLOSURE (r
) = type
;
16913 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
16915 LAMBDA_EXPR_LOCATION (r
)
16916 = LAMBDA_EXPR_LOCATION (t
);
16917 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
16918 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
16919 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
16920 LAMBDA_EXPR_DISCRIMINATOR (r
)
16921 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
16922 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
16924 /* No substitution needed. */;
16925 else if (VAR_OR_FUNCTION_DECL_P (scope
))
16926 /* For a function or variable scope, we want to use tsubst so that we
16927 don't complain about referring to an auto before deduction. */
16928 scope
= tsubst (scope
, args
, complain
, in_decl
);
16929 else if (TREE_CODE (scope
) == PARM_DECL
)
16931 /* Look up the parameter we want directly, as tsubst_copy
16932 doesn't do what we need. */
16933 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
16934 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
16935 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
16936 parm
= DECL_CHAIN (parm
);
16938 /* FIXME Work around the parm not having DECL_CONTEXT set. */
16939 if (DECL_CONTEXT (scope
) == NULL_TREE
)
16940 DECL_CONTEXT (scope
) = fn
;
16942 else if (TREE_CODE (scope
) == FIELD_DECL
)
16943 /* For a field, use tsubst_copy so that we look up the existing field
16944 rather than build a new one. */
16945 scope
= RECUR (scope
);
16947 gcc_unreachable ();
16948 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
16949 LAMBDA_EXPR_RETURN_TYPE (r
)
16950 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
16952 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
16953 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
16955 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
16956 determine_visibility (TYPE_NAME (type
));
16957 /* Now that we know visibility, instantiate the type so we have a
16958 declaration of the op() for later calls to lambda_function. */
16959 complete_type (type
);
16961 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
16963 insert_pending_capture_proxies ();
16965 RETURN (build_lambda_object (r
));
16969 /* We can get here for a constant initializer of non-dependent type.
16970 FIXME stop folding in cp_parser_initializer_clause. */
16972 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
16977 case TRANSACTION_EXPR
:
16978 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
16979 integral_constant_expression_p
));
16982 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
16984 case VEC_PERM_EXPR
:
16986 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16987 tree op1
= RECUR (TREE_OPERAND (t
, 1));
16988 tree op2
= RECUR (TREE_OPERAND (t
, 2));
16989 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
16993 case REQUIRES_EXPR
:
16994 RETURN (tsubst_requires_expr (t
, args
, complain
, in_decl
));
16997 /* Handle Objective-C++ constructs, if appropriate. */
17000 = objcp_tsubst_copy_and_build (t
, args
, complain
,
17001 in_decl
, /*function_p=*/false);
17005 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
17011 input_location
= loc
;
17015 /* Verify that the instantiated ARGS are valid. For type arguments,
17016 make sure that the type's linkage is ok. For non-type arguments,
17017 make sure they are constants if they are integral or enumerations.
17018 Emit an error under control of COMPLAIN, and return TRUE on error. */
17021 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
17023 if (dependent_template_arg_p (t
))
17025 if (ARGUMENT_PACK_P (t
))
17027 tree vec
= ARGUMENT_PACK_ARGS (t
);
17028 int len
= TREE_VEC_LENGTH (vec
);
17029 bool result
= false;
17032 for (i
= 0; i
< len
; ++i
)
17033 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
17037 else if (TYPE_P (t
))
17039 /* [basic.link]: A name with no linkage (notably, the name
17040 of a class or enumeration declared in a local scope)
17041 shall not be used to declare an entity with linkage.
17042 This implies that names with no linkage cannot be used as
17045 DR 757 relaxes this restriction for C++0x. */
17046 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
17047 : no_linkage_check (t
, /*relaxed_p=*/false));
17051 /* DR 488 makes use of a type with no linkage cause
17052 type deduction to fail. */
17053 if (complain
& tf_error
)
17055 if (TYPE_ANONYMOUS_P (nt
))
17056 error ("%qT is/uses anonymous type", t
);
17058 error ("template argument for %qD uses local type %qT",
17063 /* In order to avoid all sorts of complications, we do not
17064 allow variably-modified types as template arguments. */
17065 else if (variably_modified_type_p (t
, NULL_TREE
))
17067 if (complain
& tf_error
)
17068 error ("%qT is a variably modified type", t
);
17072 /* Class template and alias template arguments should be OK. */
17073 else if (DECL_TYPE_TEMPLATE_P (t
))
17075 /* A non-type argument of integral or enumerated type must be a
17077 else if (TREE_TYPE (t
)
17078 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
17079 && !REFERENCE_REF_P (t
)
17080 && !TREE_CONSTANT (t
))
17082 if (complain
& tf_error
)
17083 error ("integral expression %qE is not constant", t
);
17090 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
17092 int ix
, len
= DECL_NTPARMS (tmpl
);
17093 bool result
= false;
17095 for (ix
= 0; ix
!= len
; ix
++)
17097 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
17100 if (result
&& (complain
& tf_error
))
17101 error (" trying to instantiate %qD", tmpl
);
17105 /* We're out of SFINAE context now, so generate diagnostics for the access
17106 errors we saw earlier when instantiating D from TMPL and ARGS. */
17109 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
17111 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
17112 tree type
= TREE_TYPE (pattern
);
17113 location_t loc
= input_location
;
17115 push_access_scope (d
);
17116 push_deferring_access_checks (dk_no_deferred
);
17117 input_location
= DECL_SOURCE_LOCATION (pattern
);
17118 tsubst (type
, args
, tf_warning_or_error
, d
);
17119 input_location
= loc
;
17120 pop_deferring_access_checks ();
17121 pop_access_scope (d
);
17124 /* Instantiate the indicated variable, function, or alias template TMPL with
17125 the template arguments in TARG_PTR. */
17128 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
17130 tree targ_ptr
= orig_args
;
17134 bool access_ok
= true;
17136 if (tmpl
== error_mark_node
)
17137 return error_mark_node
;
17139 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
17141 /* If this function is a clone, handle it specially. */
17142 if (DECL_CLONED_FUNCTION_P (tmpl
))
17147 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
17148 DECL_CLONED_FUNCTION. */
17149 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
17150 targ_ptr
, complain
);
17151 if (spec
== error_mark_node
)
17152 return error_mark_node
;
17154 /* Look for the clone. */
17155 FOR_EACH_CLONE (clone
, spec
)
17156 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
17158 /* We should always have found the clone by now. */
17159 gcc_unreachable ();
17163 if (targ_ptr
== error_mark_node
)
17164 return error_mark_node
;
17166 /* Check to see if we already have this specialization. */
17167 gen_tmpl
= most_general_template (tmpl
);
17168 if (tmpl
!= gen_tmpl
)
17169 /* The TMPL is a partial instantiation. To get a full set of
17170 arguments we must add the arguments used to perform the
17171 partial instantiation. */
17172 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
17175 /* It would be nice to avoid hashing here and then again in tsubst_decl,
17176 but it doesn't seem to be on the hot path. */
17177 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
17179 gcc_assert (tmpl
== gen_tmpl
17180 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
17182 || fndecl
== NULL_TREE
);
17184 if (spec
!= NULL_TREE
)
17186 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
17188 if (complain
& tf_error
)
17189 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
17190 return error_mark_node
;
17195 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
17197 return error_mark_node
;
17199 /* We are building a FUNCTION_DECL, during which the access of its
17200 parameters and return types have to be checked. However this
17201 FUNCTION_DECL which is the desired context for access checking
17202 is not built yet. We solve this chicken-and-egg problem by
17203 deferring all checks until we have the FUNCTION_DECL. */
17204 push_deferring_access_checks (dk_deferred
);
17206 /* Instantiation of the function happens in the context of the function
17207 template, not the context of the overload resolution we're doing. */
17208 push_to_top_level ();
17209 /* If there are dependent arguments, e.g. because we're doing partial
17210 ordering, make sure processing_template_decl stays set. */
17211 if (uses_template_parms (targ_ptr
))
17212 ++processing_template_decl
;
17213 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
17215 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
17216 complain
, gen_tmpl
, true);
17217 push_nested_class (ctx
);
17220 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
17222 if (VAR_P (pattern
))
17224 /* We need to determine if we're using a partial or explicit
17225 specialization now, because the type of the variable could be
17227 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
17228 tree elt
= most_specialized_partial_spec (tid
, complain
);
17229 if (elt
== error_mark_node
)
17230 pattern
= error_mark_node
;
17233 tmpl
= TREE_VALUE (elt
);
17234 pattern
= DECL_TEMPLATE_RESULT (tmpl
);
17235 targ_ptr
= TREE_PURPOSE (elt
);
17239 /* Substitute template parameters to obtain the specialization. */
17240 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
17241 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
17242 pop_nested_class ();
17243 pop_from_top_level ();
17245 if (fndecl
== error_mark_node
)
17247 pop_deferring_access_checks ();
17248 return error_mark_node
;
17251 /* The DECL_TI_TEMPLATE should always be the immediate parent
17252 template, not the most general template. */
17253 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
17254 DECL_TI_ARGS (fndecl
) = targ_ptr
;
17256 /* Now we know the specialization, compute access previously
17258 push_access_scope (fndecl
);
17259 if (!perform_deferred_access_checks (complain
))
17261 pop_access_scope (fndecl
);
17262 pop_deferring_access_checks ();
17264 /* If we've just instantiated the main entry point for a function,
17265 instantiate all the alternate entry points as well. We do this
17266 by cloning the instantiation of the main entry point, not by
17267 instantiating the template clones. */
17268 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
17269 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
17273 if (!(complain
& tf_error
))
17275 /* Remember to reinstantiate when we're out of SFINAE so the user
17276 can see the errors. */
17277 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
17279 return error_mark_node
;
17284 /* Wrapper for instantiate_template_1. */
17287 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
17290 timevar_push (TV_TEMPLATE_INST
);
17291 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
17292 timevar_pop (TV_TEMPLATE_INST
);
17296 /* Instantiate the alias template TMPL with ARGS. Also push a template
17297 instantiation level, which instantiate_template doesn't do because
17298 functions and variables have sufficient context established by the
17302 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
17304 struct pending_template
*old_last_pend
= last_pending_template
;
17305 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
17306 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
17307 return error_mark_node
;
17308 tree tinst
= build_tree_list (tmpl
, args
);
17309 if (!push_tinst_level (tinst
))
17312 return error_mark_node
;
17316 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
17317 args
, tmpl
, complain
,
17318 /*require_all_args=*/true,
17319 /*use_default_args=*/true);
17321 tree r
= instantiate_template (tmpl
, args
, complain
);
17322 pop_tinst_level ();
17323 /* We can't free this if a pending_template entry or last_error_tinst_level
17324 is pointing at it. */
17325 if (last_pending_template
== old_last_pend
17326 && last_error_tinst_level
== old_error_tinst
)
17332 /* PARM is a template parameter pack for FN. Returns true iff
17333 PARM is used in a deducible way in the argument list of FN. */
17336 pack_deducible_p (tree parm
, tree fn
)
17338 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
17339 for (; t
; t
= TREE_CHAIN (t
))
17341 tree type
= TREE_VALUE (t
);
17343 if (!PACK_EXPANSION_P (type
))
17345 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
17346 packs
; packs
= TREE_CHAIN (packs
))
17347 if (template_args_equal (TREE_VALUE (packs
), parm
))
17349 /* The template parameter pack is used in a function parameter
17350 pack. If this is the end of the parameter list, the
17351 template parameter pack is deducible. */
17352 if (TREE_CHAIN (t
) == void_list_node
)
17355 /* Otherwise, not. Well, it could be deduced from
17356 a non-pack parameter, but doing so would end up with
17357 a deduction mismatch, so don't bother. */
17361 /* The template parameter pack isn't used in any function parameter
17362 packs, but it might be used deeper, e.g. tuple<Args...>. */
17366 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
17367 NARGS elements of the arguments that are being used when calling
17368 it. TARGS is a vector into which the deduced template arguments
17371 Returns either a FUNCTION_DECL for the matching specialization of FN or
17372 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
17373 true, diagnostics will be printed to explain why it failed.
17375 If FN is a conversion operator, or we are trying to produce a specific
17376 specialization, RETURN_TYPE is the return type desired.
17378 The EXPLICIT_TARGS are explicit template arguments provided via a
17381 The parameter STRICT is one of:
17384 We are deducing arguments for a function call, as in
17385 [temp.deduct.call]. If RETURN_TYPE is non-null, we are
17386 deducing arguments for a call to the result of a conversion
17387 function template, as in [over.call.object].
17390 We are deducing arguments for a conversion function, as in
17391 [temp.deduct.conv].
17394 We are deducing arguments when doing an explicit instantiation
17395 as in [temp.explicit], when determining an explicit specialization
17396 as in [temp.expl.spec], or when taking the address of a function
17397 template, as in [temp.deduct.funcaddr]. */
17400 fn_type_unification (tree fn
,
17401 tree explicit_targs
,
17404 unsigned int nargs
,
17406 unification_kind_t strict
,
17413 tree decl
= NULL_TREE
;
17414 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
17416 static int deduction_depth
;
17417 struct pending_template
*old_last_pend
= last_pending_template
;
17418 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
17419 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
17421 tree r
= error_mark_node
;
17424 complain
|= tf_decltype
;
17426 /* In C++0x, it's possible to have a function template whose type depends
17427 on itself recursively. This is most obvious with decltype, but can also
17428 occur with enumeration scope (c++/48969). So we need to catch infinite
17429 recursion and reject the substitution at deduction time; this function
17430 will return error_mark_node for any repeated substitution.
17432 This also catches excessive recursion such as when f<N> depends on
17433 f<N-1> across all integers, and returns error_mark_node for all the
17434 substitutions back up to the initial one.
17436 This is, of course, not reentrant. */
17437 if (excessive_deduction_depth
)
17438 return error_mark_node
;
17439 tinst
= build_tree_list (fn
, NULL_TREE
);
17442 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
17444 fntype
= TREE_TYPE (fn
);
17445 if (explicit_targs
)
17449 The specified template arguments must match the template
17450 parameters in kind (i.e., type, nontype, template), and there
17451 must not be more arguments than there are parameters;
17452 otherwise type deduction fails.
17454 Nontype arguments must match the types of the corresponding
17455 nontype template parameters, or must be convertible to the
17456 types of the corresponding nontype parameters as specified in
17457 _temp.arg.nontype_, otherwise type deduction fails.
17459 All references in the function type of the function template
17460 to the corresponding template parameters are replaced by the
17461 specified template argument values. If a substitution in a
17462 template parameter or in the function type of the function
17463 template results in an invalid type, type deduction fails. */
17464 int i
, len
= TREE_VEC_LENGTH (tparms
);
17465 location_t loc
= input_location
;
17466 bool incomplete
= false;
17468 /* Adjust any explicit template arguments before entering the
17469 substitution context. */
17471 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
17473 /*require_all_args=*/false,
17474 /*use_default_args=*/false));
17475 if (explicit_targs
== error_mark_node
)
17478 /* Substitute the explicit args into the function type. This is
17479 necessary so that, for instance, explicitly declared function
17480 arguments can match null pointed constants. If we were given
17481 an incomplete set of explicit args, we must not do semantic
17482 processing during substitution as we could create partial
17484 for (i
= 0; i
< len
; i
++)
17486 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
17487 bool parameter_pack
= false;
17488 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
17490 /* Dig out the actual parm. */
17491 if (TREE_CODE (parm
) == TYPE_DECL
17492 || TREE_CODE (parm
) == TEMPLATE_DECL
)
17494 parm
= TREE_TYPE (parm
);
17495 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
17497 else if (TREE_CODE (parm
) == PARM_DECL
)
17499 parm
= DECL_INITIAL (parm
);
17500 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
17503 if (!parameter_pack
&& targ
== NULL_TREE
)
17504 /* No explicit argument for this template parameter. */
17507 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
17509 /* Mark the argument pack as "incomplete". We could
17510 still deduce more arguments during unification.
17511 We remove this mark in type_unification_real. */
17514 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
17515 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
17516 = ARGUMENT_PACK_ARGS (targ
);
17519 /* We have some incomplete argument packs. */
17524 TREE_VALUE (tinst
) = explicit_targs
;
17525 if (!push_tinst_level (tinst
))
17527 excessive_deduction_depth
= true;
17530 processing_template_decl
+= incomplete
;
17531 input_location
= DECL_SOURCE_LOCATION (fn
);
17532 /* Ignore any access checks; we'll see them again in
17533 instantiate_template and they might have the wrong
17534 access path at this point. */
17535 push_deferring_access_checks (dk_deferred
);
17536 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
17537 complain
| tf_partial
, NULL_TREE
);
17538 pop_deferring_access_checks ();
17539 input_location
= loc
;
17540 processing_template_decl
-= incomplete
;
17541 pop_tinst_level ();
17543 if (fntype
== error_mark_node
)
17546 /* Place the explicitly specified arguments in TARGS. */
17547 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
17548 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
17551 /* Never do unification on the 'this' parameter. */
17552 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
17554 if (return_type
&& strict
== DEDUCE_CALL
)
17556 /* We're deducing for a call to the result of a template conversion
17557 function. The parms we really want are in return_type. */
17558 if (POINTER_TYPE_P (return_type
))
17559 return_type
= TREE_TYPE (return_type
);
17560 parms
= TYPE_ARG_TYPES (return_type
);
17562 else if (return_type
)
17566 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
17567 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
17568 new_args
[0] = return_type
;
17569 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
17574 /* We allow incomplete unification without an error message here
17575 because the standard doesn't seem to explicitly prohibit it. Our
17576 callers must be ready to deal with unification failures in any
17579 TREE_VALUE (tinst
) = targs
;
17580 /* If we aren't explaining yet, push tinst context so we can see where
17581 any errors (e.g. from class instantiations triggered by instantiation
17582 of default template arguments) come from. If we are explaining, this
17583 context is redundant. */
17584 if (!explain_p
&& !push_tinst_level (tinst
))
17586 excessive_deduction_depth
= true;
17590 /* type_unification_real will pass back any access checks from default
17591 template argument substitution. */
17592 vec
<deferred_access_check
, va_gc
> *checks
;
17595 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17596 targs
, parms
, args
, nargs
, /*subr=*/0,
17597 strict
, flags
, &checks
, explain_p
);
17599 pop_tinst_level ();
17603 /* Now that we have bindings for all of the template arguments,
17604 ensure that the arguments deduced for the template template
17605 parameters have compatible template parameter lists. We cannot
17606 check this property before we have deduced all template
17607 arguments, because the template parameter types of a template
17608 template parameter might depend on prior template parameters
17609 deduced after the template template parameter. The following
17610 ill-formed example illustrates this issue:
17612 template<typename T, template<T> class C> void f(C<5>, T);
17614 template<int N> struct X {};
17617 f(X<5>(), 5l); // error: template argument deduction fails
17620 The template parameter list of 'C' depends on the template type
17621 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
17622 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
17623 time that we deduce 'C'. */
17624 if (!template_template_parm_bindings_ok_p
17625 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
17627 unify_inconsistent_template_template_parameters (explain_p
);
17631 /* All is well so far. Now, check:
17635 When all template arguments have been deduced, all uses of
17636 template parameters in nondeduced contexts are replaced with
17637 the corresponding deduced argument values. If the
17638 substitution results in an invalid type, as described above,
17639 type deduction fails. */
17640 TREE_VALUE (tinst
) = targs
;
17641 if (!push_tinst_level (tinst
))
17643 excessive_deduction_depth
= true;
17647 /* Also collect access checks from the instantiation. */
17648 reopen_deferring_access_checks (checks
);
17650 decl
= instantiate_template (fn
, targs
, complain
);
17652 checks
= get_deferred_access_checks ();
17653 pop_deferring_access_checks ();
17655 pop_tinst_level ();
17657 if (decl
== error_mark_node
)
17660 /* Now perform any access checks encountered during substitution. */
17661 push_access_scope (decl
);
17662 ok
= perform_access_checks (checks
, complain
);
17663 pop_access_scope (decl
);
17667 /* If we're looking for an exact match, check that what we got
17668 is indeed an exact match. It might not be if some template
17669 parameters are used in non-deduced contexts. But don't check
17670 for an exact match if we have dependent template arguments;
17671 in that case we're doing partial ordering, and we already know
17672 that we have two candidates that will provide the actual type. */
17673 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
17675 tree substed
= TREE_TYPE (decl
);
17679 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
17681 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
17682 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
17683 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
17685 unify_type_mismatch (explain_p
, args
[i
],
17686 TREE_VALUE (sarg
));
17695 if (excessive_deduction_depth
)
17697 if (deduction_depth
== 0)
17698 /* Reset once we're all the way out. */
17699 excessive_deduction_depth
= false;
17702 /* We can't free this if a pending_template entry or last_error_tinst_level
17703 is pointing at it. */
17704 if (last_pending_template
== old_last_pend
17705 && last_error_tinst_level
== old_error_tinst
)
17711 /* Adjust types before performing type deduction, as described in
17712 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
17713 sections are symmetric. PARM is the type of a function parameter
17714 or the return type of the conversion function. ARG is the type of
17715 the argument passed to the call, or the type of the value
17716 initialized with the result of the conversion function.
17717 ARG_EXPR is the original argument expression, which may be null. */
17720 maybe_adjust_types_for_deduction (unification_kind_t strict
,
17733 /* Swap PARM and ARG throughout the remainder of this
17734 function; the handling is precisely symmetric since PARM
17735 will initialize ARG rather than vice versa. */
17736 std::swap (parm
, arg
);
17740 /* Core issue #873: Do the DR606 thing (see below) for these cases,
17741 too, but here handle it by stripping the reference from PARM
17742 rather than by adding it to ARG. */
17743 if (TREE_CODE (*parm
) == REFERENCE_TYPE
17744 && TYPE_REF_IS_RVALUE (*parm
)
17745 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
17746 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
17747 && TREE_CODE (*arg
) == REFERENCE_TYPE
17748 && !TYPE_REF_IS_RVALUE (*arg
))
17749 *parm
= TREE_TYPE (*parm
);
17750 /* Nothing else to do in this case. */
17754 gcc_unreachable ();
17757 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
17759 /* [temp.deduct.call]
17761 If P is not a reference type:
17763 --If A is an array type, the pointer type produced by the
17764 array-to-pointer standard conversion (_conv.array_) is
17765 used in place of A for type deduction; otherwise,
17767 --If A is a function type, the pointer type produced by
17768 the function-to-pointer standard conversion
17769 (_conv.func_) is used in place of A for type deduction;
17772 --If A is a cv-qualified type, the top level
17773 cv-qualifiers of A's type are ignored for type
17775 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
17776 *arg
= build_pointer_type (TREE_TYPE (*arg
));
17777 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
17778 *arg
= build_pointer_type (*arg
);
17780 *arg
= TYPE_MAIN_VARIANT (*arg
);
17783 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
17784 of the form T&&, where T is a template parameter, and the argument
17785 is an lvalue, T is deduced as A& */
17786 if (TREE_CODE (*parm
) == REFERENCE_TYPE
17787 && TYPE_REF_IS_RVALUE (*parm
)
17788 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
17789 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
17790 && (arg_expr
? real_lvalue_p (arg_expr
)
17791 /* try_one_overload doesn't provide an arg_expr, but
17792 functions are always lvalues. */
17793 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
17794 *arg
= build_reference_type (*arg
);
17796 /* [temp.deduct.call]
17798 If P is a cv-qualified type, the top level cv-qualifiers
17799 of P's type are ignored for type deduction. If P is a
17800 reference type, the type referred to by P is used for
17802 *parm
= TYPE_MAIN_VARIANT (*parm
);
17803 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
17805 *parm
= TREE_TYPE (*parm
);
17806 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
17809 /* DR 322. For conversion deduction, remove a reference type on parm
17810 too (which has been swapped into ARG). */
17811 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
17812 *arg
= TREE_TYPE (*arg
);
17817 /* Subroutine of unify_one_argument. PARM is a function parameter of a
17818 template which does contain any deducible template parameters; check if
17819 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
17820 unify_one_argument. */
17823 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
17824 int flags
, bool explain_p
)
17829 type
= TREE_TYPE (arg
);
17833 if (same_type_p (parm
, type
))
17834 return unify_success (explain_p
);
17836 if (strict
== DEDUCE_CONV
)
17838 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
17839 explain_p
? tf_warning_or_error
: tf_none
))
17840 return unify_success (explain_p
);
17842 else if (strict
!= DEDUCE_EXACT
)
17844 if (can_convert_arg (parm
, type
,
17845 TYPE_P (arg
) ? NULL_TREE
: arg
,
17846 flags
, explain_p
? tf_warning_or_error
: tf_none
))
17847 return unify_success (explain_p
);
17850 if (strict
== DEDUCE_EXACT
)
17851 return unify_type_mismatch (explain_p
, parm
, arg
);
17853 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
17856 static bool uses_deducible_template_parms (tree type
);
17858 /* Returns true iff the expression EXPR is one from which a template
17859 argument can be deduced. In other words, if it's an undecorated
17860 use of a template non-type parameter. */
17863 deducible_expression (tree expr
)
17865 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
17868 /* Returns true iff the array domain DOMAIN uses a template parameter in a
17869 deducible way; that is, if it has a max value of <PARM> - 1. */
17872 deducible_array_bound (tree domain
)
17874 if (domain
== NULL_TREE
)
17877 tree max
= TYPE_MAX_VALUE (domain
);
17878 if (TREE_CODE (max
) != MINUS_EXPR
)
17881 return deducible_expression (TREE_OPERAND (max
, 0));
17884 /* Returns true iff the template arguments ARGS use a template parameter
17885 in a deducible way. */
17888 deducible_template_args (tree args
)
17890 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
17893 tree elt
= TREE_VEC_ELT (args
, i
);
17894 if (ARGUMENT_PACK_P (elt
))
17895 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
17898 if (PACK_EXPANSION_P (elt
))
17899 elt
= PACK_EXPANSION_PATTERN (elt
);
17900 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
17902 else if (TYPE_P (elt
))
17903 deducible
= uses_deducible_template_parms (elt
);
17905 deducible
= deducible_expression (elt
);
17913 /* Returns true iff TYPE contains any deducible references to template
17914 parameters, as per 14.8.2.5. */
17917 uses_deducible_template_parms (tree type
)
17919 if (PACK_EXPANSION_P (type
))
17920 type
= PACK_EXPANSION_PATTERN (type
);
17927 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
17928 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17934 if (POINTER_TYPE_P (type
))
17935 return uses_deducible_template_parms (TREE_TYPE (type
));
17937 /* T[integer-constant ]
17939 if (TREE_CODE (type
) == ARRAY_TYPE
)
17940 return (uses_deducible_template_parms (TREE_TYPE (type
))
17941 || deducible_array_bound (TYPE_DOMAIN (type
)));
17953 if (TYPE_PTRMEM_P (type
))
17954 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
17955 || (uses_deducible_template_parms
17956 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
17958 /* template-name <T> (where template-name refers to a class template)
17959 template-name <i> (where template-name refers to a class template) */
17960 if (CLASS_TYPE_P (type
)
17961 && CLASSTYPE_TEMPLATE_INFO (type
)
17962 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
17963 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
17964 (CLASSTYPE_TI_ARGS (type
)));
17969 if (TREE_CODE (type
) == FUNCTION_TYPE
17970 || TREE_CODE (type
) == METHOD_TYPE
)
17972 if (uses_deducible_template_parms (TREE_TYPE (type
)))
17974 tree parm
= TYPE_ARG_TYPES (type
);
17975 if (TREE_CODE (type
) == METHOD_TYPE
)
17976 parm
= TREE_CHAIN (parm
);
17977 for (; parm
; parm
= TREE_CHAIN (parm
))
17978 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
17985 /* Subroutine of type_unification_real and unify_pack_expansion to
17986 handle unification of a single P/A pair. Parameters are as
17987 for those functions. */
17990 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
17991 int subr
, unification_kind_t strict
,
17994 tree arg_expr
= NULL_TREE
;
17997 if (arg
== error_mark_node
|| parm
== error_mark_node
)
17998 return unify_invalid (explain_p
);
17999 if (arg
== unknown_type_node
)
18000 /* We can't deduce anything from this, but we might get all the
18001 template args from other function args. */
18002 return unify_success (explain_p
);
18004 /* Implicit conversions (Clause 4) will be performed on a function
18005 argument to convert it to the type of the corresponding function
18006 parameter if the parameter type contains no template-parameters that
18007 participate in template argument deduction. */
18008 if (strict
!= DEDUCE_EXACT
18009 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
18010 /* For function parameters with no deducible template parameters,
18011 just return. We'll check non-dependent conversions later. */
18012 return unify_success (explain_p
);
18017 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
18018 | UNIFY_ALLOW_MORE_CV_QUAL
18019 | UNIFY_ALLOW_DERIVED
);
18023 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
18027 arg_strict
= UNIFY_ALLOW_NONE
;
18031 gcc_unreachable ();
18034 /* We only do these transformations if this is the top-level
18035 parameter_type_list in a call or declaration matching; in other
18036 situations (nested function declarators, template argument lists) we
18037 won't be comparing a type to an expression, and we don't do any type
18043 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
18044 if (type_unknown_p (arg
))
18046 /* [temp.deduct.type] A template-argument can be
18047 deduced from a pointer to function or pointer
18048 to member function argument if the set of
18049 overloaded functions does not contain function
18050 templates and at most one of a set of
18051 overloaded functions provides a unique
18054 if (resolve_overloaded_unification
18055 (tparms
, targs
, parm
, arg
, strict
,
18056 arg_strict
, explain_p
))
18057 return unify_success (explain_p
);
18058 return unify_overload_resolution_failure (explain_p
, arg
);
18062 arg
= unlowered_expr_type (arg
);
18063 if (arg
== error_mark_node
)
18064 return unify_invalid (explain_p
);
18068 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
18071 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
18072 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
18073 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18075 /* For deduction from an init-list we need the actual list. */
18076 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
18078 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
18081 /* Most parms like fn_type_unification.
18083 If SUBR is 1, we're being called recursively (to unify the
18084 arguments of a function or method parameter of a function
18087 CHECKS is a pointer to a vector of access checks encountered while
18088 substituting default template arguments. */
18091 type_unification_real (tree tparms
,
18095 unsigned int xnargs
,
18097 unification_kind_t strict
,
18099 vec
<deferred_access_check
, va_gc
> **checks
,
18104 int ntparms
= TREE_VEC_LENGTH (tparms
);
18105 int saw_undeduced
= 0;
18108 unsigned int nargs
;
18111 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
18112 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
18113 gcc_assert (ntparms
> 0);
18115 /* Reset the number of non-defaulted template arguments contained
18117 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
18125 while (parms
&& parms
!= void_list_node
18128 parm
= TREE_VALUE (parms
);
18130 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
18131 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
18132 /* For a function parameter pack that occurs at the end of the
18133 parameter-declaration-list, the type A of each remaining
18134 argument of the call is compared with the type P of the
18135 declarator-id of the function parameter pack. */
18138 parms
= TREE_CHAIN (parms
);
18140 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
18141 /* For a function parameter pack that does not occur at the
18142 end of the parameter-declaration-list, the type of the
18143 parameter pack is a non-deduced context. */
18149 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
18155 && parms
!= void_list_node
18156 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
18158 /* Unify the remaining arguments with the pack expansion type. */
18160 tree parmvec
= make_tree_vec (1);
18162 /* Allocate a TREE_VEC and copy in all of the arguments */
18163 argvec
= make_tree_vec (nargs
- ia
);
18164 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
18165 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
18167 /* Copy the parameter into parmvec. */
18168 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
18169 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
18170 /*subr=*/subr
, explain_p
))
18173 /* Advance to the end of the list of parameters. */
18174 parms
= TREE_CHAIN (parms
);
18177 /* Fail if we've reached the end of the parm list, and more args
18178 are present, and the parm list isn't variadic. */
18179 if (ia
< nargs
&& parms
== void_list_node
)
18180 return unify_too_many_arguments (explain_p
, nargs
, ia
);
18181 /* Fail if parms are left and they don't have default values and
18182 they aren't all deduced as empty packs (c++/57397). This is
18183 consistent with sufficient_parms_p. */
18184 if (parms
&& parms
!= void_list_node
18185 && TREE_PURPOSE (parms
) == NULL_TREE
)
18187 unsigned int count
= nargs
;
18192 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
18195 p
= TREE_CHAIN (p
);
18197 while (p
&& p
!= void_list_node
);
18198 if (count
!= nargs
)
18199 return unify_too_few_arguments (explain_p
, ia
, count
,
18205 tsubst_flags_t complain
= (explain_p
18206 ? tf_warning_or_error
18209 for (i
= 0; i
< ntparms
; i
++)
18211 tree targ
= TREE_VEC_ELT (targs
, i
);
18212 tree tparm
= TREE_VEC_ELT (tparms
, i
);
18214 /* Clear the "incomplete" flags on all argument packs now so that
18215 substituting them into later default arguments works. */
18216 if (targ
&& ARGUMENT_PACK_P (targ
))
18218 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
18219 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
18222 if (targ
|| tparm
== error_mark_node
)
18224 tparm
= TREE_VALUE (tparm
);
18226 /* If this is an undeduced nontype parameter that depends on
18227 a type parameter, try another pass; its type may have been
18228 deduced from a later argument than the one from which
18229 this parameter can be deduced. */
18230 if (TREE_CODE (tparm
) == PARM_DECL
18231 && uses_template_parms (TREE_TYPE (tparm
))
18232 && saw_undeduced
< 2)
18238 /* Core issue #226 (C++0x) [temp.deduct]:
18240 If a template argument has not been deduced, its
18241 default template argument, if any, is used.
18243 When we are in C++98 mode, TREE_PURPOSE will either
18244 be NULL_TREE or ERROR_MARK_NODE, so we do not need
18245 to explicitly check cxx_dialect here. */
18246 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
18247 /* OK, there is a default argument. Wait until after the
18248 conversion check to do substitution. */
18251 /* If the type parameter is a parameter pack, then it will
18252 be deduced to an empty parameter pack. */
18253 if (template_parameter_pack_p (tparm
))
18257 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
18259 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
18260 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
18261 TREE_CONSTANT (arg
) = 1;
18264 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
18266 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
18268 TREE_VEC_ELT (targs
, i
) = arg
;
18272 return unify_parameter_deduction_failure (explain_p
, tparm
);
18275 /* DR 1391: All parameters have args, now check non-dependent parms for
18277 if (saw_undeduced
< 2)
18278 for (ia
= 0, parms
= xparms
, args
= xargs
, nargs
= xnargs
;
18279 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
18281 parm
= TREE_VALUE (parms
);
18283 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
18284 && (!TREE_CHAIN (parms
)
18285 || TREE_CHAIN (parms
) == void_list_node
))
18286 /* For a function parameter pack that occurs at the end of the
18287 parameter-declaration-list, the type A of each remaining
18288 argument of the call is compared with the type P of the
18289 declarator-id of the function parameter pack. */
18292 parms
= TREE_CHAIN (parms
);
18294 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
18295 /* For a function parameter pack that does not occur at the
18296 end of the parameter-declaration-list, the type of the
18297 parameter pack is a non-deduced context. */
18303 if (uses_template_parms (parm
))
18305 if (check_non_deducible_conversion (parm
, arg
, strict
, flags
,
18310 /* Now substitute into the default template arguments. */
18311 for (i
= 0; i
< ntparms
; i
++)
18313 tree targ
= TREE_VEC_ELT (targs
, i
);
18314 tree tparm
= TREE_VEC_ELT (tparms
, i
);
18316 if (targ
|| tparm
== error_mark_node
)
18318 tree parm
= TREE_VALUE (tparm
);
18320 if (TREE_CODE (parm
) == PARM_DECL
18321 && uses_template_parms (TREE_TYPE (parm
))
18322 && saw_undeduced
< 2)
18325 tree arg
= TREE_PURPOSE (tparm
);
18326 reopen_deferring_access_checks (*checks
);
18327 location_t save_loc
= input_location
;
18329 input_location
= DECL_SOURCE_LOCATION (parm
);
18330 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
18331 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
18333 input_location
= save_loc
;
18334 *checks
= get_deferred_access_checks ();
18335 pop_deferring_access_checks ();
18336 if (arg
== error_mark_node
)
18340 TREE_VEC_ELT (targs
, i
) = arg
;
18341 /* The position of the first default template argument,
18342 is also the number of non-defaulted arguments in TARGS.
18344 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
18345 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
18350 if (saw_undeduced
++ == 1)
18354 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
18355 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
18357 return unify_success (explain_p
);
18360 /* Subroutine of type_unification_real. Args are like the variables
18361 at the call site. ARG is an overloaded function (or template-id);
18362 we try deducing template args from each of the overloads, and if
18363 only one succeeds, we go with that. Modifies TARGS and returns
18364 true on success. */
18367 resolve_overloaded_unification (tree tparms
,
18371 unification_kind_t strict
,
18375 tree tempargs
= copy_node (targs
);
18377 tree goodfn
= NULL_TREE
;
18380 if (TREE_CODE (arg
) == ADDR_EXPR
)
18382 arg
= TREE_OPERAND (arg
, 0);
18388 if (TREE_CODE (arg
) == COMPONENT_REF
)
18389 /* Handle `&x' where `x' is some static or non-static member
18391 arg
= TREE_OPERAND (arg
, 1);
18393 if (TREE_CODE (arg
) == OFFSET_REF
)
18394 arg
= TREE_OPERAND (arg
, 1);
18396 /* Strip baselink information. */
18397 if (BASELINK_P (arg
))
18398 arg
= BASELINK_FUNCTIONS (arg
);
18400 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
18402 /* If we got some explicit template args, we need to plug them into
18403 the affected templates before we try to unify, in case the
18404 explicit args will completely resolve the templates in question. */
18407 tree expl_subargs
= TREE_OPERAND (arg
, 1);
18408 arg
= TREE_OPERAND (arg
, 0);
18410 for (; arg
; arg
= OVL_NEXT (arg
))
18412 tree fn
= OVL_CURRENT (arg
);
18413 tree subargs
, elem
;
18415 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
18418 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
18419 expl_subargs
, NULL_TREE
, tf_none
,
18420 /*require_all_args=*/true,
18421 /*use_default_args=*/true);
18422 if (subargs
!= error_mark_node
18423 && !any_dependent_template_arguments_p (subargs
))
18425 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
18426 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
18427 elem
, strict
, sub_strict
, addr_p
, explain_p
)
18428 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
18437 /* If no templates (or more than one) are fully resolved by the
18438 explicit arguments, this template-id is a non-deduced context; it
18439 could still be OK if we deduce all template arguments for the
18440 enclosing call through other arguments. */
18444 else if (TREE_CODE (arg
) != OVERLOAD
18445 && TREE_CODE (arg
) != FUNCTION_DECL
)
18446 /* If ARG is, for example, "(0, &f)" then its type will be unknown
18447 -- but the deduction does not succeed because the expression is
18448 not just the function on its own. */
18451 for (; arg
; arg
= OVL_NEXT (arg
))
18452 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
18453 TREE_TYPE (OVL_CURRENT (arg
)),
18454 strict
, sub_strict
, addr_p
, explain_p
)
18455 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
18457 goodfn
= OVL_CURRENT (arg
);
18461 /* [temp.deduct.type] A template-argument can be deduced from a pointer
18462 to function or pointer to member function argument if the set of
18463 overloaded functions does not contain function templates and at most
18464 one of a set of overloaded functions provides a unique match.
18466 So if we found multiple possibilities, we return success but don't
18467 deduce anything. */
18471 int i
= TREE_VEC_LENGTH (targs
);
18473 if (TREE_VEC_ELT (tempargs
, i
))
18475 tree old
= TREE_VEC_ELT (targs
, i
);
18476 tree new_
= TREE_VEC_ELT (tempargs
, i
);
18477 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
18478 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
18479 /* Don't forget explicit template arguments in a pack. */
18480 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
18481 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
18482 TREE_VEC_ELT (targs
, i
) = new_
;
18491 /* Core DR 115: In contexts where deduction is done and fails, or in
18492 contexts where deduction is not done, if a template argument list is
18493 specified and it, along with any default template arguments, identifies
18494 a single function template specialization, then the template-id is an
18495 lvalue for the function template specialization. */
18498 resolve_nondeduced_context (tree orig_expr
)
18500 tree expr
, offset
, baselink
;
18503 if (!type_unknown_p (orig_expr
))
18508 offset
= NULL_TREE
;
18509 baselink
= NULL_TREE
;
18511 if (TREE_CODE (expr
) == ADDR_EXPR
)
18513 expr
= TREE_OPERAND (expr
, 0);
18516 if (TREE_CODE (expr
) == OFFSET_REF
)
18519 expr
= TREE_OPERAND (expr
, 1);
18521 if (BASELINK_P (expr
))
18524 expr
= BASELINK_FUNCTIONS (expr
);
18527 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
18530 tree goodfn
= NULL_TREE
;
18532 /* If we got some explicit template args, we need to plug them into
18533 the affected templates before we try to unify, in case the
18534 explicit args will completely resolve the templates in question. */
18536 tree expl_subargs
= TREE_OPERAND (expr
, 1);
18537 tree arg
= TREE_OPERAND (expr
, 0);
18538 tree badfn
= NULL_TREE
;
18539 tree badargs
= NULL_TREE
;
18541 for (; arg
; arg
= OVL_NEXT (arg
))
18543 tree fn
= OVL_CURRENT (arg
);
18544 tree subargs
, elem
;
18546 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
18549 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
18550 expl_subargs
, NULL_TREE
, tf_none
,
18551 /*require_all_args=*/true,
18552 /*use_default_args=*/true);
18553 if (subargs
!= error_mark_node
18554 && !any_dependent_template_arguments_p (subargs
))
18556 elem
= instantiate_template (fn
, subargs
, tf_none
);
18557 if (elem
== error_mark_node
)
18562 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
18571 mark_used (goodfn
);
18574 expr
= build_baselink (BASELINK_BINFO (baselink
),
18575 BASELINK_ACCESS_BINFO (baselink
),
18576 expr
, BASELINK_OPTYPE (baselink
));
18580 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
18581 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
18584 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
18587 else if (good
== 0 && badargs
)
18588 /* There were no good options and at least one bad one, so let the
18589 user know what the problem is. */
18590 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
18595 /* Subroutine of resolve_overloaded_unification; does deduction for a single
18596 overload. Fills TARGS with any deduced arguments, or error_mark_node if
18597 different overloads deduce different arguments for a given parm.
18598 ADDR_P is true if the expression for which deduction is being
18599 performed was of the form "& fn" rather than simply "fn".
18601 Returns 1 on success. */
18604 try_one_overload (tree tparms
,
18609 unification_kind_t strict
,
18618 if (arg
== error_mark_node
)
18621 /* [temp.deduct.type] A template-argument can be deduced from a pointer
18622 to function or pointer to member function argument if the set of
18623 overloaded functions does not contain function templates and at most
18624 one of a set of overloaded functions provides a unique match.
18626 So if this is a template, just return success. */
18628 if (uses_template_parms (arg
))
18631 if (TREE_CODE (arg
) == METHOD_TYPE
)
18632 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
18634 arg
= build_pointer_type (arg
);
18636 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
18638 /* We don't copy orig_targs for this because if we have already deduced
18639 some template args from previous args, unify would complain when we
18640 try to deduce a template parameter for the same argument, even though
18641 there isn't really a conflict. */
18642 nargs
= TREE_VEC_LENGTH (targs
);
18643 tempargs
= make_tree_vec (nargs
);
18645 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
18648 /* First make sure we didn't deduce anything that conflicts with
18649 explicitly specified args. */
18650 for (i
= nargs
; i
--; )
18652 tree elt
= TREE_VEC_ELT (tempargs
, i
);
18653 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
18657 else if (uses_template_parms (elt
))
18658 /* Since we're unifying against ourselves, we will fill in
18659 template args used in the function parm list with our own
18660 template parms. Discard them. */
18661 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
18662 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
18666 for (i
= nargs
; i
--; )
18668 tree elt
= TREE_VEC_ELT (tempargs
, i
);
18671 TREE_VEC_ELT (targs
, i
) = elt
;
18677 /* PARM is a template class (perhaps with unbound template
18678 parameters). ARG is a fully instantiated type. If ARG can be
18679 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
18680 TARGS are as for unify. */
18683 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
18686 tree copy_of_targs
;
18688 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
18689 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
18690 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
18693 /* We need to make a new template argument vector for the call to
18694 unify. If we used TARGS, we'd clutter it up with the result of
18695 the attempted unification, even if this class didn't work out.
18696 We also don't want to commit ourselves to all the unifications
18697 we've already done, since unification is supposed to be done on
18698 an argument-by-argument basis. In other words, consider the
18699 following pathological case:
18701 template <int I, int J, int K>
18704 template <int I, int J>
18705 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
18707 template <int I, int J, int K>
18708 void f(S<I, J, K>, S<I, I, I>);
18717 Now, by the time we consider the unification involving `s2', we
18718 already know that we must have `f<0, 0, 0>'. But, even though
18719 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
18720 because there are two ways to unify base classes of S<0, 1, 2>
18721 with S<I, I, I>. If we kept the already deduced knowledge, we
18722 would reject the possibility I=1. */
18723 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
18725 /* If unification failed, we're done. */
18726 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
18727 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
18733 /* Given a template type PARM and a class type ARG, find the unique
18734 base type in ARG that is an instance of PARM. We do not examine
18735 ARG itself; only its base-classes. If there is not exactly one
18736 appropriate base class, return NULL_TREE. PARM may be the type of
18737 a partial specialization, as well as a plain template type. Used
18740 static enum template_base_result
18741 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
18742 bool explain_p
, tree
*result
)
18744 tree rval
= NULL_TREE
;
18747 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
18749 binfo
= TYPE_BINFO (complete_type (arg
));
18752 /* The type could not be completed. */
18753 *result
= NULL_TREE
;
18754 return tbr_incomplete_type
;
18757 /* Walk in inheritance graph order. The search order is not
18758 important, and this avoids multiple walks of virtual bases. */
18759 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
18761 tree r
= try_class_unification (tparms
, targs
, parm
,
18762 BINFO_TYPE (binfo
), explain_p
);
18766 /* If there is more than one satisfactory baseclass, then:
18770 If they yield more than one possible deduced A, the type
18774 if (rval
&& !same_type_p (r
, rval
))
18776 *result
= NULL_TREE
;
18777 return tbr_ambiguous_baseclass
;
18785 return tbr_success
;
18788 /* Returns the level of DECL, which declares a template parameter. */
18791 template_decl_level (tree decl
)
18793 switch (TREE_CODE (decl
))
18796 case TEMPLATE_DECL
:
18797 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
18800 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
18803 gcc_unreachable ();
18808 /* Decide whether ARG can be unified with PARM, considering only the
18809 cv-qualifiers of each type, given STRICT as documented for unify.
18810 Returns nonzero iff the unification is OK on that basis. */
18813 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
18815 int arg_quals
= cp_type_quals (arg
);
18816 int parm_quals
= cp_type_quals (parm
);
18818 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
18819 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
18821 /* Although a CVR qualifier is ignored when being applied to a
18822 substituted template parameter ([8.3.2]/1 for example), that
18823 does not allow us to unify "const T" with "int&" because both
18824 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
18825 It is ok when we're allowing additional CV qualifiers
18826 at the outer level [14.8.2.1]/3,1st bullet. */
18827 if ((TREE_CODE (arg
) == REFERENCE_TYPE
18828 || TREE_CODE (arg
) == FUNCTION_TYPE
18829 || TREE_CODE (arg
) == METHOD_TYPE
)
18830 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
18833 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
18834 && (parm_quals
& TYPE_QUAL_RESTRICT
))
18838 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
18839 && (arg_quals
& parm_quals
) != parm_quals
)
18842 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
18843 && (parm_quals
& arg_quals
) != arg_quals
)
18849 /* Determines the LEVEL and INDEX for the template parameter PARM. */
18851 template_parm_level_and_index (tree parm
, int* level
, int* index
)
18853 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
18854 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
18855 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
18857 *index
= TEMPLATE_TYPE_IDX (parm
);
18858 *level
= TEMPLATE_TYPE_LEVEL (parm
);
18862 *index
= TEMPLATE_PARM_IDX (parm
);
18863 *level
= TEMPLATE_PARM_LEVEL (parm
);
18867 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
18869 if (unify (TP, TA, P, A, S, EP)) \
18873 /* Unifies the remaining arguments in PACKED_ARGS with the pack
18874 expansion at the end of PACKED_PARMS. Returns 0 if the type
18875 deduction succeeds, 1 otherwise. STRICT is the same as in
18876 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
18877 call argument list. We'll need to adjust the arguments to make them
18878 types. SUBR tells us if this is from a recursive call to
18879 type_unification_real, or for comparing two template argument
18883 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
18884 tree packed_args
, unification_kind_t strict
,
18885 bool subr
, bool explain_p
)
18888 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
18889 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
18890 tree pack
, packs
= NULL_TREE
;
18891 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
18893 packed_args
= expand_template_argument_pack (packed_args
);
18895 int len
= TREE_VEC_LENGTH (packed_args
);
18897 /* Determine the parameter packs we will be deducing from the
18898 pattern, and record their current deductions. */
18899 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
18900 pack
; pack
= TREE_CHAIN (pack
))
18902 tree parm_pack
= TREE_VALUE (pack
);
18905 /* Determine the index and level of this parameter pack. */
18906 template_parm_level_and_index (parm_pack
, &level
, &idx
);
18908 /* Keep track of the parameter packs and their corresponding
18910 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
18911 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
18914 /* Loop through all of the arguments that have not yet been
18915 unified and unify each with the pattern. */
18916 for (i
= start
; i
< len
; i
++)
18919 bool any_explicit
= false;
18920 tree arg
= TREE_VEC_ELT (packed_args
, i
);
18922 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
18923 or the element of its argument pack at the current index if
18924 this argument was explicitly specified. */
18925 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
18929 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
18932 if (TREE_VALUE (pack
)
18933 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
18934 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
18936 any_explicit
= true;
18937 arg
= TREE_VEC_ELT (pargs
, i
- start
);
18939 TMPL_ARG (targs
, level
, idx
) = arg
;
18942 /* If we had explicit template arguments, substitute them into the
18943 pattern before deduction. */
18946 /* Some arguments might still be unspecified or dependent. */
18948 ++processing_template_decl
;
18949 dependent
= any_dependent_template_arguments_p (targs
);
18951 --processing_template_decl
;
18952 parm
= tsubst (pattern
, targs
,
18953 explain_p
? tf_warning_or_error
: tf_none
,
18956 --processing_template_decl
;
18957 if (parm
== error_mark_node
)
18963 /* Unify the pattern with the current argument. */
18964 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
18968 /* For each parameter pack, collect the deduced value. */
18969 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
18972 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
18974 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
18975 TMPL_ARG (targs
, level
, idx
);
18979 /* Verify that the results of unification with the parameter packs
18980 produce results consistent with what we've seen before, and make
18981 the deduced argument packs available. */
18982 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
18984 tree old_pack
= TREE_VALUE (pack
);
18985 tree new_args
= TREE_TYPE (pack
);
18986 int i
, len
= TREE_VEC_LENGTH (new_args
);
18988 bool nondeduced_p
= false;
18990 /* By default keep the original deduced argument pack.
18991 If necessary, more specific code is going to update the
18992 resulting deduced argument later down in this function. */
18993 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
18994 TMPL_ARG (targs
, level
, idx
) = old_pack
;
18996 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
18997 actually deduce anything. */
18998 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
18999 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
19000 nondeduced_p
= true;
19004 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
19006 /* If we had fewer function args than explicit template args,
19007 just use the explicits. */
19008 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
19009 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
19010 if (len
< explicit_len
)
19011 new_args
= explicit_args
;
19017 /* Build the deduced *_ARGUMENT_PACK. */
19018 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
19020 result
= make_node (NONTYPE_ARGUMENT_PACK
);
19021 TREE_TYPE (result
) =
19022 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
19023 TREE_CONSTANT (result
) = 1;
19026 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
19028 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
19030 /* Note the deduced argument packs for this parameter
19032 TMPL_ARG (targs
, level
, idx
) = result
;
19034 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
19035 && (ARGUMENT_PACK_ARGS (old_pack
)
19036 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
19038 /* We only had the explicitly-provided arguments before, but
19039 now we have a complete set of arguments. */
19040 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
19042 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
19043 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
19044 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
19048 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
19049 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
19051 if (!comp_template_args_with_info (old_args
, new_args
,
19052 &bad_old_arg
, &bad_new_arg
))
19053 /* Inconsistent unification of this parameter pack. */
19054 return unify_parameter_pack_inconsistent (explain_p
,
19060 return unify_success (explain_p
);
19063 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
19064 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
19065 parameters and return value are as for unify. */
19068 unify_array_domain (tree tparms
, tree targs
,
19069 tree parm_dom
, tree arg_dom
,
19077 /* Our representation of array types uses "N - 1" as the
19078 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
19079 not an integer constant. We cannot unify arbitrarily
19080 complex expressions, so we eliminate the MINUS_EXPRs
19082 parm_max
= TYPE_MAX_VALUE (parm_dom
);
19083 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
19086 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
19087 parm_max
= TREE_OPERAND (parm_max
, 0);
19089 arg_max
= TYPE_MAX_VALUE (arg_dom
);
19090 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
19093 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
19094 trying to unify the type of a variable with the type
19095 of a template parameter. For example:
19097 template <unsigned int N>
19098 void f (char (&) [N]);
19105 Here, the type of the ARG will be "int [g(i)]", and
19106 may be a SAVE_EXPR, etc. */
19107 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
19108 return unify_vla_arg (explain_p
, arg_dom
);
19109 arg_max
= TREE_OPERAND (arg_max
, 0);
19112 /* If only one of the bounds used a MINUS_EXPR, compensate
19113 by adding one to the other bound. */
19114 if (parm_cst
&& !arg_cst
)
19115 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
19119 else if (arg_cst
&& !parm_cst
)
19120 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
19125 return unify (tparms
, targs
, parm_max
, arg_max
,
19126 UNIFY_ALLOW_INTEGER
, explain_p
);
19129 /* Deduce the value of template parameters. TPARMS is the (innermost)
19130 set of template parameters to a template. TARGS is the bindings
19131 for those template parameters, as determined thus far; TARGS may
19132 include template arguments for outer levels of template parameters
19133 as well. PARM is a parameter to a template function, or a
19134 subcomponent of that parameter; ARG is the corresponding argument.
19135 This function attempts to match PARM with ARG in a manner
19136 consistent with the existing assignments in TARGS. If more values
19137 are deduced, then TARGS is updated.
19139 Returns 0 if the type deduction succeeds, 1 otherwise. The
19140 parameter STRICT is a bitwise or of the following flags:
19143 Require an exact match between PARM and ARG.
19144 UNIFY_ALLOW_MORE_CV_QUAL:
19145 Allow the deduced ARG to be more cv-qualified (by qualification
19146 conversion) than ARG.
19147 UNIFY_ALLOW_LESS_CV_QUAL:
19148 Allow the deduced ARG to be less cv-qualified than ARG.
19149 UNIFY_ALLOW_DERIVED:
19150 Allow the deduced ARG to be a template base class of ARG,
19151 or a pointer to a template base class of the type pointed to by
19153 UNIFY_ALLOW_INTEGER:
19154 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
19155 case for more information.
19156 UNIFY_ALLOW_OUTER_LEVEL:
19157 This is the outermost level of a deduction. Used to determine validity
19158 of qualification conversions. A valid qualification conversion must
19159 have const qualified pointers leading up to the inner type which
19160 requires additional CV quals, except at the outer level, where const
19161 is not required [conv.qual]. It would be normal to set this flag in
19162 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
19163 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
19164 This is the outermost level of a deduction, and PARM can be more CV
19165 qualified at this point.
19166 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
19167 This is the outermost level of a deduction, and PARM can be less CV
19168 qualified at this point. */
19171 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
19177 int strict_in
= strict
;
19179 /* I don't think this will do the right thing with respect to types.
19180 But the only case I've seen it in so far has been array bounds, where
19181 signedness is the only information lost, and I think that will be
19183 while (TREE_CODE (parm
) == NOP_EXPR
)
19184 parm
= TREE_OPERAND (parm
, 0);
19186 if (arg
== error_mark_node
)
19187 return unify_invalid (explain_p
);
19188 if (arg
== unknown_type_node
19189 || arg
== init_list_type_node
)
19190 /* We can't deduce anything from this, but we might get all the
19191 template args from other function args. */
19192 return unify_success (explain_p
);
19194 /* If PARM uses template parameters, then we can't bail out here,
19195 even if ARG == PARM, since we won't record unifications for the
19196 template parameters. We might need them if we're trying to
19197 figure out which of two things is more specialized. */
19198 if (arg
== parm
&& !uses_template_parms (parm
))
19199 return unify_success (explain_p
);
19201 /* Handle init lists early, so the rest of the function can assume
19202 we're dealing with a type. */
19203 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
19207 tree orig_parm
= parm
;
19209 /* Replace T with std::initializer_list<T> for deduction. */
19210 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
19211 && flag_deduce_init_list
)
19212 parm
= listify (parm
);
19214 if (!is_std_init_list (parm
)
19215 && TREE_CODE (parm
) != ARRAY_TYPE
)
19216 /* We can only deduce from an initializer list argument if the
19217 parameter is std::initializer_list or an array; otherwise this
19218 is a non-deduced context. */
19219 return unify_success (explain_p
);
19221 if (TREE_CODE (parm
) == ARRAY_TYPE
)
19222 elttype
= TREE_TYPE (parm
);
19225 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
19226 /* Deduction is defined in terms of a single type, so just punt
19227 on the (bizarre) std::initializer_list<T...>. */
19228 if (PACK_EXPANSION_P (elttype
))
19229 return unify_success (explain_p
);
19232 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
19234 int elt_strict
= strict
;
19236 if (elt
== error_mark_node
)
19237 return unify_invalid (explain_p
);
19239 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
19241 tree type
= TREE_TYPE (elt
);
19242 if (type
== error_mark_node
)
19243 return unify_invalid (explain_p
);
19244 /* It should only be possible to get here for a call. */
19245 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
19246 elt_strict
|= maybe_adjust_types_for_deduction
19247 (DEDUCE_CALL
, &elttype
, &type
, elt
);
19251 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
19255 if (TREE_CODE (parm
) == ARRAY_TYPE
19256 && deducible_array_bound (TYPE_DOMAIN (parm
)))
19258 /* Also deduce from the length of the initializer list. */
19259 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
19260 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
19261 if (idx
== error_mark_node
)
19262 return unify_invalid (explain_p
);
19263 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
19267 /* If the std::initializer_list<T> deduction worked, replace the
19268 deduced A with std::initializer_list<A>. */
19269 if (orig_parm
!= parm
)
19271 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
19272 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
19273 targ
= listify (targ
);
19274 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
19276 return unify_success (explain_p
);
19279 /* Immediately reject some pairs that won't unify because of
19280 cv-qualification mismatches. */
19281 if (TREE_CODE (arg
) == TREE_CODE (parm
)
19283 /* It is the elements of the array which hold the cv quals of an array
19284 type, and the elements might be template type parms. We'll check
19285 when we recurse. */
19286 && TREE_CODE (arg
) != ARRAY_TYPE
19287 /* We check the cv-qualifiers when unifying with template type
19288 parameters below. We want to allow ARG `const T' to unify with
19289 PARM `T' for example, when computing which of two templates
19290 is more specialized, for example. */
19291 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
19292 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
19293 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
19295 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
19296 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
19297 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
19298 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
19299 strict
&= ~UNIFY_ALLOW_DERIVED
;
19300 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
19301 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
19303 switch (TREE_CODE (parm
))
19305 case TYPENAME_TYPE
:
19307 case UNBOUND_CLASS_TEMPLATE
:
19308 /* In a type which contains a nested-name-specifier, template
19309 argument values cannot be deduced for template parameters used
19310 within the nested-name-specifier. */
19311 return unify_success (explain_p
);
19313 case TEMPLATE_TYPE_PARM
:
19314 case TEMPLATE_TEMPLATE_PARM
:
19315 case BOUND_TEMPLATE_TEMPLATE_PARM
:
19316 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
19317 if (error_operand_p (tparm
))
19318 return unify_invalid (explain_p
);
19320 if (TEMPLATE_TYPE_LEVEL (parm
)
19321 != template_decl_level (tparm
))
19322 /* The PARM is not one we're trying to unify. Just check
19323 to see if it matches ARG. */
19325 if (TREE_CODE (arg
) == TREE_CODE (parm
)
19326 && (is_auto (parm
) ? is_auto (arg
)
19327 : same_type_p (parm
, arg
)))
19328 return unify_success (explain_p
);
19330 return unify_type_mismatch (explain_p
, parm
, arg
);
19332 idx
= TEMPLATE_TYPE_IDX (parm
);
19333 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
19334 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
19335 if (error_operand_p (tparm
))
19336 return unify_invalid (explain_p
);
19338 /* Check for mixed types and values. */
19339 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
19340 && TREE_CODE (tparm
) != TYPE_DECL
)
19341 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
19342 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
19343 gcc_unreachable ();
19345 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
19347 /* ARG must be constructed from a template class or a template
19348 template parameter. */
19349 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
19350 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
19351 return unify_template_deduction_failure (explain_p
, parm
, arg
);
19353 tree parmvec
= TYPE_TI_ARGS (parm
);
19354 /* An alias template name is never deduced. */
19355 if (TYPE_ALIAS_P (arg
))
19356 arg
= strip_typedefs (arg
);
19357 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
19358 tree full_argvec
= add_to_template_args (targs
, argvec
);
19360 = DECL_INNERMOST_TEMPLATE_PARMS
19361 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
19363 int parm_variadic_p
= 0;
19365 /* The resolution to DR150 makes clear that default
19366 arguments for an N-argument may not be used to bind T
19367 to a template template parameter with fewer than N
19368 parameters. It is not safe to permit the binding of
19369 default arguments as an extension, as that may change
19370 the meaning of a conforming program. Consider:
19372 struct Dense { static const unsigned int dim = 1; };
19374 template <template <typename> class View,
19376 void operator+(float, View<Block> const&);
19378 template <typename Block,
19379 unsigned int Dim = Block::dim>
19380 struct Lvalue_proxy { operator float() const; };
19384 Lvalue_proxy<Dense> p;
19389 Here, if Lvalue_proxy is permitted to bind to View, then
19390 the global operator+ will be used; if they are not, the
19391 Lvalue_proxy will be converted to float. */
19392 if (coerce_template_parms (parm_parms
,
19394 TYPE_TI_TEMPLATE (parm
),
19396 ? tf_warning_or_error
19398 /*require_all_args=*/true,
19399 /*use_default_args=*/false)
19400 == error_mark_node
)
19403 /* Deduce arguments T, i from TT<T> or TT<i>.
19404 We check each element of PARMVEC and ARGVEC individually
19405 rather than the whole TREE_VEC since they can have
19406 different number of elements. */
19408 parmvec
= expand_template_argument_pack (parmvec
);
19409 argvec
= expand_template_argument_pack (argvec
);
19411 len
= TREE_VEC_LENGTH (parmvec
);
19413 /* Check if the parameters end in a pack, making them
19416 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
19417 parm_variadic_p
= 1;
19419 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
19420 /* If the template argument list of P contains a pack
19421 expansion that is not the last template argument, the
19422 entire template argument list is a non-deduced
19424 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
19425 return unify_success (explain_p
);
19427 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
19428 return unify_too_few_arguments (explain_p
,
19429 TREE_VEC_LENGTH (argvec
), len
);
19431 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
19433 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
19434 TREE_VEC_ELT (parmvec
, i
),
19435 TREE_VEC_ELT (argvec
, i
),
19436 UNIFY_ALLOW_NONE
, explain_p
);
19439 if (parm_variadic_p
19440 && unify_pack_expansion (tparms
, targs
,
19443 /*subr=*/true, explain_p
))
19446 arg
= TYPE_TI_TEMPLATE (arg
);
19448 /* Fall through to deduce template name. */
19451 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
19452 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
19454 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
19456 /* Simple cases: Value already set, does match or doesn't. */
19457 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
19458 return unify_success (explain_p
);
19460 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
19464 /* If PARM is `const T' and ARG is only `int', we don't have
19465 a match unless we are allowing additional qualification.
19466 If ARG is `const int' and PARM is just `T' that's OK;
19467 that binds `const int' to `T'. */
19468 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
19470 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
19472 /* Consider the case where ARG is `const volatile int' and
19473 PARM is `const T'. Then, T should be `volatile int'. */
19474 arg
= cp_build_qualified_type_real
19475 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
19476 if (arg
== error_mark_node
)
19477 return unify_invalid (explain_p
);
19479 /* Simple cases: Value already set, does match or doesn't. */
19480 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
19481 return unify_success (explain_p
);
19483 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
19485 /* Make sure that ARG is not a variable-sized array. (Note
19486 that were talking about variable-sized arrays (like
19487 `int[n]'), rather than arrays of unknown size (like
19488 `int[]').) We'll get very confused by such a type since
19489 the bound of the array is not constant, and therefore
19490 not mangleable. Besides, such types are not allowed in
19491 ISO C++, so we can do as we please here. We do allow
19492 them for 'auto' deduction, since that isn't ABI-exposed. */
19493 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
19494 return unify_vla_arg (explain_p
, arg
);
19496 /* Strip typedefs as in convert_template_argument. */
19497 arg
= canonicalize_type_argument (arg
, tf_none
);
19500 /* If ARG is a parameter pack or an expansion, we cannot unify
19501 against it unless PARM is also a parameter pack. */
19502 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
19503 && !template_parameter_pack_p (parm
))
19504 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
19506 /* If the argument deduction results is a METHOD_TYPE,
19507 then there is a problem.
19508 METHOD_TYPE doesn't map to any real C++ type the result of
19509 the deduction can not be of that type. */
19510 if (TREE_CODE (arg
) == METHOD_TYPE
)
19511 return unify_method_type_error (explain_p
, arg
);
19513 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
19514 return unify_success (explain_p
);
19516 case TEMPLATE_PARM_INDEX
:
19517 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
19518 if (error_operand_p (tparm
))
19519 return unify_invalid (explain_p
);
19521 if (TEMPLATE_PARM_LEVEL (parm
)
19522 != template_decl_level (tparm
))
19524 /* The PARM is not one we're trying to unify. Just check
19525 to see if it matches ARG. */
19526 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
19527 && cp_tree_equal (parm
, arg
));
19529 unify_expression_unequal (explain_p
, parm
, arg
);
19533 idx
= TEMPLATE_PARM_IDX (parm
);
19534 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
19538 int x
= !cp_tree_equal (targ
, arg
);
19540 unify_inconsistency (explain_p
, parm
, targ
, arg
);
19544 /* [temp.deduct.type] If, in the declaration of a function template
19545 with a non-type template-parameter, the non-type
19546 template-parameter is used in an expression in the function
19547 parameter-list and, if the corresponding template-argument is
19548 deduced, the template-argument type shall match the type of the
19549 template-parameter exactly, except that a template-argument
19550 deduced from an array bound may be of any integral type.
19551 The non-type parameter might use already deduced type parameters. */
19552 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
19553 if (!TREE_TYPE (arg
))
19554 /* Template-parameter dependent expression. Just accept it for now.
19555 It will later be processed in convert_template_argument. */
19557 else if (same_type_p (TREE_TYPE (arg
), tparm
))
19559 else if ((strict
& UNIFY_ALLOW_INTEGER
)
19560 && CP_INTEGRAL_TYPE_P (tparm
))
19561 /* Convert the ARG to the type of PARM; the deduced non-type
19562 template argument must exactly match the types of the
19563 corresponding parameter. */
19564 arg
= fold (build_nop (tparm
, arg
));
19565 else if (uses_template_parms (tparm
))
19566 /* We haven't deduced the type of this parameter yet. Try again
19568 return unify_success (explain_p
);
19570 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
19572 /* If ARG is a parameter pack or an expansion, we cannot unify
19573 against it unless PARM is also a parameter pack. */
19574 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
19575 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
19576 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
19579 bool removed_attr
= false;
19580 arg
= strip_typedefs_expr (arg
, &removed_attr
);
19582 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
19583 return unify_success (explain_p
);
19587 /* A pointer-to-member constant can be unified only with
19588 another constant. */
19589 if (TREE_CODE (arg
) != PTRMEM_CST
)
19590 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
19592 /* Just unify the class member. It would be useless (and possibly
19593 wrong, depending on the strict flags) to unify also
19594 PTRMEM_CST_CLASS, because we want to be sure that both parm and
19595 arg refer to the same variable, even if through different
19596 classes. For instance:
19598 struct A { int x; };
19601 Unification of &A::x and &B::x must succeed. */
19602 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
19603 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
19608 if (!TYPE_PTR_P (arg
))
19609 return unify_type_mismatch (explain_p
, parm
, arg
);
19611 /* [temp.deduct.call]
19613 A can be another pointer or pointer to member type that can
19614 be converted to the deduced A via a qualification
19615 conversion (_conv.qual_).
19617 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
19618 This will allow for additional cv-qualification of the
19619 pointed-to types if appropriate. */
19621 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
19622 /* The derived-to-base conversion only persists through one
19623 level of pointers. */
19624 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
19626 return unify (tparms
, targs
, TREE_TYPE (parm
),
19627 TREE_TYPE (arg
), strict
, explain_p
);
19630 case REFERENCE_TYPE
:
19631 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
19632 return unify_type_mismatch (explain_p
, parm
, arg
);
19633 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
19634 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
19637 if (TREE_CODE (arg
) != ARRAY_TYPE
)
19638 return unify_type_mismatch (explain_p
, parm
, arg
);
19639 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
19640 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
19641 return unify_type_mismatch (explain_p
, parm
, arg
);
19642 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
19643 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
19644 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
19645 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
19646 TYPE_DOMAIN (arg
), explain_p
);
19647 return unify_success (explain_p
);
19654 case ENUMERAL_TYPE
:
19657 if (TREE_CODE (arg
) != TREE_CODE (parm
))
19658 return unify_type_mismatch (explain_p
, parm
, arg
);
19660 /* We have already checked cv-qualification at the top of the
19662 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
19663 return unify_type_mismatch (explain_p
, parm
, arg
);
19665 /* As far as unification is concerned, this wins. Later checks
19666 will invalidate it if necessary. */
19667 return unify_success (explain_p
);
19669 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
19670 /* Type INTEGER_CST can come from ordinary constant template args. */
19672 while (TREE_CODE (arg
) == NOP_EXPR
)
19673 arg
= TREE_OPERAND (arg
, 0);
19675 if (TREE_CODE (arg
) != INTEGER_CST
)
19676 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
19677 return (tree_int_cst_equal (parm
, arg
)
19678 ? unify_success (explain_p
)
19679 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
19683 int i
, len
, argslen
;
19684 int parm_variadic_p
= 0;
19686 if (TREE_CODE (arg
) != TREE_VEC
)
19687 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
19689 len
= TREE_VEC_LENGTH (parm
);
19690 argslen
= TREE_VEC_LENGTH (arg
);
19692 /* Check for pack expansions in the parameters. */
19693 for (i
= 0; i
< len
; ++i
)
19695 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
19698 /* We can unify against something with a trailing
19700 parm_variadic_p
= 1;
19702 /* [temp.deduct.type]/9: If the template argument list of
19703 P contains a pack expansion that is not the last
19704 template argument, the entire template argument list
19705 is a non-deduced context. */
19706 return unify_success (explain_p
);
19710 /* If we don't have enough arguments to satisfy the parameters
19711 (not counting the pack expression at the end), or we have
19712 too many arguments for a parameter list that doesn't end in
19713 a pack expression, we can't unify. */
19714 if (parm_variadic_p
19715 ? argslen
< len
- parm_variadic_p
19717 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
19719 /* Unify all of the parameters that precede the (optional)
19720 pack expression. */
19721 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
19723 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
19724 TREE_VEC_ELT (parm
, i
),
19725 TREE_VEC_ELT (arg
, i
),
19726 UNIFY_ALLOW_NONE
, explain_p
);
19728 if (parm_variadic_p
)
19729 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
19731 /*subr=*/true, explain_p
);
19732 return unify_success (explain_p
);
19737 if (TREE_CODE (arg
) != TREE_CODE (parm
))
19738 return unify_type_mismatch (explain_p
, parm
, arg
);
19740 if (TYPE_PTRMEMFUNC_P (parm
))
19742 if (!TYPE_PTRMEMFUNC_P (arg
))
19743 return unify_type_mismatch (explain_p
, parm
, arg
);
19745 return unify (tparms
, targs
,
19746 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
19747 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
19748 strict
, explain_p
);
19750 else if (TYPE_PTRMEMFUNC_P (arg
))
19751 return unify_type_mismatch (explain_p
, parm
, arg
);
19753 if (CLASSTYPE_TEMPLATE_INFO (parm
))
19755 tree t
= NULL_TREE
;
19757 if (strict_in
& UNIFY_ALLOW_DERIVED
)
19759 /* First, we try to unify the PARM and ARG directly. */
19760 t
= try_class_unification (tparms
, targs
,
19761 parm
, arg
, explain_p
);
19765 /* Fallback to the special case allowed in
19766 [temp.deduct.call]:
19768 If P is a class, and P has the form
19769 template-id, then A can be a derived class of
19770 the deduced A. Likewise, if P is a pointer to
19771 a class of the form template-id, A can be a
19772 pointer to a derived class pointed to by the
19774 enum template_base_result r
;
19775 r
= get_template_base (tparms
, targs
, parm
, arg
,
19780 /* Don't give the derived diagnostic if we're
19781 already dealing with the same template. */
19783 = (CLASSTYPE_TEMPLATE_INFO (arg
)
19784 && (CLASSTYPE_TI_TEMPLATE (parm
)
19785 == CLASSTYPE_TI_TEMPLATE (arg
)));
19786 return unify_no_common_base (explain_p
&& !same_template
,
19791 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
19792 && (CLASSTYPE_TI_TEMPLATE (parm
)
19793 == CLASSTYPE_TI_TEMPLATE (arg
)))
19794 /* Perhaps PARM is something like S<U> and ARG is S<int>.
19795 Then, we should unify `int' and `U'. */
19798 /* There's no chance of unification succeeding. */
19799 return unify_type_mismatch (explain_p
, parm
, arg
);
19801 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
19802 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
19804 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
19805 return unify_type_mismatch (explain_p
, parm
, arg
);
19806 return unify_success (explain_p
);
19809 case FUNCTION_TYPE
:
19811 unsigned int nargs
;
19816 if (TREE_CODE (arg
) != TREE_CODE (parm
))
19817 return unify_type_mismatch (explain_p
, parm
, arg
);
19819 /* CV qualifications for methods can never be deduced, they must
19820 match exactly. We need to check them explicitly here,
19821 because type_unification_real treats them as any other
19822 cv-qualified parameter. */
19823 if (TREE_CODE (parm
) == METHOD_TYPE
19824 && (!check_cv_quals_for_unify
19826 class_of_this_parm (arg
),
19827 class_of_this_parm (parm
))))
19828 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
19830 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
19831 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
19833 nargs
= list_length (TYPE_ARG_TYPES (arg
));
19834 args
= XALLOCAVEC (tree
, nargs
);
19835 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
19836 a
!= NULL_TREE
&& a
!= void_list_node
;
19837 a
= TREE_CHAIN (a
), ++i
)
19838 args
[i
] = TREE_VALUE (a
);
19841 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
19842 args
, nargs
, 1, DEDUCE_EXACT
,
19843 LOOKUP_NORMAL
, NULL
, explain_p
);
19847 /* Unify a pointer to member with a pointer to member function, which
19848 deduces the type of the member as a function type. */
19849 if (TYPE_PTRMEMFUNC_P (arg
))
19851 /* Check top-level cv qualifiers */
19852 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
19853 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
19855 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
19856 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
19857 UNIFY_ALLOW_NONE
, explain_p
);
19859 /* Determine the type of the function we are unifying against. */
19860 tree fntype
= static_fn_type (arg
);
19862 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
19865 if (TREE_CODE (arg
) != OFFSET_TYPE
)
19866 return unify_type_mismatch (explain_p
, parm
, arg
);
19867 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
19868 TYPE_OFFSET_BASETYPE (arg
),
19869 UNIFY_ALLOW_NONE
, explain_p
);
19870 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
19871 strict
, explain_p
);
19874 if (DECL_TEMPLATE_PARM_P (parm
))
19875 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
19876 if (arg
!= scalar_constant_value (parm
))
19877 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
19878 return unify_success (explain_p
);
19881 case TEMPLATE_DECL
:
19882 /* Matched cases are handled by the ARG == PARM test above. */
19883 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
19886 /* A non-type template parameter that is a variable should be a
19887 an integral constant, in which case, it whould have been
19888 folded into its (constant) value. So we should not be getting
19889 a variable here. */
19890 gcc_unreachable ();
19892 case TYPE_ARGUMENT_PACK
:
19893 case NONTYPE_ARGUMENT_PACK
:
19894 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
19895 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
19898 case DECLTYPE_TYPE
:
19899 case UNDERLYING_TYPE
:
19900 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
19901 or UNDERLYING_TYPE nodes. */
19902 return unify_success (explain_p
);
19905 /* Unification fails if we hit an error node. */
19906 return unify_invalid (explain_p
);
19909 if (REFERENCE_REF_P (parm
))
19911 if (REFERENCE_REF_P (arg
))
19912 arg
= TREE_OPERAND (arg
, 0);
19913 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
19914 strict
, explain_p
);
19919 /* An unresolved overload is a nondeduced context. */
19920 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
19921 return unify_success (explain_p
);
19922 gcc_assert (EXPR_P (parm
));
19924 /* We must be looking at an expression. This can happen with
19928 void foo(S<I>, S<I + 2>);
19930 This is a "nondeduced context":
19934 The nondeduced contexts are:
19936 --A type that is a template-id in which one or more of
19937 the template-arguments is an expression that references
19938 a template-parameter.
19940 In these cases, we assume deduction succeeded, but don't
19941 actually infer any unifications. */
19943 if (!uses_template_parms (parm
)
19944 && !template_args_equal (parm
, arg
))
19945 return unify_expression_unequal (explain_p
, parm
, arg
);
19947 return unify_success (explain_p
);
19950 #undef RECUR_AND_CHECK_FAILURE
19952 /* Note that DECL can be defined in this translation unit, if
19956 mark_definable (tree decl
)
19959 DECL_NOT_REALLY_EXTERN (decl
) = 1;
19960 FOR_EACH_CLONE (clone
, decl
)
19961 DECL_NOT_REALLY_EXTERN (clone
) = 1;
19964 /* Called if RESULT is explicitly instantiated, or is a member of an
19965 explicitly instantiated class. */
19968 mark_decl_instantiated (tree result
, int extern_p
)
19970 SET_DECL_EXPLICIT_INSTANTIATION (result
);
19972 /* If this entity has already been written out, it's too late to
19973 make any modifications. */
19974 if (TREE_ASM_WRITTEN (result
))
19977 /* For anonymous namespace we don't need to do anything. */
19978 if (decl_anon_ns_mem_p (result
))
19980 gcc_assert (!TREE_PUBLIC (result
));
19984 if (TREE_CODE (result
) != FUNCTION_DECL
)
19985 /* The TREE_PUBLIC flag for function declarations will have been
19986 set correctly by tsubst. */
19987 TREE_PUBLIC (result
) = 1;
19989 /* This might have been set by an earlier implicit instantiation. */
19990 DECL_COMDAT (result
) = 0;
19993 DECL_NOT_REALLY_EXTERN (result
) = 0;
19996 mark_definable (result
);
19997 mark_needed (result
);
19998 /* Always make artificials weak. */
19999 if (DECL_ARTIFICIAL (result
) && flag_weak
)
20000 comdat_linkage (result
);
20001 /* For WIN32 we also want to put explicit instantiations in
20002 linkonce sections. */
20003 else if (TREE_PUBLIC (result
))
20004 maybe_make_one_only (result
);
20007 /* If EXTERN_P, then this function will not be emitted -- unless
20008 followed by an explicit instantiation, at which point its linkage
20009 will be adjusted. If !EXTERN_P, then this function will be
20010 emitted here. In neither circumstance do we want
20011 import_export_decl to adjust the linkage. */
20012 DECL_INTERFACE_KNOWN (result
) = 1;
20015 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
20016 important template arguments. If any are missing, we check whether
20017 they're important by using error_mark_node for substituting into any
20018 args that were used for partial ordering (the ones between ARGS and END)
20019 and seeing if it bubbles up. */
20022 check_undeduced_parms (tree targs
, tree args
, tree end
)
20024 bool found
= false;
20026 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
20027 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
20030 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
20034 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
20035 if (substed
== error_mark_node
)
20041 /* Given two function templates PAT1 and PAT2, return:
20043 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
20044 -1 if PAT2 is more specialized than PAT1.
20045 0 if neither is more specialized.
20047 LEN indicates the number of parameters we should consider
20048 (defaulted parameters should not be considered).
20050 The 1998 std underspecified function template partial ordering, and
20051 DR214 addresses the issue. We take pairs of arguments, one from
20052 each of the templates, and deduce them against each other. One of
20053 the templates will be more specialized if all the *other*
20054 template's arguments deduce against its arguments and at least one
20055 of its arguments *does* *not* deduce against the other template's
20056 corresponding argument. Deduction is done as for class templates.
20057 The arguments used in deduction have reference and top level cv
20058 qualifiers removed. Iff both arguments were originally reference
20059 types *and* deduction succeeds in both directions, an lvalue reference
20060 wins against an rvalue reference and otherwise the template
20061 with the more cv-qualified argument wins for that pairing (if
20062 neither is more cv-qualified, they both are equal). Unlike regular
20063 deduction, after all the arguments have been deduced in this way,
20064 we do *not* verify the deduced template argument values can be
20065 substituted into non-deduced contexts.
20067 The logic can be a bit confusing here, because we look at deduce1 and
20068 targs1 to see if pat2 is at least as specialized, and vice versa; if we
20069 can find template arguments for pat1 to make arg1 look like arg2, that
20070 means that arg2 is at least as specialized as arg1. */
20073 more_specialized_fn (tree pat1
, tree pat2
, int len
)
20075 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
20076 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
20077 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
20078 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
20079 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
20080 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
20081 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
20082 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
20083 tree origs1
, origs2
;
20084 bool lose1
= false;
20085 bool lose2
= false;
20087 /* Remove the this parameter from non-static member functions. If
20088 one is a non-static member function and the other is not a static
20089 member function, remove the first parameter from that function
20090 also. This situation occurs for operator functions where we
20091 locate both a member function (with this pointer) and non-member
20092 operator (with explicit first operand). */
20093 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
20095 len
--; /* LEN is the number of significant arguments for DECL1 */
20096 args1
= TREE_CHAIN (args1
);
20097 if (!DECL_STATIC_FUNCTION_P (decl2
))
20098 args2
= TREE_CHAIN (args2
);
20100 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
20102 args2
= TREE_CHAIN (args2
);
20103 if (!DECL_STATIC_FUNCTION_P (decl1
))
20106 args1
= TREE_CHAIN (args1
);
20110 /* If only one is a conversion operator, they are unordered. */
20111 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
20114 /* Consider the return type for a conversion function */
20115 if (DECL_CONV_FN_P (decl1
))
20117 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
20118 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
20122 processing_template_decl
++;
20128 /* Stop when an ellipsis is seen. */
20129 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
20131 tree arg1
= TREE_VALUE (args1
);
20132 tree arg2
= TREE_VALUE (args2
);
20133 int deduce1
, deduce2
;
20139 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
20140 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
20142 /* When both arguments are pack expansions, we need only
20143 unify the patterns themselves. */
20144 arg1
= PACK_EXPANSION_PATTERN (arg1
);
20145 arg2
= PACK_EXPANSION_PATTERN (arg2
);
20147 /* This is the last comparison we need to do. */
20151 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
20153 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
20154 arg1
= TREE_TYPE (arg1
);
20155 quals1
= cp_type_quals (arg1
);
20158 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
20160 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
20161 arg2
= TREE_TYPE (arg2
);
20162 quals2
= cp_type_quals (arg2
);
20165 arg1
= TYPE_MAIN_VARIANT (arg1
);
20166 arg2
= TYPE_MAIN_VARIANT (arg2
);
20168 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
20170 int i
, len2
= list_length (args2
);
20171 tree parmvec
= make_tree_vec (1);
20172 tree argvec
= make_tree_vec (len2
);
20175 /* Setup the parameter vector, which contains only ARG1. */
20176 TREE_VEC_ELT (parmvec
, 0) = arg1
;
20178 /* Setup the argument vector, which contains the remaining
20180 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
20181 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
20183 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
20184 argvec
, DEDUCE_EXACT
,
20185 /*subr=*/true, /*explain_p=*/false)
20188 /* We cannot deduce in the other direction, because ARG1 is
20189 a pack expansion but ARG2 is not. */
20192 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
20194 int i
, len1
= list_length (args1
);
20195 tree parmvec
= make_tree_vec (1);
20196 tree argvec
= make_tree_vec (len1
);
20199 /* Setup the parameter vector, which contains only ARG1. */
20200 TREE_VEC_ELT (parmvec
, 0) = arg2
;
20202 /* Setup the argument vector, which contains the remaining
20204 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
20205 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
20207 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
20208 argvec
, DEDUCE_EXACT
,
20209 /*subr=*/true, /*explain_p=*/false)
20212 /* We cannot deduce in the other direction, because ARG2 is
20213 a pack expansion but ARG1 is not.*/
20219 /* The normal case, where neither argument is a pack
20221 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
20222 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
20224 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
20225 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
20229 /* If we couldn't deduce arguments for tparms1 to make arg1 match
20230 arg2, then arg2 is not as specialized as arg1. */
20236 /* "If, for a given type, deduction succeeds in both directions
20237 (i.e., the types are identical after the transformations above)
20238 and both P and A were reference types (before being replaced with
20239 the type referred to above):
20240 - if the type from the argument template was an lvalue reference and
20241 the type from the parameter template was not, the argument type is
20242 considered to be more specialized than the other; otherwise,
20243 - if the type from the argument template is more cv-qualified
20244 than the type from the parameter template (as described above),
20245 the argument type is considered to be more specialized than the other;
20247 - neither type is more specialized than the other." */
20249 if (deduce1
&& deduce2
)
20251 if (ref1
&& ref2
&& ref1
!= ref2
)
20258 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
20260 if ((quals1
& quals2
) == quals2
)
20262 if ((quals1
& quals2
) == quals1
)
20267 if (lose1
&& lose2
)
20268 /* We've failed to deduce something in either direction.
20269 These must be unordered. */
20272 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
20273 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
20274 /* We have already processed all of the arguments in our
20275 handing of the pack expansion type. */
20278 args1
= TREE_CHAIN (args1
);
20279 args2
= TREE_CHAIN (args2
);
20282 /* "In most cases, all template parameters must have values in order for
20283 deduction to succeed, but for partial ordering purposes a template
20284 parameter may remain without a value provided it is not used in the
20285 types being used for partial ordering."
20287 Thus, if we are missing any of the targs1 we need to substitute into
20288 origs1, then pat2 is not as specialized as pat1. This can happen when
20289 there is a nondeduced context. */
20290 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
20292 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
20295 processing_template_decl
--;
20297 /* If both deductions succeed, the partial ordering selects the more
20298 constrained template. */
20299 if (!lose1
&& !lose2
)
20301 tree c1
= get_constraints (DECL_TEMPLATE_RESULT (pat1
));
20302 tree c2
= get_constraints (DECL_TEMPLATE_RESULT (pat2
));
20303 lose1
= !subsumes_constraints (c1
, c2
);
20304 lose2
= !subsumes_constraints (c2
, c1
);
20307 /* All things being equal, if the next argument is a pack expansion
20308 for one function but not for the other, prefer the
20309 non-variadic function. FIXME this is bogus; see c++/41958. */
20311 && args1
&& TREE_VALUE (args1
)
20312 && args2
&& TREE_VALUE (args2
))
20314 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
20315 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
20318 if (lose1
== lose2
)
20326 /* Determine which of two partial specializations of TMPL is more
20329 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
20330 to the first partial specialization. The TREE_PURPOSE is the
20331 innermost set of template parameters for the partial
20332 specialization. PAT2 is similar, but for the second template.
20334 Return 1 if the first partial specialization is more specialized;
20335 -1 if the second is more specialized; 0 if neither is more
20338 See [temp.class.order] for information about determining which of
20339 two templates is more specialized. */
20342 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
20346 bool any_deductions
= false;
20348 tree tmpl1
= TREE_VALUE (pat1
);
20349 tree tmpl2
= TREE_VALUE (pat2
);
20350 tree parms1
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl1
);
20351 tree parms2
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl2
);
20352 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
20353 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
20355 /* Just like what happens for functions, if we are ordering between
20356 different template specializations, we may encounter dependent
20357 types in the arguments, and we need our dependency check functions
20358 to behave correctly. */
20359 ++processing_template_decl
;
20360 targs
= get_partial_spec_bindings (tmpl
, parms1
, specargs1
, specargs2
);
20364 any_deductions
= true;
20367 targs
= get_partial_spec_bindings (tmpl
, parms2
, specargs2
, specargs1
);
20371 any_deductions
= true;
20373 --processing_template_decl
;
20375 /* If both deductions succeed, the partial ordering selects the more
20376 constrained template. */
20377 if (!winner
&& any_deductions
)
20378 return more_constrained (tmpl1
, tmpl2
);
20380 /* In the case of a tie where at least one of the templates
20381 has a parameter pack at the end, the template with the most
20382 non-packed parameters wins. */
20385 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
20386 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
20388 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
20389 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
20390 int len1
= TREE_VEC_LENGTH (args1
);
20391 int len2
= TREE_VEC_LENGTH (args2
);
20393 /* We don't count the pack expansion at the end. */
20394 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
20396 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
20401 else if (len1
< len2
)
20408 /* Return the template arguments that will produce the function signature
20409 DECL from the function template FN, with the explicit template
20410 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
20411 also match. Return NULL_TREE if no satisfactory arguments could be
20415 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
20417 int ntparms
= DECL_NTPARMS (fn
);
20418 tree targs
= make_tree_vec (ntparms
);
20419 tree decl_type
= TREE_TYPE (decl
);
20420 tree decl_arg_types
;
20422 unsigned int nargs
, ix
;
20425 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
20427 /* Never do unification on the 'this' parameter. */
20428 decl_arg_types
= skip_artificial_parms_for (decl
,
20429 TYPE_ARG_TYPES (decl_type
));
20431 nargs
= list_length (decl_arg_types
);
20432 args
= XALLOCAVEC (tree
, nargs
);
20433 for (arg
= decl_arg_types
, ix
= 0;
20434 arg
!= NULL_TREE
&& arg
!= void_list_node
;
20435 arg
= TREE_CHAIN (arg
), ++ix
)
20436 args
[ix
] = TREE_VALUE (arg
);
20438 if (fn_type_unification (fn
, explicit_args
, targs
,
20440 (check_rettype
|| DECL_CONV_FN_P (fn
)
20441 ? TREE_TYPE (decl_type
) : NULL_TREE
),
20442 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
20444 == error_mark_node
)
20450 /* Return the innermost template arguments that, when applied to a partial
20451 specialization of TMPL whose innermost template parameters are
20452 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
20455 For example, suppose we have:
20457 template <class T, class U> struct S {};
20458 template <class T> struct S<T*, int> {};
20460 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
20461 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
20462 int}. The resulting vector will be {double}, indicating that `T'
20463 is bound to `double'. */
20466 get_partial_spec_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
20468 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
20470 tree innermost_deduced_args
;
20472 innermost_deduced_args
= make_tree_vec (ntparms
);
20473 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
20475 deduced_args
= copy_node (args
);
20476 SET_TMPL_ARGS_LEVEL (deduced_args
,
20477 TMPL_ARGS_DEPTH (deduced_args
),
20478 innermost_deduced_args
);
20481 deduced_args
= innermost_deduced_args
;
20483 if (unify (tparms
, deduced_args
,
20484 INNERMOST_TEMPLATE_ARGS (spec_args
),
20485 INNERMOST_TEMPLATE_ARGS (args
),
20486 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
20489 for (i
= 0; i
< ntparms
; ++i
)
20490 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
20493 /* Verify that nondeduced template arguments agree with the type
20494 obtained from argument deduction.
20498 struct A { typedef int X; };
20499 template <class T, class U> struct C {};
20500 template <class T> struct C<T, typename T::X> {};
20502 Then with the instantiation `C<A, int>', we can deduce that
20503 `T' is `A' but unify () does not check whether `typename T::X'
20505 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
20506 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
20508 tf_none
, false, false);
20509 if (spec_args
== error_mark_node
20510 /* We only need to check the innermost arguments; the other
20511 arguments will always agree. */
20512 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
20513 INNERMOST_TEMPLATE_ARGS (args
)))
20516 /* Now that we have bindings for all of the template arguments,
20517 ensure that the arguments deduced for the template template
20518 parameters have compatible template parameter lists. See the use
20519 of template_template_parm_bindings_ok_p in fn_type_unification
20520 for more information. */
20521 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
20524 return deduced_args
;
20527 // Compare two function templates T1 and T2 by deducing bindings
20528 // from one against the other. If both deductions succeed, compare
20529 // constraints to see which is more constrained.
20531 more_specialized_inst (tree t1
, tree t2
)
20536 if (get_bindings (t1
, DECL_TEMPLATE_RESULT (t2
), NULL_TREE
, true))
20542 if (get_bindings (t2
, DECL_TEMPLATE_RESULT (t1
), NULL_TREE
, true))
20548 // If both deductions succeed, then one may be more constrained.
20549 if (count
== 2 && fate
== 0)
20550 fate
= more_constrained (t1
, t2
);
20555 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
20556 Return the TREE_LIST node with the most specialized template, if
20557 any. If there is no most specialized template, the error_mark_node
20560 Note that this function does not look at, or modify, the
20561 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
20562 returned is one of the elements of INSTANTIATIONS, callers may
20563 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
20564 and retrieve it from the value returned. */
20567 most_specialized_instantiation (tree templates
)
20571 ++processing_template_decl
;
20574 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
20576 int fate
= more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
));
20581 /* Equally specialized, move to next function. If there
20582 is no next function, nothing's most specialized. */
20583 fn
= TREE_CHAIN (fn
);
20591 /* Now verify that champ is better than everything earlier in the
20592 instantiation list. */
20593 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
)) {
20594 if (more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
)) != 1)
20601 processing_template_decl
--;
20604 return error_mark_node
;
20609 /* If DECL is a specialization of some template, return the most
20610 general such template. Otherwise, returns NULL_TREE.
20612 For example, given:
20614 template <class T> struct S { template <class U> void f(U); };
20616 if TMPL is `template <class U> void S<int>::f(U)' this will return
20617 the full template. This function will not trace past partial
20618 specializations, however. For example, given in addition:
20620 template <class T> struct S<T*> { template <class U> void f(U); };
20622 if TMPL is `template <class U> void S<int*>::f(U)' this will return
20623 `template <class T> template <class U> S<T*>::f(U)'. */
20626 most_general_template (tree decl
)
20628 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
20630 if (tree tinfo
= get_template_info (decl
))
20631 decl
= TI_TEMPLATE (tinfo
);
20632 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
20633 template friend, or a FIELD_DECL for a capture pack. */
20634 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
20638 /* Look for more and more general templates. */
20639 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
20641 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
20642 (See cp-tree.h for details.) */
20643 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
20646 if (CLASS_TYPE_P (TREE_TYPE (decl
))
20647 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
20648 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
20651 /* Stop if we run into an explicitly specialized class template. */
20652 if (!DECL_NAMESPACE_SCOPE_P (decl
)
20653 && DECL_CONTEXT (decl
)
20654 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
20657 decl
= DECL_TI_TEMPLATE (decl
);
20663 /* Return the most specialized of the template partial specializations
20664 which can produce TARGET, a specialization of some class or variable
20665 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
20666 a TEMPLATE_DECL node corresponding to the partial specialization, while
20667 the TREE_PURPOSE is the set of template arguments that must be
20668 substituted into the template pattern in order to generate TARGET.
20670 If the choice of partial specialization is ambiguous, a diagnostic
20671 is issued, and the error_mark_node is returned. If there are no
20672 partial specializations matching TARGET, then NULL_TREE is
20673 returned, indicating that the primary template should be used. */
20676 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
20678 tree list
= NULL_TREE
;
20683 tree outer_args
= NULL_TREE
;
20686 if (TYPE_P (target
))
20688 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
20689 tmpl
= TI_TEMPLATE (tinfo
);
20690 args
= TI_ARGS (tinfo
);
20692 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
20694 tmpl
= TREE_OPERAND (target
, 0);
20695 args
= TREE_OPERAND (target
, 1);
20697 else if (VAR_P (target
))
20699 tree tinfo
= DECL_TEMPLATE_INFO (target
);
20700 tmpl
= TI_TEMPLATE (tinfo
);
20701 args
= TI_ARGS (tinfo
);
20704 gcc_unreachable ();
20706 tree main_tmpl
= most_general_template (tmpl
);
20708 /* For determining which partial specialization to use, only the
20709 innermost args are interesting. */
20710 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
20712 outer_args
= strip_innermost_template_args (args
, 1);
20713 args
= INNERMOST_TEMPLATE_ARGS (args
);
20716 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
20718 tree partial_spec_args
;
20720 tree spec_tmpl
= TREE_VALUE (t
);
20722 partial_spec_args
= TREE_PURPOSE (t
);
20724 ++processing_template_decl
;
20728 /* Discard the outer levels of args, and then substitute in the
20729 template args from the enclosing class. */
20730 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
20731 partial_spec_args
= tsubst_template_args
20732 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
20734 /* And the same for the partial specialization TEMPLATE_DECL. */
20735 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
20738 partial_spec_args
=
20739 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
20742 /*require_all_args=*/true,
20743 /*use_default_args=*/true);
20745 --processing_template_decl
;
20747 if (partial_spec_args
== error_mark_node
)
20748 return error_mark_node
;
20749 if (spec_tmpl
== error_mark_node
)
20750 return error_mark_node
;
20752 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
20753 spec_args
= get_partial_spec_bindings (tmpl
, parms
,
20759 spec_args
= add_to_template_args (outer_args
, spec_args
);
20761 /* Keep the candidate only if the constraints are satisfied,
20762 or if we're not compiling with concepts. */
20764 || constraints_satisfied_p (spec_tmpl
, spec_args
))
20766 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
20767 TREE_TYPE (list
) = TREE_TYPE (t
);
20775 ambiguous_p
= false;
20778 t
= TREE_CHAIN (t
);
20779 for (; t
; t
= TREE_CHAIN (t
))
20781 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
20788 t
= TREE_CHAIN (t
);
20791 ambiguous_p
= true;
20800 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
20802 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
20805 ambiguous_p
= true;
20813 char *spaces
= NULL
;
20814 if (!(complain
& tf_error
))
20815 return error_mark_node
;
20816 if (TYPE_P (target
))
20817 error ("ambiguous template instantiation for %q#T", target
);
20819 error ("ambiguous template instantiation for %q#D", target
);
20820 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
20821 for (t
= list
; t
; t
= TREE_CHAIN (t
))
20823 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
20824 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
20825 "%s %#S", spaces
? spaces
: str
, subst
);
20826 spaces
= spaces
? spaces
: get_spaces (str
);
20829 return error_mark_node
;
20835 /* Explicitly instantiate DECL. */
20838 do_decl_instantiation (tree decl
, tree storage
)
20840 tree result
= NULL_TREE
;
20843 if (!decl
|| decl
== error_mark_node
)
20844 /* An error occurred, for which grokdeclarator has already issued
20845 an appropriate message. */
20847 else if (! DECL_LANG_SPECIFIC (decl
))
20849 error ("explicit instantiation of non-template %q#D", decl
);
20853 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
20854 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
20856 if (VAR_P (decl
) && !var_templ
)
20858 /* There is an asymmetry here in the way VAR_DECLs and
20859 FUNCTION_DECLs are handled by grokdeclarator. In the case of
20860 the latter, the DECL we get back will be marked as a
20861 template instantiation, and the appropriate
20862 DECL_TEMPLATE_INFO will be set up. This does not happen for
20863 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
20864 should handle VAR_DECLs as it currently handles
20866 if (!DECL_CLASS_SCOPE_P (decl
))
20868 error ("%qD is not a static data member of a class template", decl
);
20871 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
20872 if (!result
|| !VAR_P (result
))
20874 error ("no matching template for %qD found", decl
);
20877 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
20879 error ("type %qT for explicit instantiation %qD does not match "
20880 "declared type %qT", TREE_TYPE (result
), decl
,
20885 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
20887 error ("explicit instantiation of %q#D", decl
);
20893 /* Check for various error cases. Note that if the explicit
20894 instantiation is valid the RESULT will currently be marked as an
20895 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
20896 until we get here. */
20898 if (DECL_TEMPLATE_SPECIALIZATION (result
))
20900 /* DR 259 [temp.spec].
20902 Both an explicit instantiation and a declaration of an explicit
20903 specialization shall not appear in a program unless the explicit
20904 instantiation follows a declaration of the explicit specialization.
20906 For a given set of template parameters, if an explicit
20907 instantiation of a template appears after a declaration of an
20908 explicit specialization for that template, the explicit
20909 instantiation has no effect. */
20912 else if (DECL_EXPLICIT_INSTANTIATION (result
))
20916 No program shall explicitly instantiate any template more
20919 We check DECL_NOT_REALLY_EXTERN so as not to complain when
20920 the first instantiation was `extern' and the second is not,
20921 and EXTERN_P for the opposite case. */
20922 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
20923 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
20924 /* If an "extern" explicit instantiation follows an ordinary
20925 explicit instantiation, the template is instantiated. */
20929 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
20931 error ("no matching template for %qD found", result
);
20934 else if (!DECL_TEMPLATE_INFO (result
))
20936 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
20940 if (storage
== NULL_TREE
)
20942 else if (storage
== ridpointers
[(int) RID_EXTERN
])
20944 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
20945 pedwarn (input_location
, OPT_Wpedantic
,
20946 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
20951 error ("storage class %qD applied to template instantiation", storage
);
20953 check_explicit_instantiation_namespace (result
);
20954 mark_decl_instantiated (result
, extern_p
);
20956 instantiate_decl (result
, /*defer_ok=*/1,
20957 /*expl_inst_class_mem_p=*/false);
20961 mark_class_instantiated (tree t
, int extern_p
)
20963 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
20964 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
20965 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
20966 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
20969 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
20970 rest_of_type_compilation (t
, 1);
20974 /* Called from do_type_instantiation through binding_table_foreach to
20975 do recursive instantiation for the type bound in ENTRY. */
20977 bt_instantiate_type_proc (binding_entry entry
, void *data
)
20979 tree storage
= *(tree
*) data
;
20981 if (MAYBE_CLASS_TYPE_P (entry
->type
)
20982 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
20983 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
20986 /* Called from do_type_instantiation to instantiate a member
20987 (a member function or a static member variable) of an
20988 explicitly instantiated class template. */
20990 instantiate_class_member (tree decl
, int extern_p
)
20992 mark_decl_instantiated (decl
, extern_p
);
20994 instantiate_decl (decl
, /*defer_ok=*/1,
20995 /*expl_inst_class_mem_p=*/true);
20998 /* Perform an explicit instantiation of template class T. STORAGE, if
20999 non-null, is the RID for extern, inline or static. COMPLAIN is
21000 nonzero if this is called from the parser, zero if called recursively,
21001 since the standard is unclear (as detailed below). */
21004 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
21009 int previous_instantiation_extern_p
= 0;
21011 if (TREE_CODE (t
) == TYPE_DECL
)
21014 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
21017 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
21019 error ("explicit instantiation of non-class template %qD", tmpl
);
21021 error ("explicit instantiation of non-template type %qT", t
);
21027 if (!COMPLETE_TYPE_P (t
))
21029 if (complain
& tf_error
)
21030 error ("explicit instantiation of %q#T before definition of template",
21035 if (storage
!= NULL_TREE
)
21037 if (!in_system_header_at (input_location
))
21039 if (storage
== ridpointers
[(int) RID_EXTERN
])
21041 if (cxx_dialect
== cxx98
)
21042 pedwarn (input_location
, OPT_Wpedantic
,
21043 "ISO C++ 1998 forbids the use of %<extern%> on "
21044 "explicit instantiations");
21047 pedwarn (input_location
, OPT_Wpedantic
,
21048 "ISO C++ forbids the use of %qE"
21049 " on explicit instantiations", storage
);
21052 if (storage
== ridpointers
[(int) RID_INLINE
])
21054 else if (storage
== ridpointers
[(int) RID_EXTERN
])
21056 else if (storage
== ridpointers
[(int) RID_STATIC
])
21060 error ("storage class %qD applied to template instantiation",
21066 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
21068 /* DR 259 [temp.spec].
21070 Both an explicit instantiation and a declaration of an explicit
21071 specialization shall not appear in a program unless the explicit
21072 instantiation follows a declaration of the explicit specialization.
21074 For a given set of template parameters, if an explicit
21075 instantiation of a template appears after a declaration of an
21076 explicit specialization for that template, the explicit
21077 instantiation has no effect. */
21080 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
21084 No program shall explicitly instantiate any template more
21087 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
21088 instantiation was `extern'. If EXTERN_P then the second is.
21089 These cases are OK. */
21090 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
21092 if (!previous_instantiation_extern_p
&& !extern_p
21093 && (complain
& tf_error
))
21094 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
21096 /* If we've already instantiated the template, just return now. */
21097 if (!CLASSTYPE_INTERFACE_ONLY (t
))
21101 check_explicit_instantiation_namespace (TYPE_NAME (t
));
21102 mark_class_instantiated (t
, extern_p
);
21110 /* In contrast to implicit instantiation, where only the
21111 declarations, and not the definitions, of members are
21112 instantiated, we have here:
21116 The explicit instantiation of a class template specialization
21117 implies the instantiation of all of its members not
21118 previously explicitly specialized in the translation unit
21119 containing the explicit instantiation.
21121 Of course, we can't instantiate member template classes, since
21122 we don't have any arguments for them. Note that the standard
21123 is unclear on whether the instantiation of the members are
21124 *explicit* instantiations or not. However, the most natural
21125 interpretation is that it should be an explicit instantiation. */
21128 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
21129 if (TREE_CODE (tmp
) == FUNCTION_DECL
21130 && DECL_TEMPLATE_INSTANTIATION (tmp
))
21131 instantiate_class_member (tmp
, extern_p
);
21133 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
21134 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
21135 instantiate_class_member (tmp
, extern_p
);
21137 if (CLASSTYPE_NESTED_UTDS (t
))
21138 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
21139 bt_instantiate_type_proc
, &storage
);
21143 /* Given a function DECL, which is a specialization of TMPL, modify
21144 DECL to be a re-instantiation of TMPL with the same template
21145 arguments. TMPL should be the template into which tsubst'ing
21146 should occur for DECL, not the most general template.
21148 One reason for doing this is a scenario like this:
21151 void f(const T&, int i);
21153 void g() { f(3, 7); }
21156 void f(const T& t, const int i) { }
21158 Note that when the template is first instantiated, with
21159 instantiate_template, the resulting DECL will have no name for the
21160 first parameter, and the wrong type for the second. So, when we go
21161 to instantiate the DECL, we regenerate it. */
21164 regenerate_decl_from_template (tree decl
, tree tmpl
)
21166 /* The arguments used to instantiate DECL, from the most general
21171 args
= DECL_TI_ARGS (decl
);
21172 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
21174 /* Make sure that we can see identifiers, and compute access
21176 push_access_scope (decl
);
21178 if (TREE_CODE (decl
) == FUNCTION_DECL
)
21186 args_depth
= TMPL_ARGS_DEPTH (args
);
21187 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
21188 if (args_depth
> parms_depth
)
21189 args
= get_innermost_template_args (args
, parms_depth
);
21191 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
21192 args
, tf_error
, NULL_TREE
,
21193 /*defer_ok*/false);
21194 if (specs
&& specs
!= error_mark_node
)
21195 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
21198 /* Merge parameter declarations. */
21199 decl_parm
= skip_artificial_parms_for (decl
,
21200 DECL_ARGUMENTS (decl
));
21202 = skip_artificial_parms_for (code_pattern
,
21203 DECL_ARGUMENTS (code_pattern
));
21204 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
21209 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
21210 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
21211 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
21213 parm_type
= type_decays_to (parm_type
);
21214 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
21215 TREE_TYPE (decl_parm
) = parm_type
;
21216 attributes
= DECL_ATTRIBUTES (pattern_parm
);
21217 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
21219 DECL_ATTRIBUTES (decl_parm
) = attributes
;
21220 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
21222 decl_parm
= DECL_CHAIN (decl_parm
);
21223 pattern_parm
= DECL_CHAIN (pattern_parm
);
21225 /* Merge any parameters that match with the function parameter
21227 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
21230 tree expanded_types
;
21231 /* Expand the TYPE_PACK_EXPANSION that provides the types for
21232 the parameters in this function parameter pack. */
21233 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
21234 args
, tf_error
, NULL_TREE
);
21235 len
= TREE_VEC_LENGTH (expanded_types
);
21236 for (i
= 0; i
< len
; i
++)
21241 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
21242 /* Rename the parameter to include the index. */
21243 DECL_NAME (decl_parm
) =
21244 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
21245 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
21246 parm_type
= type_decays_to (parm_type
);
21247 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
21248 TREE_TYPE (decl_parm
) = parm_type
;
21249 attributes
= DECL_ATTRIBUTES (pattern_parm
);
21250 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
21252 DECL_ATTRIBUTES (decl_parm
) = attributes
;
21253 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
21255 decl_parm
= DECL_CHAIN (decl_parm
);
21258 /* Merge additional specifiers from the CODE_PATTERN. */
21259 if (DECL_DECLARED_INLINE_P (code_pattern
)
21260 && !DECL_DECLARED_INLINE_P (decl
))
21261 DECL_DECLARED_INLINE_P (decl
) = 1;
21263 else if (VAR_P (decl
))
21265 DECL_INITIAL (decl
) =
21266 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
21267 tf_error
, DECL_TI_TEMPLATE (decl
),
21268 /*integral_constant_expression_p=*/false);
21269 if (VAR_HAD_UNKNOWN_BOUND (decl
))
21270 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
21271 tf_error
, DECL_TI_TEMPLATE (decl
));
21274 gcc_unreachable ();
21276 pop_access_scope (decl
);
21279 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
21280 substituted to get DECL. */
21283 template_for_substitution (tree decl
)
21285 tree tmpl
= DECL_TI_TEMPLATE (decl
);
21287 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
21288 for the instantiation. This is not always the most general
21289 template. Consider, for example:
21292 struct S { template <class U> void f();
21293 template <> void f<int>(); };
21295 and an instantiation of S<double>::f<int>. We want TD to be the
21296 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
21297 while (/* An instantiation cannot have a definition, so we need a
21298 more general template. */
21299 DECL_TEMPLATE_INSTANTIATION (tmpl
)
21300 /* We must also deal with friend templates. Given:
21302 template <class T> struct S {
21303 template <class U> friend void f() {};
21306 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
21307 so far as the language is concerned, but that's still
21308 where we get the pattern for the instantiation from. On
21309 other hand, if the definition comes outside the class, say:
21311 template <class T> struct S {
21312 template <class U> friend void f();
21314 template <class U> friend void f() {}
21316 we don't need to look any further. That's what the check for
21317 DECL_INITIAL is for. */
21318 || (TREE_CODE (decl
) == FUNCTION_DECL
21319 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
21320 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
21322 /* The present template, TD, should not be a definition. If it
21323 were a definition, we should be using it! Note that we
21324 cannot restructure the loop to just keep going until we find
21325 a template with a definition, since that might go too far if
21326 a specialization was declared, but not defined. */
21328 /* Fetch the more general template. */
21329 tmpl
= DECL_TI_TEMPLATE (tmpl
);
21335 /* Returns true if we need to instantiate this template instance even if we
21336 know we aren't going to emit it. */
21339 always_instantiate_p (tree decl
)
21341 /* We always instantiate inline functions so that we can inline them. An
21342 explicit instantiation declaration prohibits implicit instantiation of
21343 non-inline functions. With high levels of optimization, we would
21344 normally inline non-inline functions -- but we're not allowed to do
21345 that for "extern template" functions. Therefore, we check
21346 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
21347 return ((TREE_CODE (decl
) == FUNCTION_DECL
21348 && (DECL_DECLARED_INLINE_P (decl
)
21349 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
21350 /* And we need to instantiate static data members so that
21351 their initializers are available in integral constant
21354 && decl_maybe_constant_var_p (decl
)));
21357 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
21358 instantiate it now, modifying TREE_TYPE (fn). */
21361 maybe_instantiate_noexcept (tree fn
)
21363 tree fntype
, spec
, noex
, clone
;
21365 /* Don't instantiate a noexcept-specification from template context. */
21366 if (processing_template_decl
)
21369 if (DECL_CLONED_FUNCTION_P (fn
))
21370 fn
= DECL_CLONED_FUNCTION (fn
);
21371 fntype
= TREE_TYPE (fn
);
21372 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
21374 if (!spec
|| !TREE_PURPOSE (spec
))
21377 noex
= TREE_PURPOSE (spec
);
21379 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
21381 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
21382 spec
= get_defaulted_eh_spec (fn
);
21383 else if (push_tinst_level (fn
))
21385 push_access_scope (fn
);
21386 push_deferring_access_checks (dk_no_deferred
);
21387 input_location
= DECL_SOURCE_LOCATION (fn
);
21388 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
21389 DEFERRED_NOEXCEPT_ARGS (noex
),
21390 tf_warning_or_error
, fn
,
21391 /*function_p=*/false,
21392 /*integral_constant_expression_p=*/true);
21393 pop_deferring_access_checks ();
21394 pop_access_scope (fn
);
21395 pop_tinst_level ();
21396 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
21397 if (spec
== error_mark_node
)
21398 spec
= noexcept_false_spec
;
21401 spec
= noexcept_false_spec
;
21403 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
21406 FOR_EACH_CLONE (clone
, fn
)
21408 if (TREE_TYPE (clone
) == fntype
)
21409 TREE_TYPE (clone
) = TREE_TYPE (fn
);
21411 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
21415 /* Produce the definition of D, a _DECL generated from a template. If
21416 DEFER_OK is nonzero, then we don't have to actually do the
21417 instantiation now; we just have to do it sometime. Normally it is
21418 an error if this is an explicit instantiation but D is undefined.
21419 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
21420 explicitly instantiated class template. */
21423 instantiate_decl (tree d
, int defer_ok
,
21424 bool expl_inst_class_mem_p
)
21426 tree tmpl
= DECL_TI_TEMPLATE (d
);
21433 bool pattern_defined
;
21434 location_t saved_loc
= input_location
;
21435 int saved_unevaluated_operand
= cp_unevaluated_operand
;
21436 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
21440 bool nested
= false;
21442 /* This function should only be used to instantiate templates for
21443 functions and static member variables. */
21444 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
21446 /* A concept is never instantiated. */
21447 gcc_assert (!DECL_DECLARED_CONCEPT_P (d
));
21449 /* Variables are never deferred; if instantiation is required, they
21450 are instantiated right away. That allows for better code in the
21451 case that an expression refers to the value of the variable --
21452 if the variable has a constant value the referring expression can
21453 take advantage of that fact. */
21455 || DECL_DECLARED_CONSTEXPR_P (d
))
21458 /* Don't instantiate cloned functions. Instead, instantiate the
21459 functions they cloned. */
21460 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
21461 d
= DECL_CLONED_FUNCTION (d
);
21463 if (DECL_TEMPLATE_INSTANTIATED (d
)
21464 || (TREE_CODE (d
) == FUNCTION_DECL
21465 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
21466 || DECL_TEMPLATE_SPECIALIZATION (d
))
21467 /* D has already been instantiated or explicitly specialized, so
21468 there's nothing for us to do here.
21470 It might seem reasonable to check whether or not D is an explicit
21471 instantiation, and, if so, stop here. But when an explicit
21472 instantiation is deferred until the end of the compilation,
21473 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
21474 the instantiation. */
21477 /* Check to see whether we know that this template will be
21478 instantiated in some other file, as with "extern template"
21480 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
21482 /* In general, we do not instantiate such templates. */
21483 if (external_p
&& !always_instantiate_p (d
))
21486 gen_tmpl
= most_general_template (tmpl
);
21487 gen_args
= DECL_TI_ARGS (d
);
21489 if (tmpl
!= gen_tmpl
)
21490 /* We should already have the extra args. */
21491 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
21492 == TMPL_ARGS_DEPTH (gen_args
));
21493 /* And what's in the hash table should match D. */
21494 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
21495 || spec
== NULL_TREE
);
21497 /* This needs to happen before any tsubsting. */
21498 if (! push_tinst_level (d
))
21501 timevar_push (TV_TEMPLATE_INST
);
21503 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
21504 for the instantiation. */
21505 td
= template_for_substitution (d
);
21506 code_pattern
= DECL_TEMPLATE_RESULT (td
);
21508 /* We should never be trying to instantiate a member of a class
21509 template or partial specialization. */
21510 gcc_assert (d
!= code_pattern
);
21512 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
21513 || DECL_TEMPLATE_SPECIALIZATION (td
))
21514 /* In the case of a friend template whose definition is provided
21515 outside the class, we may have too many arguments. Drop the
21516 ones we don't need. The same is true for specializations. */
21517 args
= get_innermost_template_args
21518 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
21522 if (TREE_CODE (d
) == FUNCTION_DECL
)
21524 deleted_p
= DECL_DELETED_FN (code_pattern
);
21525 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
21526 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
21532 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
21535 /* We may be in the middle of deferred access check. Disable it now. */
21536 push_deferring_access_checks (dk_no_deferred
);
21538 /* Unless an explicit instantiation directive has already determined
21539 the linkage of D, remember that a definition is available for
21541 if (pattern_defined
21542 && !DECL_INTERFACE_KNOWN (d
)
21543 && !DECL_NOT_REALLY_EXTERN (d
))
21544 mark_definable (d
);
21546 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
21547 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
21548 input_location
= DECL_SOURCE_LOCATION (d
);
21550 /* If D is a member of an explicitly instantiated class template,
21551 and no definition is available, treat it like an implicit
21553 if (!pattern_defined
&& expl_inst_class_mem_p
21554 && DECL_EXPLICIT_INSTANTIATION (d
))
21556 /* Leave linkage flags alone on instantiations with anonymous
21558 if (TREE_PUBLIC (d
))
21560 DECL_NOT_REALLY_EXTERN (d
) = 0;
21561 DECL_INTERFACE_KNOWN (d
) = 0;
21563 SET_DECL_IMPLICIT_INSTANTIATION (d
);
21566 /* Defer all other templates, unless we have been explicitly
21567 forbidden from doing so. */
21568 if (/* If there is no definition, we cannot instantiate the
21571 /* If it's OK to postpone instantiation, do so. */
21573 /* If this is a static data member that will be defined
21574 elsewhere, we don't want to instantiate the entire data
21575 member, but we do want to instantiate the initializer so that
21576 we can substitute that elsewhere. */
21577 || (external_p
&& VAR_P (d
))
21578 /* Handle here a deleted function too, avoid generating
21579 its body (c++/61080). */
21582 /* The definition of the static data member is now required so
21583 we must substitute the initializer. */
21585 && !DECL_INITIAL (d
)
21586 && DECL_INITIAL (code_pattern
))
21590 bool const_init
= false;
21591 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
21593 ns
= decl_namespace_context (d
);
21594 push_nested_namespace (ns
);
21596 push_nested_class (DECL_CONTEXT (d
));
21597 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
21599 tf_warning_or_error
, NULL_TREE
,
21600 /*integral_constant_expression_p=*/false);
21601 /* If instantiating the initializer involved instantiating this
21602 again, don't call cp_finish_decl twice. */
21603 if (!DECL_INITIAL (d
))
21605 /* Make sure the initializer is still constant, in case of
21606 circular dependency (template/instantiate6.C). */
21608 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
21609 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
21610 /*asmspec_tree=*/NULL_TREE
,
21611 LOOKUP_ONLYCONVERTING
);
21614 pop_nested_class ();
21615 pop_nested_namespace (ns
);
21618 /* We restore the source position here because it's used by
21619 add_pending_template. */
21620 input_location
= saved_loc
;
21622 if (at_eof
&& !pattern_defined
21623 && DECL_EXPLICIT_INSTANTIATION (d
)
21624 && DECL_NOT_REALLY_EXTERN (d
))
21627 The definition of a non-exported function template, a
21628 non-exported member function template, or a non-exported
21629 member function or static data member of a class template
21630 shall be present in every translation unit in which it is
21631 explicitly instantiated. */
21632 permerror (input_location
, "explicit instantiation of %qD "
21633 "but no definition available", d
);
21635 /* If we're in unevaluated context, we just wanted to get the
21636 constant value; this isn't an odr use, so don't queue
21637 a full instantiation. */
21638 if (cp_unevaluated_operand
!= 0)
21640 /* ??? Historically, we have instantiated inline functions, even
21641 when marked as "extern template". */
21642 if (!(external_p
&& VAR_P (d
)))
21643 add_pending_template (d
);
21646 /* Tell the repository that D is available in this translation unit
21647 -- and see if it is supposed to be instantiated here. */
21648 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
21650 /* In a PCH file, despite the fact that the repository hasn't
21651 requested instantiation in the PCH it is still possible that
21652 an instantiation will be required in a file that includes the
21655 add_pending_template (d
);
21656 /* Instantiate inline functions so that the inliner can do its
21657 job, even though we'll not be emitting a copy of this
21659 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
21663 fn_context
= decl_function_context (d
);
21664 nested
= (current_function_decl
!= NULL_TREE
);
21665 vec
<tree
> omp_privatization_save
;
21667 save_omp_privatization_clauses (omp_privatization_save
);
21670 push_to_top_level ();
21674 push_function_context ();
21675 cp_unevaluated_operand
= 0;
21676 c_inhibit_evaluation_warnings
= 0;
21679 /* Mark D as instantiated so that recursive calls to
21680 instantiate_decl do not try to instantiate it again. */
21681 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
21683 /* Regenerate the declaration in case the template has been modified
21684 by a subsequent redeclaration. */
21685 regenerate_decl_from_template (d
, td
);
21687 /* We already set the file and line above. Reset them now in case
21688 they changed as a result of calling regenerate_decl_from_template. */
21689 input_location
= DECL_SOURCE_LOCATION (d
);
21694 bool const_init
= false;
21696 /* Clear out DECL_RTL; whatever was there before may not be right
21697 since we've reset the type of the declaration. */
21698 SET_DECL_RTL (d
, NULL
);
21699 DECL_IN_AGGR_P (d
) = 0;
21701 /* The initializer is placed in DECL_INITIAL by
21702 regenerate_decl_from_template so we don't need to
21703 push/pop_access_scope again here. Pull it out so that
21704 cp_finish_decl can process it. */
21705 init
= DECL_INITIAL (d
);
21706 DECL_INITIAL (d
) = NULL_TREE
;
21707 DECL_INITIALIZED_P (d
) = 0;
21709 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
21710 initializer. That function will defer actual emission until
21711 we have a chance to determine linkage. */
21712 DECL_EXTERNAL (d
) = 0;
21714 /* Enter the scope of D so that access-checking works correctly. */
21715 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
21717 push_nested_class (DECL_CONTEXT (d
));
21719 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
21720 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
21723 pop_nested_class ();
21725 if (variable_template_p (td
))
21726 note_variable_template_instantiation (d
);
21728 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
21729 synthesize_method (d
);
21730 else if (TREE_CODE (d
) == FUNCTION_DECL
)
21732 hash_map
<tree
, tree
> *saved_local_specializations
;
21736 tree block
= NULL_TREE
;
21738 /* Save away the current list, in case we are instantiating one
21739 template from within the body of another. */
21740 saved_local_specializations
= local_specializations
;
21742 /* Set up the list of local specializations, copying the current
21743 list if there is one. */
21744 if (local_specializations
)
21745 local_specializations
21746 = new hash_map
<tree
, tree
> (*local_specializations
);
21748 local_specializations
= new hash_map
<tree
, tree
>;
21750 /* Set up context. */
21751 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
21752 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
21753 block
= push_stmt_list ();
21755 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
21757 /* Some typedefs referenced from within the template code need to be
21758 access checked at template instantiation time, i.e now. These
21759 types were added to the template at parsing time. Let's get those
21760 and perform the access checks then. */
21761 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
21764 /* Create substitution entries for the parameters. */
21765 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
21766 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
21767 spec_parm
= DECL_ARGUMENTS (d
);
21768 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
21770 register_local_specialization (spec_parm
, tmpl_parm
);
21771 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
21772 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
21774 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
21776 if (!DECL_PACK_P (tmpl_parm
))
21778 register_local_specialization (spec_parm
, tmpl_parm
);
21779 spec_parm
= DECL_CHAIN (spec_parm
);
21783 /* Register the (value) argument pack as a specialization of
21784 TMPL_PARM, then move on. */
21785 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
21786 register_local_specialization (argpack
, tmpl_parm
);
21789 gcc_assert (!spec_parm
);
21791 /* Substitute into the body of the function. */
21792 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
21793 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
21794 tf_warning_or_error
, tmpl
);
21797 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
21798 tf_warning_or_error
, tmpl
,
21799 /*integral_constant_expression_p=*/false);
21801 /* Set the current input_location to the end of the function
21802 so that finish_function knows where we are. */
21804 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
21806 /* Remember if we saw an infinite loop in the template. */
21807 current_function_infinite_loop
21808 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
21811 /* We don't need the local specializations any more. */
21812 delete local_specializations
;
21813 local_specializations
= saved_local_specializations
;
21815 /* Finish the function. */
21816 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
21817 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
21818 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
21821 d
= finish_function (0);
21822 expand_or_defer_fn (d
);
21825 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
21826 cp_check_omp_declare_reduction (d
);
21829 /* We're not deferring instantiation any more. */
21830 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
21833 pop_from_top_level ();
21835 pop_function_context ();
21838 input_location
= saved_loc
;
21839 cp_unevaluated_operand
= saved_unevaluated_operand
;
21840 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
21841 pop_deferring_access_checks ();
21842 pop_tinst_level ();
21844 restore_omp_privatization_clauses (omp_privatization_save
);
21846 timevar_pop (TV_TEMPLATE_INST
);
21851 /* Run through the list of templates that we wish we could
21852 instantiate, and instantiate any we can. RETRIES is the
21853 number of times we retry pending template instantiation. */
21856 instantiate_pending_templates (int retries
)
21859 location_t saved_loc
= input_location
;
21861 /* Instantiating templates may trigger vtable generation. This in turn
21862 may require further template instantiations. We place a limit here
21863 to avoid infinite loop. */
21864 if (pending_templates
&& retries
>= max_tinst_depth
)
21866 tree decl
= pending_templates
->tinst
->decl
;
21868 fatal_error (input_location
,
21869 "template instantiation depth exceeds maximum of %d"
21870 " instantiating %q+D, possibly from virtual table generation"
21871 " (use -ftemplate-depth= to increase the maximum)",
21872 max_tinst_depth
, decl
);
21873 if (TREE_CODE (decl
) == FUNCTION_DECL
)
21874 /* Pretend that we defined it. */
21875 DECL_INITIAL (decl
) = error_mark_node
;
21881 struct pending_template
**t
= &pending_templates
;
21882 struct pending_template
*last
= NULL
;
21886 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
21887 bool complete
= false;
21889 if (TYPE_P (instantiation
))
21893 if (!COMPLETE_TYPE_P (instantiation
))
21895 instantiate_class_template (instantiation
);
21896 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
21897 for (fn
= TYPE_METHODS (instantiation
);
21899 fn
= TREE_CHAIN (fn
))
21900 if (! DECL_ARTIFICIAL (fn
))
21901 instantiate_decl (fn
,
21903 /*expl_inst_class_mem_p=*/false);
21904 if (COMPLETE_TYPE_P (instantiation
))
21908 complete
= COMPLETE_TYPE_P (instantiation
);
21912 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
21913 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
21916 = instantiate_decl (instantiation
,
21918 /*expl_inst_class_mem_p=*/false);
21919 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
21923 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
21924 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
21928 /* If INSTANTIATION has been instantiated, then we don't
21929 need to consider it again in the future. */
21937 current_tinst_level
= NULL
;
21939 last_pending_template
= last
;
21941 while (reconsider
);
21943 input_location
= saved_loc
;
21946 /* Substitute ARGVEC into T, which is a list of initializers for
21947 either base class or a non-static data member. The TREE_PURPOSEs
21948 are DECLs, and the TREE_VALUEs are the initializer values. Used by
21949 instantiate_decl. */
21952 tsubst_initializer_list (tree t
, tree argvec
)
21954 tree inits
= NULL_TREE
;
21956 for (; t
; t
= TREE_CHAIN (t
))
21960 tree expanded_bases
= NULL_TREE
;
21961 tree expanded_arguments
= NULL_TREE
;
21964 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
21969 /* Expand the base class expansion type into separate base
21971 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
21972 tf_warning_or_error
,
21974 if (expanded_bases
== error_mark_node
)
21977 /* We'll be building separate TREE_LISTs of arguments for
21979 len
= TREE_VEC_LENGTH (expanded_bases
);
21980 expanded_arguments
= make_tree_vec (len
);
21981 for (i
= 0; i
< len
; i
++)
21982 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
21984 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
21985 expand each argument in the TREE_VALUE of t. */
21986 expr
= make_node (EXPR_PACK_EXPANSION
);
21987 PACK_EXPANSION_LOCAL_P (expr
) = true;
21988 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
21989 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
21991 if (TREE_VALUE (t
) == void_type_node
)
21992 /* VOID_TYPE_NODE is used to indicate
21993 value-initialization. */
21995 for (i
= 0; i
< len
; i
++)
21996 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
22000 /* Substitute parameter packs into each argument in the
22002 in_base_initializer
= 1;
22003 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
22005 tree expanded_exprs
;
22007 /* Expand the argument. */
22008 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
22010 = tsubst_pack_expansion (expr
, argvec
,
22011 tf_warning_or_error
,
22013 if (expanded_exprs
== error_mark_node
)
22016 /* Prepend each of the expanded expressions to the
22017 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
22018 for (i
= 0; i
< len
; i
++)
22020 TREE_VEC_ELT (expanded_arguments
, i
) =
22021 tree_cons (NULL_TREE
,
22022 TREE_VEC_ELT (expanded_exprs
, i
),
22023 TREE_VEC_ELT (expanded_arguments
, i
));
22026 in_base_initializer
= 0;
22028 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
22029 since we built them backwards. */
22030 for (i
= 0; i
< len
; i
++)
22032 TREE_VEC_ELT (expanded_arguments
, i
) =
22033 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
22038 for (i
= 0; i
< len
; ++i
)
22040 if (expanded_bases
)
22042 decl
= TREE_VEC_ELT (expanded_bases
, i
);
22043 decl
= expand_member_init (decl
);
22044 init
= TREE_VEC_ELT (expanded_arguments
, i
);
22049 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
22050 tf_warning_or_error
, NULL_TREE
);
22052 decl
= expand_member_init (decl
);
22053 if (decl
&& !DECL_P (decl
))
22054 in_base_initializer
= 1;
22056 init
= TREE_VALUE (t
);
22058 if (init
!= void_type_node
)
22059 init
= tsubst_expr (init
, argvec
,
22060 tf_warning_or_error
, NULL_TREE
,
22061 /*integral_constant_expression_p=*/false);
22062 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
22063 /* If we had an initializer but it instantiated to nothing,
22064 value-initialize the object. This will only occur when
22065 the initializer was a pack expansion where the parameter
22066 packs used in that expansion were of length zero. */
22067 init
= void_type_node
;
22068 in_base_initializer
= 0;
22073 init
= build_tree_list (decl
, init
);
22074 TREE_CHAIN (init
) = inits
;
22082 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
22085 set_current_access_from_decl (tree decl
)
22087 if (TREE_PRIVATE (decl
))
22088 current_access_specifier
= access_private_node
;
22089 else if (TREE_PROTECTED (decl
))
22090 current_access_specifier
= access_protected_node
;
22092 current_access_specifier
= access_public_node
;
22095 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
22096 is the instantiation (which should have been created with
22097 start_enum) and ARGS are the template arguments to use. */
22100 tsubst_enum (tree tag
, tree newtag
, tree args
)
22104 if (SCOPED_ENUM_P (newtag
))
22105 begin_scope (sk_scoped_enum
, newtag
);
22107 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
22112 decl
= TREE_VALUE (e
);
22113 /* Note that in a template enum, the TREE_VALUE is the
22114 CONST_DECL, not the corresponding INTEGER_CST. */
22115 value
= tsubst_expr (DECL_INITIAL (decl
),
22116 args
, tf_warning_or_error
, NULL_TREE
,
22117 /*integral_constant_expression_p=*/true);
22119 /* Give this enumeration constant the correct access. */
22120 set_current_access_from_decl (decl
);
22122 /* Actually build the enumerator itself. Here we're assuming that
22123 enumerators can't have dependent attributes. */
22124 build_enumerator (DECL_NAME (decl
), value
, newtag
,
22125 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
22128 if (SCOPED_ENUM_P (newtag
))
22131 finish_enum_value_list (newtag
);
22132 finish_enum (newtag
);
22134 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
22135 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
22138 /* DECL is a FUNCTION_DECL that is a template specialization. Return
22139 its type -- but without substituting the innermost set of template
22140 arguments. So, innermost set of template parameters will appear in
22144 get_mostly_instantiated_function_type (tree decl
)
22146 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
22147 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
22150 /* Return truthvalue if we're processing a template different from
22151 the last one involved in diagnostics. */
22153 problematic_instantiation_changed (void)
22155 return current_tinst_level
!= last_error_tinst_level
;
22158 /* Remember current template involved in diagnostics. */
22160 record_last_problematic_instantiation (void)
22162 last_error_tinst_level
= current_tinst_level
;
22165 struct tinst_level
*
22166 current_instantiation (void)
22168 return current_tinst_level
;
22171 /* Return TRUE if current_function_decl is being instantiated, false
22175 instantiating_current_function_p (void)
22177 return (current_instantiation ()
22178 && current_instantiation ()->decl
== current_function_decl
);
22181 /* [temp.param] Check that template non-type parm TYPE is of an allowable
22182 type. Return zero for ok, nonzero for disallowed. Issue error and
22183 warning messages under control of COMPLAIN. */
22186 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
22188 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
22190 else if (POINTER_TYPE_P (type
))
22192 else if (TYPE_PTRMEM_P (type
))
22194 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
22196 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
22198 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
22200 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
22202 /* A bound template template parm could later be instantiated to have a valid
22203 nontype parm type via an alias template. */
22204 else if (cxx_dialect
>= cxx11
22205 && TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22208 if (complain
& tf_error
)
22210 if (type
== error_mark_node
)
22211 inform (input_location
, "invalid template non-type parameter");
22213 error ("%q#T is not a valid type for a template non-type parameter",
22219 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
22220 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
22223 dependent_type_p_r (tree type
)
22229 A type is dependent if it is:
22231 -- a template parameter. Template template parameters are types
22232 for us (since TYPE_P holds true for them) so we handle
22234 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
22235 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
22237 /* -- a qualified-id with a nested-name-specifier which contains a
22238 class-name that names a dependent type or whose unqualified-id
22239 names a dependent type. */
22240 if (TREE_CODE (type
) == TYPENAME_TYPE
)
22243 /* An alias template specialization can be dependent even if the
22244 resulting type is not. */
22245 if (dependent_alias_template_spec_p (type
))
22248 /* -- a cv-qualified type where the cv-unqualified type is
22250 No code is necessary for this bullet; the code below handles
22251 cv-qualified types, and we don't want to strip aliases with
22252 TYPE_MAIN_VARIANT because of DR 1558. */
22253 /* -- a compound type constructed from any dependent type. */
22254 if (TYPE_PTRMEM_P (type
))
22255 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
22256 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
22258 else if (TYPE_PTR_P (type
)
22259 || TREE_CODE (type
) == REFERENCE_TYPE
)
22260 return dependent_type_p (TREE_TYPE (type
));
22261 else if (TREE_CODE (type
) == FUNCTION_TYPE
22262 || TREE_CODE (type
) == METHOD_TYPE
)
22266 if (dependent_type_p (TREE_TYPE (type
)))
22268 for (arg_type
= TYPE_ARG_TYPES (type
);
22270 arg_type
= TREE_CHAIN (arg_type
))
22271 if (dependent_type_p (TREE_VALUE (arg_type
)))
22275 /* -- an array type constructed from any dependent type or whose
22276 size is specified by a constant expression that is
22279 We checked for type- and value-dependence of the bounds in
22280 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
22281 if (TREE_CODE (type
) == ARRAY_TYPE
)
22283 if (TYPE_DOMAIN (type
)
22284 && dependent_type_p (TYPE_DOMAIN (type
)))
22286 return dependent_type_p (TREE_TYPE (type
));
22289 /* -- a template-id in which either the template name is a template
22291 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
22293 /* ... or any of the template arguments is a dependent type or
22294 an expression that is type-dependent or value-dependent. */
22295 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
22296 && (any_dependent_template_arguments_p
22297 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
22300 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
22301 dependent; if the argument of the `typeof' expression is not
22302 type-dependent, then it should already been have resolved. */
22303 if (TREE_CODE (type
) == TYPEOF_TYPE
22304 || TREE_CODE (type
) == DECLTYPE_TYPE
22305 || TREE_CODE (type
) == UNDERLYING_TYPE
)
22308 /* A template argument pack is dependent if any of its packed
22310 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
22312 tree args
= ARGUMENT_PACK_ARGS (type
);
22313 int i
, len
= TREE_VEC_LENGTH (args
);
22314 for (i
= 0; i
< len
; ++i
)
22315 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
22319 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
22320 be template parameters. */
22321 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
22324 /* The standard does not specifically mention types that are local
22325 to template functions or local classes, but they should be
22326 considered dependent too. For example:
22328 template <int I> void f() {
22333 The size of `E' cannot be known until the value of `I' has been
22334 determined. Therefore, `E' must be considered dependent. */
22335 scope
= TYPE_CONTEXT (type
);
22336 if (scope
&& TYPE_P (scope
))
22337 return dependent_type_p (scope
);
22338 /* Don't use type_dependent_expression_p here, as it can lead
22339 to infinite recursion trying to determine whether a lambda
22340 nested in a lambda is dependent (c++/47687). */
22341 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
22342 && DECL_LANG_SPECIFIC (scope
)
22343 && DECL_TEMPLATE_INFO (scope
)
22344 && (any_dependent_template_arguments_p
22345 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
22348 /* Other types are non-dependent. */
22352 /* Returns TRUE if TYPE is dependent, in the sense of
22353 [temp.dep.type]. Note that a NULL type is considered dependent. */
22356 dependent_type_p (tree type
)
22358 /* If there are no template parameters in scope, then there can't be
22359 any dependent types. */
22360 if (!processing_template_decl
)
22362 /* If we are not processing a template, then nobody should be
22363 providing us with a dependent type. */
22365 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
22369 /* If the type is NULL, we have not computed a type for the entity
22370 in question; in that case, the type is dependent. */
22374 /* Erroneous types can be considered non-dependent. */
22375 if (type
== error_mark_node
)
22378 /* If we have not already computed the appropriate value for TYPE,
22380 if (!TYPE_DEPENDENT_P_VALID (type
))
22382 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
22383 TYPE_DEPENDENT_P_VALID (type
) = 1;
22386 return TYPE_DEPENDENT_P (type
);
22389 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
22390 lookup. In other words, a dependent type that is not the current
22394 dependent_scope_p (tree scope
)
22396 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
22397 && !currently_open_class (scope
));
22400 /* T is a SCOPE_REF; return whether we need to consider it
22401 instantiation-dependent so that we can check access at instantiation
22402 time even though we know which member it resolves to. */
22405 instantiation_dependent_scope_ref_p (tree t
)
22407 if (DECL_P (TREE_OPERAND (t
, 1))
22408 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
22409 && accessible_in_template_p (TREE_OPERAND (t
, 0),
22410 TREE_OPERAND (t
, 1)))
22416 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
22417 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
22420 /* Note that this predicate is not appropriate for general expressions;
22421 only constant expressions (that satisfy potential_constant_expression)
22422 can be tested for value dependence. */
22425 value_dependent_expression_p (tree expression
)
22427 if (!processing_template_decl
)
22430 /* A name declared with a dependent type. */
22431 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
22434 switch (TREE_CODE (expression
))
22436 case IDENTIFIER_NODE
:
22437 /* A name that has not been looked up -- must be dependent. */
22440 case TEMPLATE_PARM_INDEX
:
22441 /* A non-type template parm. */
22445 /* A non-type template parm. */
22446 if (DECL_TEMPLATE_PARM_P (expression
))
22448 return value_dependent_expression_p (DECL_INITIAL (expression
));
22451 /* A constant with literal type and is initialized
22452 with an expression that is value-dependent.
22454 Note that a non-dependent parenthesized initializer will have
22455 already been replaced with its constant value, so if we see
22456 a TREE_LIST it must be dependent. */
22457 if (DECL_INITIAL (expression
)
22458 && decl_constant_var_p (expression
)
22459 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
22460 /* cp_finish_decl doesn't fold reference initializers. */
22461 || TREE_CODE (TREE_TYPE (expression
)) == REFERENCE_TYPE
22462 || value_dependent_expression_p (DECL_INITIAL (expression
))))
22466 case DYNAMIC_CAST_EXPR
:
22467 case STATIC_CAST_EXPR
:
22468 case CONST_CAST_EXPR
:
22469 case REINTERPRET_CAST_EXPR
:
22471 /* These expressions are value-dependent if the type to which
22472 the cast occurs is dependent or the expression being casted
22473 is value-dependent. */
22475 tree type
= TREE_TYPE (expression
);
22477 if (dependent_type_p (type
))
22480 /* A functional cast has a list of operands. */
22481 expression
= TREE_OPERAND (expression
, 0);
22484 /* If there are no operands, it must be an expression such
22485 as "int()". This should not happen for aggregate types
22486 because it would form non-constant expressions. */
22487 gcc_assert (cxx_dialect
>= cxx11
22488 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
22493 if (TREE_CODE (expression
) == TREE_LIST
)
22494 return any_value_dependent_elements_p (expression
);
22496 return value_dependent_expression_p (expression
);
22500 if (SIZEOF_EXPR_TYPE_P (expression
))
22501 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
22505 /* A `sizeof' expression is value-dependent if the operand is
22506 type-dependent or is a pack expansion. */
22507 expression
= TREE_OPERAND (expression
, 0);
22508 if (PACK_EXPANSION_P (expression
))
22510 else if (TYPE_P (expression
))
22511 return dependent_type_p (expression
);
22512 return instantiation_dependent_expression_p (expression
);
22514 case AT_ENCODE_EXPR
:
22515 /* An 'encode' expression is value-dependent if the operand is
22517 expression
= TREE_OPERAND (expression
, 0);
22518 return dependent_type_p (expression
);
22520 case NOEXCEPT_EXPR
:
22521 expression
= TREE_OPERAND (expression
, 0);
22522 return instantiation_dependent_expression_p (expression
);
22525 /* All instantiation-dependent expressions should also be considered
22526 value-dependent. */
22527 return instantiation_dependent_scope_ref_p (expression
);
22529 case COMPONENT_REF
:
22530 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
22531 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
22533 case NONTYPE_ARGUMENT_PACK
:
22534 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
22535 is value-dependent. */
22537 tree values
= ARGUMENT_PACK_ARGS (expression
);
22538 int i
, len
= TREE_VEC_LENGTH (values
);
22540 for (i
= 0; i
< len
; ++i
)
22541 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
22549 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
22550 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
22551 || (type2
? dependent_type_p (type2
) : false));
22555 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
22556 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
22559 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
22560 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
22564 tree op
= TREE_OPERAND (expression
, 0);
22565 return (value_dependent_expression_p (op
)
22566 || has_value_dependent_address (op
));
22569 case REQUIRES_EXPR
:
22570 /* Treat all requires-expressions as value-dependent so
22571 we don't try to fold them. */
22575 return dependent_type_p (TREE_OPERAND (expression
, 0));
22579 tree fn
= get_callee_fndecl (expression
);
22581 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
22583 nargs
= call_expr_nargs (expression
);
22584 for (i
= 0; i
< nargs
; ++i
)
22586 tree op
= CALL_EXPR_ARG (expression
, i
);
22587 /* In a call to a constexpr member function, look through the
22588 implicit ADDR_EXPR on the object argument so that it doesn't
22589 cause the call to be considered value-dependent. We also
22590 look through it in potential_constant_expression. */
22591 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
22592 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
22593 && TREE_CODE (op
) == ADDR_EXPR
)
22594 op
= TREE_OPERAND (op
, 0);
22595 if (value_dependent_expression_p (op
))
22601 case TEMPLATE_ID_EXPR
:
22602 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
22604 return type_dependent_expression_p (expression
)
22605 || variable_concept_p (TREE_OPERAND (expression
, 0));
22611 if (dependent_type_p (TREE_TYPE (expression
)))
22613 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
22614 if (value_dependent_expression_p (val
))
22620 /* Treat a GNU statement expression as dependent to avoid crashing
22621 under instantiate_non_dependent_expr; it can't be constant. */
22625 /* A constant expression is value-dependent if any subexpression is
22626 value-dependent. */
22627 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
22629 case tcc_reference
:
22631 case tcc_comparison
:
22633 case tcc_expression
:
22636 int i
, len
= cp_tree_operand_length (expression
);
22638 for (i
= 0; i
< len
; i
++)
22640 tree t
= TREE_OPERAND (expression
, i
);
22642 /* In some cases, some of the operands may be missing.l
22643 (For example, in the case of PREDECREMENT_EXPR, the
22644 amount to increment by may be missing.) That doesn't
22645 make the expression dependent. */
22646 if (t
&& value_dependent_expression_p (t
))
22657 /* The expression is not value-dependent. */
22661 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
22662 [temp.dep.expr]. Note that an expression with no type is
22663 considered dependent. Other parts of the compiler arrange for an
22664 expression with type-dependent subexpressions to have no type, so
22665 this function doesn't have to be fully recursive. */
22668 type_dependent_expression_p (tree expression
)
22670 if (!processing_template_decl
)
22673 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
22676 /* An unresolved name is always dependent. */
22677 if (identifier_p (expression
)
22678 || TREE_CODE (expression
) == USING_DECL
22679 || TREE_CODE (expression
) == WILDCARD_DECL
)
22682 /* A fold expression is type-dependent. */
22683 if (TREE_CODE (expression
) == UNARY_LEFT_FOLD_EXPR
22684 || TREE_CODE (expression
) == UNARY_RIGHT_FOLD_EXPR
22685 || TREE_CODE (expression
) == BINARY_LEFT_FOLD_EXPR
22686 || TREE_CODE (expression
) == BINARY_RIGHT_FOLD_EXPR
)
22689 /* Some expression forms are never type-dependent. */
22690 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
22691 || TREE_CODE (expression
) == SIZEOF_EXPR
22692 || TREE_CODE (expression
) == ALIGNOF_EXPR
22693 || TREE_CODE (expression
) == AT_ENCODE_EXPR
22694 || TREE_CODE (expression
) == NOEXCEPT_EXPR
22695 || TREE_CODE (expression
) == TRAIT_EXPR
22696 || TREE_CODE (expression
) == TYPEID_EXPR
22697 || TREE_CODE (expression
) == DELETE_EXPR
22698 || TREE_CODE (expression
) == VEC_DELETE_EXPR
22699 || TREE_CODE (expression
) == THROW_EXPR
22700 || TREE_CODE (expression
) == REQUIRES_EXPR
)
22703 /* The types of these expressions depends only on the type to which
22704 the cast occurs. */
22705 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
22706 || TREE_CODE (expression
) == STATIC_CAST_EXPR
22707 || TREE_CODE (expression
) == CONST_CAST_EXPR
22708 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
22709 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
22710 || TREE_CODE (expression
) == CAST_EXPR
)
22711 return dependent_type_p (TREE_TYPE (expression
));
22713 /* The types of these expressions depends only on the type created
22714 by the expression. */
22715 if (TREE_CODE (expression
) == NEW_EXPR
22716 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
22718 /* For NEW_EXPR tree nodes created inside a template, either
22719 the object type itself or a TREE_LIST may appear as the
22721 tree type
= TREE_OPERAND (expression
, 1);
22722 if (TREE_CODE (type
) == TREE_LIST
)
22723 /* This is an array type. We need to check array dimensions
22725 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
22726 || value_dependent_expression_p
22727 (TREE_OPERAND (TREE_VALUE (type
), 1));
22729 return dependent_type_p (type
);
22732 if (TREE_CODE (expression
) == SCOPE_REF
)
22734 tree scope
= TREE_OPERAND (expression
, 0);
22735 tree name
= TREE_OPERAND (expression
, 1);
22737 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
22738 contains an identifier associated by name lookup with one or more
22739 declarations declared with a dependent type, or...a
22740 nested-name-specifier or qualified-id that names a member of an
22741 unknown specialization. */
22742 return (type_dependent_expression_p (name
)
22743 || dependent_scope_p (scope
));
22746 if (TREE_CODE (expression
) == FUNCTION_DECL
22747 && DECL_LANG_SPECIFIC (expression
)
22748 && DECL_TEMPLATE_INFO (expression
)
22749 && (any_dependent_template_arguments_p
22750 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
22753 if (TREE_CODE (expression
) == TEMPLATE_DECL
22754 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
22757 if (TREE_CODE (expression
) == STMT_EXPR
)
22758 expression
= stmt_expr_value_expr (expression
);
22760 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
22765 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
22767 if (type_dependent_expression_p (elt
))
22773 /* A static data member of the current instantiation with incomplete
22774 array type is type-dependent, as the definition and specializations
22775 can have different bounds. */
22776 if (VAR_P (expression
)
22777 && DECL_CLASS_SCOPE_P (expression
)
22778 && dependent_type_p (DECL_CONTEXT (expression
))
22779 && VAR_HAD_UNKNOWN_BOUND (expression
))
22782 /* An array of unknown bound depending on a variadic parameter, eg:
22784 template<typename... Args>
22785 void foo (Args... args)
22787 int arr[] = { args... };
22790 template<int... vals>
22793 int arr[] = { vals... };
22796 If the array has no length and has an initializer, it must be that
22797 we couldn't determine its length in cp_complete_array_type because
22798 it is dependent. */
22799 if (VAR_P (expression
)
22800 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
22801 && !TYPE_DOMAIN (TREE_TYPE (expression
))
22802 && DECL_INITIAL (expression
))
22805 /* A variable template specialization is type-dependent if it has any
22806 dependent template arguments. */
22807 if (VAR_P (expression
)
22808 && DECL_LANG_SPECIFIC (expression
)
22809 && DECL_TEMPLATE_INFO (expression
)
22810 && variable_template_p (DECL_TI_TEMPLATE (expression
)))
22811 return any_dependent_template_arguments_p (DECL_TI_ARGS (expression
));
22813 /* Always dependent, on the number of arguments if nothing else. */
22814 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
22817 if (TREE_TYPE (expression
) == unknown_type_node
)
22819 if (TREE_CODE (expression
) == ADDR_EXPR
)
22820 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
22821 if (TREE_CODE (expression
) == COMPONENT_REF
22822 || TREE_CODE (expression
) == OFFSET_REF
)
22824 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
22826 expression
= TREE_OPERAND (expression
, 1);
22827 if (identifier_p (expression
))
22830 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
22831 if (TREE_CODE (expression
) == SCOPE_REF
)
22834 if (BASELINK_P (expression
))
22836 if (BASELINK_OPTYPE (expression
)
22837 && dependent_type_p (BASELINK_OPTYPE (expression
)))
22839 expression
= BASELINK_FUNCTIONS (expression
);
22842 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
22844 if (any_dependent_template_arguments_p
22845 (TREE_OPERAND (expression
, 1)))
22847 expression
= TREE_OPERAND (expression
, 0);
22848 if (identifier_p (expression
))
22852 gcc_assert (TREE_CODE (expression
) == OVERLOAD
22853 || TREE_CODE (expression
) == FUNCTION_DECL
);
22857 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
22859 expression
= OVL_NEXT (expression
);
22864 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
22866 return (dependent_type_p (TREE_TYPE (expression
)));
22869 /* walk_tree callback function for instantiation_dependent_expression_p,
22870 below. Returns non-zero if a dependent subexpression is found. */
22873 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
22878 /* We don't have to worry about decltype currently because decltype
22879 of an instantiation-dependent expr is a dependent type. This
22880 might change depending on the resolution of DR 1172. */
22881 *walk_subtrees
= false;
22884 enum tree_code code
= TREE_CODE (*tp
);
22887 /* Don't treat an argument list as dependent just because it has no
22895 /* A constant with a dependent initializer is dependent. */
22896 if (value_dependent_expression_p (*tp
))
22900 case TEMPLATE_PARM_INDEX
:
22903 /* Handle expressions with type operands. */
22907 case AT_ENCODE_EXPR
:
22909 tree op
= TREE_OPERAND (*tp
, 0);
22910 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
22911 op
= TREE_TYPE (op
);
22914 if (dependent_type_p (op
))
22918 *walk_subtrees
= false;
22926 if (value_dependent_expression_p (*tp
))
22928 *walk_subtrees
= false;
22931 case COMPONENT_REF
:
22932 if (identifier_p (TREE_OPERAND (*tp
, 1)))
22933 /* In a template, finish_class_member_access_expr creates a
22934 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
22935 type-dependent, so that we can check access control at
22936 instantiation time (PR 42277). See also Core issue 1273. */
22941 if (instantiation_dependent_scope_ref_p (*tp
))
22946 /* Treat statement-expressions as dependent. */
22950 /* Treat requires-expressions as dependent. */
22951 case REQUIRES_EXPR
:
22955 /* Treat calls to function concepts as dependent. */
22956 if (function_concept_check_p (*tp
))
22960 case TEMPLATE_ID_EXPR
:
22961 /* And variable concepts. */
22962 if (variable_concept_p (TREE_OPERAND (*tp
, 0)))
22970 if (type_dependent_expression_p (*tp
))
22976 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
22977 sense defined by the ABI:
22979 "An expression is instantiation-dependent if it is type-dependent
22980 or value-dependent, or it has a subexpression that is type-dependent
22981 or value-dependent." */
22984 instantiation_dependent_expression_p (tree expression
)
22988 if (!processing_template_decl
)
22991 if (expression
== error_mark_node
)
22994 result
= cp_walk_tree_without_duplicates (&expression
,
22995 instantiation_dependent_r
, NULL
);
22996 return result
!= NULL_TREE
;
22999 /* Like type_dependent_expression_p, but it also works while not processing
23000 a template definition, i.e. during substitution or mangling. */
23003 type_dependent_expression_p_push (tree expr
)
23006 ++processing_template_decl
;
23007 b
= type_dependent_expression_p (expr
);
23008 --processing_template_decl
;
23012 /* Returns TRUE if ARGS contains a type-dependent expression. */
23015 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
23020 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
23022 if (type_dependent_expression_p (arg
))
23028 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
23029 expressions) contains any type-dependent expressions. */
23032 any_type_dependent_elements_p (const_tree list
)
23034 for (; list
; list
= TREE_CHAIN (list
))
23035 if (type_dependent_expression_p (TREE_VALUE (list
)))
23041 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
23042 expressions) contains any value-dependent expressions. */
23045 any_value_dependent_elements_p (const_tree list
)
23047 for (; list
; list
= TREE_CHAIN (list
))
23048 if (value_dependent_expression_p (TREE_VALUE (list
)))
23054 /* Returns TRUE if the ARG (a template argument) is dependent. */
23057 dependent_template_arg_p (tree arg
)
23059 if (!processing_template_decl
)
23062 /* Assume a template argument that was wrongly written by the user
23063 is dependent. This is consistent with what
23064 any_dependent_template_arguments_p [that calls this function]
23066 if (!arg
|| arg
== error_mark_node
)
23069 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
23070 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
23072 if (TREE_CODE (arg
) == TEMPLATE_DECL
23073 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
23074 return dependent_template_p (arg
);
23075 else if (ARGUMENT_PACK_P (arg
))
23077 tree args
= ARGUMENT_PACK_ARGS (arg
);
23078 int i
, len
= TREE_VEC_LENGTH (args
);
23079 for (i
= 0; i
< len
; ++i
)
23081 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
23087 else if (TYPE_P (arg
))
23088 return dependent_type_p (arg
);
23090 return (type_dependent_expression_p (arg
)
23091 || value_dependent_expression_p (arg
));
23094 /* Returns true if ARGS (a collection of template arguments) contains
23095 any types that require structural equality testing. */
23098 any_template_arguments_need_structural_equality_p (tree args
)
23105 if (args
== error_mark_node
)
23108 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
23110 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
23111 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
23113 tree arg
= TREE_VEC_ELT (level
, j
);
23114 tree packed_args
= NULL_TREE
;
23117 if (ARGUMENT_PACK_P (arg
))
23119 /* Look inside the argument pack. */
23120 packed_args
= ARGUMENT_PACK_ARGS (arg
);
23121 len
= TREE_VEC_LENGTH (packed_args
);
23124 for (k
= 0; k
< len
; ++k
)
23127 arg
= TREE_VEC_ELT (packed_args
, k
);
23129 if (error_operand_p (arg
))
23131 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
23133 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
23135 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
23136 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
23145 /* Returns true if ARGS (a collection of template arguments) contains
23146 any dependent arguments. */
23149 any_dependent_template_arguments_p (const_tree args
)
23156 if (args
== error_mark_node
)
23159 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
23161 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
23162 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
23163 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
23170 /* Returns TRUE if the template TMPL is dependent. */
23173 dependent_template_p (tree tmpl
)
23175 if (TREE_CODE (tmpl
) == OVERLOAD
)
23179 if (dependent_template_p (OVL_CURRENT (tmpl
)))
23181 tmpl
= OVL_NEXT (tmpl
);
23186 /* Template template parameters are dependent. */
23187 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
23188 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
23190 /* So are names that have not been looked up. */
23191 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
23193 /* So are member templates of dependent classes. */
23194 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
23195 return dependent_type_p (DECL_CONTEXT (tmpl
));
23199 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
23202 dependent_template_id_p (tree tmpl
, tree args
)
23204 return (dependent_template_p (tmpl
)
23205 || any_dependent_template_arguments_p (args
));
23208 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
23212 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
23216 if (!processing_template_decl
)
23219 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
23221 tree decl
= TREE_VEC_ELT (declv
, i
);
23222 tree init
= TREE_VEC_ELT (initv
, i
);
23223 tree cond
= TREE_VEC_ELT (condv
, i
);
23224 tree incr
= TREE_VEC_ELT (incrv
, i
);
23226 if (type_dependent_expression_p (decl
)
23227 || TREE_CODE (decl
) == SCOPE_REF
)
23230 if (init
&& type_dependent_expression_p (init
))
23233 if (type_dependent_expression_p (cond
))
23236 if (COMPARISON_CLASS_P (cond
)
23237 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
23238 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
23241 if (TREE_CODE (incr
) == MODOP_EXPR
)
23243 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
23244 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
23247 else if (type_dependent_expression_p (incr
))
23249 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
23251 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
23253 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
23255 tree t
= TREE_OPERAND (incr
, 1);
23256 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
23257 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
23266 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
23267 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
23268 no such TYPE can be found. Note that this function peers inside
23269 uninstantiated templates and therefore should be used only in
23270 extremely limited situations. ONLY_CURRENT_P restricts this
23271 peering to the currently open classes hierarchy (which is required
23272 when comparing types). */
23275 resolve_typename_type (tree type
, bool only_current_p
)
23284 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
23286 scope
= TYPE_CONTEXT (type
);
23287 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
23288 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
23289 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
23290 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
23291 identifier of the TYPENAME_TYPE anymore.
23292 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
23293 TYPENAME_TYPE instead, we avoid messing up with a possible
23294 typedef variant case. */
23295 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
23297 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
23298 it first before we can figure out what NAME refers to. */
23299 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
23301 if (TYPENAME_IS_RESOLVING_P (scope
))
23302 /* Given a class template A with a dependent base with nested type C,
23303 typedef typename A::C::C C will land us here, as trying to resolve
23304 the initial A::C leads to the local C typedef, which leads back to
23305 A::C::C. So we break the recursion now. */
23308 scope
= resolve_typename_type (scope
, only_current_p
);
23310 /* If we don't know what SCOPE refers to, then we cannot resolve the
23312 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
23314 /* If the SCOPE is a template type parameter, we have no way of
23315 resolving the name. */
23316 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
23318 /* If the SCOPE is not the current instantiation, there's no reason
23319 to look inside it. */
23320 if (only_current_p
&& !currently_open_class (scope
))
23322 /* If this is a typedef, we don't want to look inside (c++/11987). */
23323 if (typedef_variant_p (type
))
23325 /* If SCOPE isn't the template itself, it will not have a valid
23326 TYPE_FIELDS list. */
23327 if (CLASS_TYPE_P (scope
)
23328 && same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
23329 /* scope is either the template itself or a compatible instantiation
23330 like X<T>, so look up the name in the original template. */
23331 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
23333 /* scope is a partial instantiation, so we can't do the lookup or we
23334 will lose the template arguments. */
23336 /* Enter the SCOPE so that name lookup will be resolved as if we
23337 were in the class definition. In particular, SCOPE will no
23338 longer be considered a dependent type. */
23339 pushed_scope
= push_scope (scope
);
23340 /* Look up the declaration. */
23341 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
23342 tf_warning_or_error
);
23344 result
= NULL_TREE
;
23346 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
23347 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
23350 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
23351 && TREE_CODE (decl
) == TYPE_DECL
)
23353 result
= TREE_TYPE (decl
);
23354 if (result
== error_mark_node
)
23355 result
= NULL_TREE
;
23357 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
23358 && DECL_CLASS_TEMPLATE_P (decl
))
23362 /* Obtain the template and the arguments. */
23363 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
23364 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
23365 /* Instantiate the template. */
23366 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
23367 /*entering_scope=*/0,
23368 tf_error
| tf_user
);
23369 if (result
== error_mark_node
)
23370 result
= NULL_TREE
;
23373 /* Leave the SCOPE. */
23375 pop_scope (pushed_scope
);
23377 /* If we failed to resolve it, return the original typename. */
23381 /* If lookup found a typename type, resolve that too. */
23382 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
23384 /* Ill-formed programs can cause infinite recursion here, so we
23385 must catch that. */
23386 TYPENAME_IS_RESOLVING_P (type
) = 1;
23387 result
= resolve_typename_type (result
, only_current_p
);
23388 TYPENAME_IS_RESOLVING_P (type
) = 0;
23391 /* Qualify the resulting type. */
23392 quals
= cp_type_quals (type
);
23394 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
23399 /* EXPR is an expression which is not type-dependent. Return a proxy
23400 for EXPR that can be used to compute the types of larger
23401 expressions containing EXPR. */
23404 build_non_dependent_expr (tree expr
)
23408 /* Try to get a constant value for all non-dependent expressions in
23409 order to expose bugs in *_dependent_expression_p and constexpr. */
23410 if (flag_checking
&& cxx_dialect
>= cxx11
)
23411 fold_non_dependent_expr (expr
);
23413 /* Preserve OVERLOADs; the functions must be available to resolve
23416 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
23417 inner_expr
= stmt_expr_value_expr (inner_expr
);
23418 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
23419 inner_expr
= TREE_OPERAND (inner_expr
, 0);
23420 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
23421 inner_expr
= TREE_OPERAND (inner_expr
, 1);
23422 if (is_overloaded_fn (inner_expr
)
23423 || TREE_CODE (inner_expr
) == OFFSET_REF
)
23425 /* There is no need to return a proxy for a variable. */
23428 /* Preserve string constants; conversions from string constants to
23429 "char *" are allowed, even though normally a "const char *"
23430 cannot be used to initialize a "char *". */
23431 if (TREE_CODE (expr
) == STRING_CST
)
23433 /* Preserve void and arithmetic constants, as an optimization -- there is no
23434 reason to create a new node. */
23435 if (TREE_CODE (expr
) == VOID_CST
23436 || TREE_CODE (expr
) == INTEGER_CST
23437 || TREE_CODE (expr
) == REAL_CST
)
23439 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
23440 There is at least one place where we want to know that a
23441 particular expression is a throw-expression: when checking a ?:
23442 expression, there are special rules if the second or third
23443 argument is a throw-expression. */
23444 if (TREE_CODE (expr
) == THROW_EXPR
)
23447 /* Don't wrap an initializer list, we need to be able to look inside. */
23448 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
23451 /* Don't wrap a dummy object, we need to be able to test for it. */
23452 if (is_dummy_object (expr
))
23455 if (TREE_CODE (expr
) == COND_EXPR
)
23456 return build3 (COND_EXPR
,
23458 TREE_OPERAND (expr
, 0),
23459 (TREE_OPERAND (expr
, 1)
23460 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
23461 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
23462 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
23463 if (TREE_CODE (expr
) == COMPOUND_EXPR
23464 && !COMPOUND_EXPR_OVERLOADED (expr
))
23465 return build2 (COMPOUND_EXPR
,
23467 TREE_OPERAND (expr
, 0),
23468 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
23470 /* If the type is unknown, it can't really be non-dependent */
23471 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
23473 /* Otherwise, build a NON_DEPENDENT_EXPR. */
23474 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
23477 /* ARGS is a vector of expressions as arguments to a function call.
23478 Replace the arguments with equivalent non-dependent expressions.
23479 This modifies ARGS in place. */
23482 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
23487 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
23489 tree newarg
= build_non_dependent_expr (arg
);
23491 (*args
)[ix
] = newarg
;
23495 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
23496 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
23497 parms. If set_canonical is true, we set TYPE_CANONICAL on it. */
23500 make_auto_1 (tree name
, bool set_canonical
)
23502 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
23503 TYPE_NAME (au
) = build_decl (input_location
,
23504 TYPE_DECL
, name
, au
);
23505 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
23506 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
23507 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
23508 TYPE_NAME (au
), NULL_TREE
);
23510 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
23511 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
23512 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
23518 make_decltype_auto (void)
23520 return make_auto_1 (get_identifier ("decltype(auto)"), true);
23526 return make_auto_1 (get_identifier ("auto"), true);
23529 /* Make a "constrained auto" type-specifier. This is an
23530 auto type with constraints that must be associated after
23531 deduction. The constraint is formed from the given
23532 CONC and its optional sequence of arguments, which are
23533 non-null if written as partial-concept-id. */
23536 make_constrained_auto (tree con
, tree args
)
23538 tree type
= make_auto_1 (get_identifier ("auto"), false);
23540 /* Build the constraint. */
23541 tree tmpl
= DECL_TI_TEMPLATE (con
);
23544 expr
= build_concept_check (tmpl
, type
, args
);
23546 expr
= build_concept_check (build_overload (tmpl
, NULL_TREE
), type
, args
);
23548 tree constr
= make_predicate_constraint (expr
);
23549 PLACEHOLDER_TYPE_CONSTRAINTS (type
) = constr
;
23551 /* Our canonical type depends on the constraint. */
23552 TYPE_CANONICAL (type
) = canonical_type_parameter (type
);
23554 /* Attach the constraint to the type declaration. */
23555 tree decl
= TYPE_NAME (type
);
23559 /* Given type ARG, return std::initializer_list<ARG>. */
23564 tree std_init_list
= namespace_binding
23565 (get_identifier ("initializer_list"), std_node
);
23567 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
23569 error ("deducing from brace-enclosed initializer list requires "
23570 "#include <initializer_list>");
23571 return error_mark_node
;
23573 argvec
= make_tree_vec (1);
23574 TREE_VEC_ELT (argvec
, 0) = arg
;
23575 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
23576 NULL_TREE
, 0, tf_warning_or_error
);
23579 /* Replace auto in TYPE with std::initializer_list<auto>. */
23582 listify_autos (tree type
, tree auto_node
)
23584 tree init_auto
= listify (auto_node
);
23585 tree argvec
= make_tree_vec (1);
23586 TREE_VEC_ELT (argvec
, 0) = init_auto
;
23587 if (processing_template_decl
)
23588 argvec
= add_to_template_args (current_template_args (), argvec
);
23589 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
23592 /* Hash traits for hashing possibly constrained 'auto'
23593 TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
23595 struct auto_hash
: default_hash_traits
<tree
>
23597 static inline hashval_t
hash (tree
);
23598 static inline bool equal (tree
, tree
);
23601 /* Hash the 'auto' T. */
23604 auto_hash::hash (tree t
)
23606 if (tree c
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
23607 /* Matching constrained-type-specifiers denote the same template
23608 parameter, so hash the constraint. */
23609 return hash_placeholder_constraint (c
);
23611 /* But unconstrained autos are all separate, so just hash the pointer. */
23612 return iterative_hash_object (t
, 0);
23615 /* Compare two 'auto's. */
23618 auto_hash::equal (tree t1
, tree t2
)
23623 tree c1
= PLACEHOLDER_TYPE_CONSTRAINTS (t1
);
23624 tree c2
= PLACEHOLDER_TYPE_CONSTRAINTS (t2
);
23626 /* Two unconstrained autos are distinct. */
23630 return equivalent_placeholder_constraints (c1
, c2
);
23633 /* for_each_template_parm callback for extract_autos: if t is a (possibly
23634 constrained) auto, add it to the vector. */
23637 extract_autos_r (tree t
, void *data
)
23639 hash_table
<auto_hash
> &hash
= *(hash_table
<auto_hash
>*)data
;
23640 if (is_auto_or_concept (t
))
23642 /* All the autos were built with index 0; fix that up now. */
23643 tree
*p
= hash
.find_slot (t
, INSERT
);
23646 /* If this is a repeated constrained-type-specifier, use the index we
23648 idx
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (*p
));
23651 /* Otherwise this is new, so use the current count. */
23653 idx
= hash
.elements () - 1;
23655 TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (t
)) = idx
;
23658 /* Always keep walking. */
23662 /* Return a TREE_VEC of the 'auto's used in type under the Concepts TS, which
23663 says they can appear anywhere in the type. */
23666 extract_autos (tree type
)
23668 hash_set
<tree
> visited
;
23669 hash_table
<auto_hash
> hash (2);
23671 for_each_template_parm (type
, extract_autos_r
, &hash
, &visited
, true);
23673 tree tree_vec
= make_tree_vec (hash
.elements());
23674 for (hash_table
<auto_hash
>::iterator iter
= hash
.begin();
23675 iter
!= hash
.end(); ++iter
)
23678 unsigned i
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (elt
));
23679 TREE_VEC_ELT (tree_vec
, i
)
23680 = build_tree_list (NULL_TREE
, TYPE_NAME (elt
));
23686 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
23687 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
23690 do_auto_deduction (tree type
, tree init
, tree auto_node
)
23692 return do_auto_deduction (type
, init
, auto_node
,
23693 tf_warning_or_error
,
23697 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
23698 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
23699 The CONTEXT determines the context in which auto deduction is performed
23700 and is used to control error diagnostics. */
23703 do_auto_deduction (tree type
, tree init
, tree auto_node
,
23704 tsubst_flags_t complain
, auto_deduction_context context
)
23708 if (init
== error_mark_node
)
23709 return error_mark_node
;
23711 if (type_dependent_expression_p (init
))
23712 /* Defining a subset of type-dependent expressions that we can deduce
23713 from ahead of time isn't worth the trouble. */
23716 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
23717 with either a new invented type template parameter U or, if the
23718 initializer is a braced-init-list (8.5.4), with
23719 std::initializer_list<U>. */
23720 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
23722 if (!DIRECT_LIST_INIT_P (init
))
23723 type
= listify_autos (type
, auto_node
);
23724 else if (CONSTRUCTOR_NELTS (init
) == 1)
23725 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
23728 if (complain
& tf_warning_or_error
)
23730 if (permerror (input_location
, "direct-list-initialization of "
23731 "%<auto%> requires exactly one element"))
23732 inform (input_location
,
23733 "for deduction to %<std::initializer_list%>, use copy-"
23734 "list-initialization (i.e. add %<=%> before the %<{%>)");
23736 type
= listify_autos (type
, auto_node
);
23740 if (type
== error_mark_node
)
23741 return error_mark_node
;
23743 init
= resolve_nondeduced_context (init
);
23745 if (AUTO_IS_DECLTYPE (auto_node
))
23747 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
23748 && !REF_PARENTHESIZED_P (init
)));
23749 targs
= make_tree_vec (1);
23750 TREE_VEC_ELT (targs
, 0)
23751 = finish_decltype_type (init
, id
, tf_warning_or_error
);
23752 if (type
!= auto_node
)
23754 if (complain
& tf_error
)
23755 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
23756 return error_mark_node
;
23761 tree parms
= build_tree_list (NULL_TREE
, type
);
23765 tparms
= extract_autos (type
);
23768 tparms
= make_tree_vec (1);
23769 TREE_VEC_ELT (tparms
, 0)
23770 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
23773 targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
23774 int val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
23775 DEDUCE_CALL
, LOOKUP_NORMAL
,
23776 NULL
, /*explain_p=*/false);
23779 if (processing_template_decl
)
23780 /* Try again at instantiation time. */
23782 if (type
&& type
!= error_mark_node
23783 && (complain
& tf_error
))
23784 /* If type is error_mark_node a diagnostic must have been
23785 emitted by now. Also, having a mention to '<type error>'
23786 in the diagnostic is not really useful to the user. */
23788 if (cfun
&& auto_node
== current_function_auto_return_pattern
23789 && LAMBDA_FUNCTION_P (current_function_decl
))
23790 error ("unable to deduce lambda return type from %qE", init
);
23792 error ("unable to deduce %qT from %qE", type
, init
);
23793 type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
23794 DEDUCE_CALL
, LOOKUP_NORMAL
,
23795 NULL
, /*explain_p=*/true);
23797 return error_mark_node
;
23801 /* Check any placeholder constraints against the deduced type. */
23802 if (flag_concepts
&& !processing_template_decl
)
23803 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (auto_node
))
23805 /* Use the deduced type to check the associated constraints. */
23806 if (!constraints_satisfied_p (constr
, targs
))
23808 if (complain
& tf_warning_or_error
)
23812 case adc_unspecified
:
23813 error("placeholder constraints not satisfied");
23815 case adc_variable_type
:
23816 error ("deduced initializer does not satisfy "
23817 "placeholder constraints");
23819 case adc_return_type
:
23820 error ("deduced return type does not satisfy "
23821 "placeholder constraints");
23823 case adc_requirement
:
23824 error ("deduced expression type does not saatisy "
23825 "placeholder constraints");
23828 diagnose_constraints (input_location
, constr
, targs
);
23830 return error_mark_node
;
23834 if (processing_template_decl
)
23835 targs
= add_to_template_args (current_template_args (), targs
);
23836 return tsubst (type
, targs
, complain
, NULL_TREE
);
23839 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
23843 splice_late_return_type (tree type
, tree late_return_type
)
23845 if (is_auto (type
))
23847 if (late_return_type
)
23848 return late_return_type
;
23850 tree idx
= get_template_parm_index (type
);
23851 if (TEMPLATE_PARM_LEVEL (idx
) <= processing_template_decl
)
23852 /* In an abbreviated function template we didn't know we were dealing
23853 with a function template when we saw the auto return type, so update
23854 it to have the correct level. */
23855 return make_auto_1 (TYPE_IDENTIFIER (type
), true);
23860 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
23861 'decltype(auto)'. */
23864 is_auto (const_tree type
)
23866 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
23867 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
23868 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
23874 /* for_each_template_parm callback for type_uses_auto. */
23877 is_auto_r (tree tp
, void */
*data*/
)
23879 return is_auto_or_concept (tp
);
23882 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
23883 a use of `auto'. Returns NULL_TREE otherwise. */
23886 type_uses_auto (tree type
)
23888 if (type
== NULL_TREE
)
23890 else if (flag_concepts
)
23892 /* The Concepts TS allows multiple autos in one type-specifier; just
23893 return the first one we find, do_auto_deduction will collect all of
23895 if (uses_template_parms (type
))
23896 return for_each_template_parm (type
, is_auto_r
, /*data*/NULL
,
23897 /*visited*/NULL
, /*nondeduced*/true);
23902 return find_type_usage (type
, is_auto
);
23905 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
23906 'decltype(auto)' or a concept. */
23909 is_auto_or_concept (const_tree type
)
23911 return is_auto (type
); // or concept
23914 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
23915 a concept identifier) iff TYPE contains a use of a generic type. Returns
23916 NULL_TREE otherwise. */
23919 type_uses_auto_or_concept (tree type
)
23921 return find_type_usage (type
, is_auto_or_concept
);
23925 /* For a given template T, return the vector of typedefs referenced
23926 in T for which access check is needed at T instantiation time.
23927 T is either a FUNCTION_DECL or a RECORD_TYPE.
23928 Those typedefs were added to T by the function
23929 append_type_to_template_for_access_check. */
23931 vec
<qualified_typedef_usage_t
, va_gc
> *
23932 get_types_needing_access_check (tree t
)
23935 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
23937 if (!t
|| t
== error_mark_node
)
23940 if (!(ti
= get_template_info (t
)))
23943 if (CLASS_TYPE_P (t
)
23944 || TREE_CODE (t
) == FUNCTION_DECL
)
23946 if (!TI_TEMPLATE (ti
))
23949 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
23955 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
23956 tied to T. That list of typedefs will be access checked at
23957 T instantiation time.
23958 T is either a FUNCTION_DECL or a RECORD_TYPE.
23959 TYPE_DECL is a TYPE_DECL node representing a typedef.
23960 SCOPE is the scope through which TYPE_DECL is accessed.
23961 LOCATION is the location of the usage point of TYPE_DECL.
23963 This function is a subroutine of
23964 append_type_to_template_for_access_check. */
23967 append_type_to_template_for_access_check_1 (tree t
,
23970 location_t location
)
23972 qualified_typedef_usage_t typedef_usage
;
23975 if (!t
|| t
== error_mark_node
)
23978 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
23979 || CLASS_TYPE_P (t
))
23981 && TREE_CODE (type_decl
) == TYPE_DECL
23984 if (!(ti
= get_template_info (t
)))
23987 gcc_assert (TI_TEMPLATE (ti
));
23989 typedef_usage
.typedef_decl
= type_decl
;
23990 typedef_usage
.context
= scope
;
23991 typedef_usage
.locus
= location
;
23993 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
23996 /* Append TYPE_DECL to the template TEMPL.
23997 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
23998 At TEMPL instanciation time, TYPE_DECL will be checked to see
23999 if it can be accessed through SCOPE.
24000 LOCATION is the location of the usage point of TYPE_DECL.
24002 e.g. consider the following code snippet:
24009 template<class U> struct S
24011 C::myint mi; // <-- usage point of the typedef C::myint
24016 At S<char> instantiation time, we need to check the access of C::myint
24017 In other words, we need to check the access of the myint typedef through
24018 the C scope. For that purpose, this function will add the myint typedef
24019 and the scope C through which its being accessed to a list of typedefs
24020 tied to the template S. That list will be walked at template instantiation
24021 time and access check performed on each typedefs it contains.
24022 Note that this particular code snippet should yield an error because
24023 myint is private to C. */
24026 append_type_to_template_for_access_check (tree templ
,
24029 location_t location
)
24031 qualified_typedef_usage_t
*iter
;
24034 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
24036 /* Make sure we don't append the type to the template twice. */
24037 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
24038 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
24041 append_type_to_template_for_access_check_1 (templ
, type_decl
,
24045 /* Convert the generic type parameters in PARM that match the types given in the
24046 range [START_IDX, END_IDX) from the current_template_parms into generic type
24050 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
24052 tree current
= current_template_parms
;
24053 int depth
= TMPL_PARMS_DEPTH (current
);
24054 current
= INNERMOST_TEMPLATE_PARMS (current
);
24055 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
24057 for (int i
= 0; i
< start_idx
; ++i
)
24058 TREE_VEC_ELT (replacement
, i
)
24059 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
24061 for (int i
= start_idx
; i
< end_idx
; ++i
)
24063 /* Create a distinct parameter pack type from the current parm and add it
24064 to the replacement args to tsubst below into the generic function
24067 tree o
= TREE_TYPE (TREE_VALUE
24068 (TREE_VEC_ELT (current
, i
)));
24069 tree t
= copy_type (o
);
24070 TEMPLATE_TYPE_PARM_INDEX (t
)
24071 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
24073 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
24074 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
24075 TYPE_MAIN_VARIANT (t
) = t
;
24076 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
24077 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
24078 TREE_VEC_ELT (replacement
, i
) = t
;
24079 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
24082 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
24083 TREE_VEC_ELT (replacement
, i
)
24084 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
24086 /* If there are more levels then build up the replacement with the outer
24089 replacement
= add_to_template_args (template_parms_to_args
24090 (TREE_CHAIN (current_template_parms
)),
24093 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
24096 /* Entries in the decl_constraint hash table. */
24097 struct GTY((for_user
)) constr_entry
24103 /* Hashing function and equality for constraint entries. */
24104 struct constr_hasher
: ggc_ptr_hash
<constr_entry
>
24106 static hashval_t
hash (constr_entry
*e
)
24108 return (hashval_t
)DECL_UID (e
->decl
);
24111 static bool equal (constr_entry
*e1
, constr_entry
*e2
)
24113 return e1
->decl
== e2
->decl
;
24117 /* A mapping from declarations to constraint information. Note that
24118 both templates and their underlying declarations are mapped to the
24119 same constraint information.
24121 FIXME: This is defined in pt.c because garbage collection
24122 code is not being generated for constraint.cc. */
24124 static GTY (()) hash_table
<constr_hasher
> *decl_constraints
;
24126 /* Returns true iff cinfo contains a valid set of constraints.
24127 This is the case when the associated requirements have been
24128 successfully decomposed into lists of atomic constraints.
24129 That is, when the saved assumptions are not error_mark_node. */
24132 valid_constraints_p (tree cinfo
)
24134 gcc_assert (cinfo
);
24135 return CI_ASSUMPTIONS (cinfo
) != error_mark_node
;
24138 /* Returns the template constraints of declaration T. If T is not
24139 constrained, return NULL_TREE. Note that T must be non-null. */
24142 get_constraints (tree t
)
24144 gcc_assert (DECL_P (t
));
24145 if (TREE_CODE (t
) == TEMPLATE_DECL
)
24146 t
= DECL_TEMPLATE_RESULT (t
);
24147 constr_entry elt
= { t
, NULL_TREE
};
24148 constr_entry
* found
= decl_constraints
->find (&elt
);
24155 /* Associate the given constraint information CI with the declaration
24156 T. If T is a template, then the constraints are associated with
24157 its underlying declaration. Don't build associations if CI is
24161 set_constraints (tree t
, tree ci
)
24166 if (TREE_CODE (t
) == TEMPLATE_DECL
)
24167 t
= DECL_TEMPLATE_RESULT (t
);
24168 gcc_assert (!get_constraints (t
));
24169 constr_entry elt
= {t
, ci
};
24170 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, INSERT
);
24171 constr_entry
* entry
= ggc_alloc
<constr_entry
> ();
24176 /* Remove the associated constraints of the declaration T. */
24179 remove_constraints (tree t
)
24181 gcc_assert (DECL_P (t
));
24182 if (TREE_CODE (t
) == TEMPLATE_DECL
)
24183 t
= DECL_TEMPLATE_RESULT (t
);
24185 constr_entry elt
= {t
, NULL_TREE
};
24186 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, NO_INSERT
);
24188 decl_constraints
->clear_slot (slot
);
24191 /* Set up the hash table for constraint association. */
24194 init_constraint_processing (void)
24196 decl_constraints
= hash_table
<constr_hasher
>::create_ggc(37);
24199 /* Set up the hash tables for template instantiations. */
24202 init_template_processing (void)
24204 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
24205 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
24208 /* Print stats about the template hash tables for -fstats. */
24211 print_template_statistics (void)
24213 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
24214 "%f collisions\n", (long) decl_specializations
->size (),
24215 (long) decl_specializations
->elements (),
24216 decl_specializations
->collisions ());
24217 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
24218 "%f collisions\n", (long) type_specializations
->size (),
24219 (long) type_specializations
->elements (),
24220 type_specializations
->collisions ());
24223 #include "gt-cp-pt.h"